From 0a642511e684dac85593a19315d23e56fd24fecd Mon Sep 17 00:00:00 2001 From: Polyglot AI <293096396+polyglotAI-bot@users.noreply.github.com> Date: Wed, 18 Nov 2026 15:44:12 +0000 Subject: [PATCH 01/11] docs(agents): add the issue-priority skill for the Priority issue field Add .claude/skills/issue-priority/SKILL.md: the rules for the org issue field Priority (Urgent, High, Medium, Low). People and automated triage use the same file. AGENTS.md points to it in a new Issue triage section. Co-Authored-By: Claude Opus 5.5 --- .claude/CLAUDE.md | 6 + .claude/skills/issue-priority/SKILL.md | 152 +++++++++++++++++++++++++ 2 files changed, 158 insertions(+) create mode 100644 .claude/skills/issue-priority/SKILL.md diff --git a/.claude/CLAUDE.md b/.claude/CLAUDE.md index bb5eed59..b9841104 100644 --- a/.claude/CLAUDE.md +++ b/.claude/CLAUDE.md @@ -96,6 +96,12 @@ runtime catching it?* If yes, redesign. --- +## Issue triage + +To set, check, or explain the Priority of an issue, follow [`.claude/skills/issue-priority/SKILL.md`](.claude/skills/issue-priority/SKILL.md). It is the single source of truth for the priority rules. + +--- + ## Workflow - Do not commit directly to `main`. All changes go through a pull request. diff --git a/.claude/skills/issue-priority/SKILL.md b/.claude/skills/issue-priority/SKILL.md new file mode 100644 index 00000000..58f64f14 --- /dev/null +++ b/.claude/skills/issue-priority/SKILL.md @@ -0,0 +1,152 @@ +--- +name: issue-priority +description: > + Decide the priority of a `ClickHouse/ch-go` issue: `Urgent`, `High`, + `Medium`, or `Low`, for the org issue field **Priority**. Use this skill when + the task is to "prioritize", "set the priority of", "rate", or "triage" an + issue, or to explain why an issue has a given priority. It defines the reach + tiers of the packages, the impact classes, the severity rows, the base-level + matrix, the modifiers, and the confidence. +--- + +# Issue priority + +This skill is the single source of truth for the **Priority** of +`ClickHouse/ch-go` issues. People and automated triage use the same rules. + +The value goes into the org issue field **Priority** (`Urgent`, `High`, +`Medium`, `Low`). The field is visible to org members only. An automated tool +sets the value once, never changes a value that is already set, and keeps the +level and its reason out of public comments. + +## When to set no priority + +Set no priority when one of these is true: + +- A maintainer can close the issue with no further action: it is already fixed + on `main`, a duplicate, works as intended, already supported, answered, or + obsolete. +- Only a deprecated public API reaches the defect (a `Deprecated:` paragraph in + the Go doc comment, or docs that call the API deprecated; for example + `Query.OnProfileEvent` and `Query.OnLog`). Fixes to deprecated code are not + released. +- The issue is a question, or it is about CI, the release process, or a + discussion. + +## 1. Reach + +ch-go has two kinds of users: applications that call ch-go directly, and +`clickhouse-go`, which uses the ch-go column types and buffers (`proto`) and +the compression (`compress`) for all its users. The reach is the tier of the +most-used public path that reaches the defect, not the tier of the file that +contains it. + +For code that clickhouse-go calls, the reach is the higher of two tiers: the +tier in the table below, and the tier that the clickhouse-go priority rules +([`.claude/skills/issue-priority/SKILL.md`](https://github.com/ClickHouse/clickhouse-go/blob/main/.claude/skills/issue-priority/SKILL.md)) +give the clickhouse-go path that reaches the defect. For example, a +`proto.ColDateTime64` decode defect that clickhouse-go reaches through +`Rows.Scan` is Core. To find the calls, search a clickhouse-go checkout: +`grep -rn 'ClickHouse/ch-go/' --include=*.go`. clickhouse-go uses +`proto.Buffer`, `proto.Reader`, `proto.Block`, the server packets, the +`Col*` types of its scalar column types, and `compress`. It has its own +`Array`, `Map`, `Nullable`, `LowCardinality`, and `Tuple` code, so a defect in +`ColArr`, `ColMap`, `ColNullable`, `ColLowCardinality`, or `ColTuple` reaches +only direct ch-go users. + +| Tier | Public paths | +| --------- | ------------ | +| Core | `ch.Dial` and `Client.Do` with `Query.Body`, `Query.Input`, `Query.Result`, `OnInput`, and `OnResult` (`proto.Input`, `proto.Results`); `Client.Ping`, `Client.Close`; the handshake, username and password authentication, TLS, timeouts, and context cancellation; errors (`*ch.Exception`, `ch.IsErr`, `ch.AsException`); block encoding and decoding (`proto.Block`, `proto.Buffer`, `proto.Reader`); compression (`compress`: LZ4, ZSTD); these column types: integers up to 64 bits, `ColFloat32`, `ColFloat64`, `ColBool`, `ColStr`, `ColFixedStr`, `ColDate`, `ColDate32`, `ColDateTime`, `ColDateTime64`, `ColDecimal32` to `ColDecimal256`, `ColUUID`, `ColEnum`, `ColEnum8`, `ColEnum16`, `ColNullable`, `ColLowCardinality`, `ColArr`, `ColMap`, `ColTuple` | +| Common | `chpool`; `proto.ColAuto` and `proto.Results.Auto`; query parameters (`Query.Parameters`); `Query.Settings`, `Query.QueryID`, `Query.QuotaKey`; the callbacks `OnProgress`, `OnProfile`, `OnProfileEvents`, `OnLogs`; external data (`Query.ExternalData`, `Query.ExternalTable`); `ColRaw`; the column types `ColIPv4`, `ColIPv6`, `ColInt128`, `ColInt256`, `ColUInt128`, `ColUInt256` | +| Narrow | the other column types: `ColPoint`, `ColInterval`, `ColTime`, `ColTime64`, `ColBFloat16`, `ColQBit`, `ColNothing`, `ColJSONStr`, `ColLowCardinalityRaw`; SSH key authentication (`ssh`, `Options.SSHSigner`); OpenTelemetry (`otelch`, `Options.TracerProvider`, `Options.MeterProvider`); a custom dialer (`Options.Dialer`); inter-server queries (`Query.Secret`, `Query.InitialUser`); `Options.ProtocolVersion` | +| Satellite | `cht` (the test helper that starts a local server), `internal/` (`gold`, `e2e`, `ztest`, `cmd/`), `examples/`, `_golden/`, `README.md`, the agent skills and agents in `.claude/` | + +## 2. Severity + +First name the **impacts** of the issue. The impact classes are the same in +every ClickHouse client repository. An issue has none, one, or more of them: + +| Impact | Use when | +| -------------- | -------- | +| Security | a **vulnerability**: a defect makes the protection weaker: it exposes credentials or data, lets a value change the meaning of a query, skips or weakens a TLS or identity check, or lets a remote party stop the client. Also **authentication**: an authentication method that does not work or is missing | +| Data integrity | data that the caller wrote, or a result that the caller reads, is missing, incomplete, or different from the value given or stored, and the client reports no error; this includes a failed operation that the client reports as a success | +| Stability | the process stops in a way that the caller cannot handle as a normal error, a call does not return, or a resource leaks until none is left | +| Performance | the result is correct, but the operation is too slow, or uses too much memory or CPU | + +Give an impact only when the issue or a reproduction shows it. Most issues have +none. + +Then use the first severity row that fits. With more than one impact, the +highest row applies: + +| Severity | Use when | +| ----------------------- | -------- | +| Wrong data or security | impact **Data integrity**: the client returns or stores wrong or incomplete data with no error, or reports success for a query that failed; or impact **Security** with a vulnerability: a security defect | +| Broken, no workaround | the feature fails (an error, a hang, a panic, a leak that ends in a crash or in exhausted connections), and the caller has no reasonable workaround; also a wrong or incomplete error with no workaround: the failure is reported, but its type, code, or message is wrong or lost. The impact **Stability** (a hang, a panic, such a leak) uses this row when the caller has no reasonable workaround | +| Workaround exists | the feature fails, but the caller can avoid the failure with a small change in their own code (name the workaround in the reason); also impact **Performance**: a result that is correct but slow or uses too much memory | +| Cosmetic, docs, feature | wrong log or message text, documentation, a feature request | + +An issue that has the impact Security with no vulnerability (an authentication +method that does not work or is missing) does not use the first row. Rate an +authentication method that does not work by its failure ("Broken, no +workaround" or "Workaround exists"), and a request for a missing method as a +feature request. + +## 3. Base level + +| Severity ↓ / Reach → | Core | Common | Narrow | Satellite | +| ----------------------- | ------ | ------ | ------ | --------- | +| Wrong data or security | Urgent | Urgent | High | Medium | +| Broken, no workaround | High | High | Medium | Low | +| Workaround exists | Medium | Medium | Low | Low | +| Cosmetic, docs, feature | Low | Low | Low | Low | + +## 4. Modifiers + +Apply them in this order: + +1. **Security with a shown path from untrusted input.** The issue or a + reproduction shows how a value that an application takes from its users + reaches the defect: `Urgent` at any reach. Skip the other modifiers. A + defect in the encoding of query parameters (`query_params.go`) that lets a + parameter value change the meaning of the query is a candidate: look for + such a path. If none is shown, rate the defect by the + failure that it shows. A report that discloses a vulnerability goes to a + private channel, not to a public issue. +2. **Regression in the latest published release:** up one level. This can give + `Urgent`. It is a regression only when the latest release shows the problem + and the release before it does not. The tags are `vX.Y.Z` (for example + `v0.76.0`). +3. **Customer request in Linear.** The issue links (`linear.app`) a Linear + issue for a customer request: up one level, but never to `Urgent` (`High` + stays `High`). + +## 5. Confidence + +A missing reproduction lowers the confidence, not the level. Record the +confidence with the value when the tool that sets it supports it: + +| Confidence | Use when | +| ---------- | -------- | +| `HIGH` | a run shows the problem (or, for a feature, code inspection confirms its absence on `main`) | +| `MEDIUM` | code inspection shows a defect, but no reproduction was run (for example, it needs ClickHouse Cloud) | +| `LOW` | the report lacks what a reproduction needs, or a run did not show the problem | + +## 6. Reason + +Write one line with the value: + +` () · · · → .` + +Name the workaround when the severity is "Workaround exists". When the +confidence is `LOW`, say what is missing. When the tier comes from a +clickhouse-go path, name that path (for example +`Core (clickhouse-go Rows.Scan of DateTime64)`). + +## 7. Fixes that clickhouse-go needs + +A fix in code that clickhouse-go calls reaches clickhouse-go users only after a +ch-go release and a dependency update in clickhouse-go (`go.mod`). When the +tier comes from a clickhouse-go path, the fix PR says that clickhouse-go needs +that update. A change to an exported `proto` symbol can break clickhouse-go +(`AGENTS.md`). The priority stays as the table gives it. From d1ec948896b252b598fcf4356da87896246a6f15 Mon Sep 17 00:00:00 2001 From: Polyglot AI <293096396+polyglotAI-bot@users.noreply.github.com> Date: Wed, 18 Nov 2026 15:49:20 +0000 Subject: [PATCH 02/11] docs(agents): link the issue-priority skill from the repo root AGENTS.md is a symlink to .claude/CLAUDE.md, so a relative link resolves differently in the two files. A repo-root path works in both. Co-Authored-By: Claude Opus 5.5 --- .claude/CLAUDE.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/.claude/CLAUDE.md b/.claude/CLAUDE.md index b9841104..298f2dfa 100644 --- a/.claude/CLAUDE.md +++ b/.claude/CLAUDE.md @@ -98,7 +98,7 @@ runtime catching it?* If yes, redesign. ## Issue triage -To set, check, or explain the Priority of an issue, follow [`.claude/skills/issue-priority/SKILL.md`](.claude/skills/issue-priority/SKILL.md). It is the single source of truth for the priority rules. +To set, check, or explain the Priority of an issue, follow [`.claude/skills/issue-priority/SKILL.md`](/.claude/skills/issue-priority/SKILL.md). It is the single source of truth for the priority rules. --- From 747031452a26aa6642964e66e03f0fdb42e90c63 Mon Sep 17 00:00:00 2001 From: Polyglot AI <293096396+polyglotAI-bot@users.noreply.github.com> Date: Wed, 18 Nov 2026 16:34:24 +0000 Subject: [PATCH 03/11] docs(agents): define reach; add panic and ingestion rules to issue priority Review feedback (kavirajk): say in plain words what reach means, rate a panic at least High, and rate an ingestion defect that stores wrong data one level up, so that a query defect ranks below both. Co-Authored-By: Claude Opus 5.5 --- .claude/skills/issue-priority/SKILL.md | 36 ++++++++++++++++++++++++-- 1 file changed, 34 insertions(+), 2 deletions(-) diff --git a/.claude/skills/issue-priority/SKILL.md b/.claude/skills/issue-priority/SKILL.md index 58f64f14..ca74004d 100644 --- a/.claude/skills/issue-priority/SKILL.md +++ b/.claude/skills/issue-priority/SKILL.md @@ -35,6 +35,21 @@ Set no priority when one of these is true: ## 1. Reach +**Reach** tells how many applications can hit the defect. It comes from the +public API that leads to the code with the defect: an API that almost every +application calls has a high reach, an API that few applications use has a low +reach. There are four tiers, highest first: + +- **Core:** almost every application calls this API. +- **Common:** many applications use it, but not all. +- **Narrow:** few applications use it (rare types, experimental APIs, special + setups). +- **Satellite:** applications do not import it (examples, tests, docs, tools). + +To find the tier, find the most-used public API that reaches the defect, and +look it up in the table below. Use the API, not the file that contains the +defect. + ch-go has two kinds of users: applications that call ch-go directly, and `clickhouse-go`, which uses the ch-go column types and buffers (`proto`) and the compression (`compress`) for all its users. The reach is the tier of the @@ -113,14 +128,31 @@ Apply them in this order: such a path. If none is shown, rate the defect by the failure that it shows. A report that discloses a vulnerability goes to a private channel, not to a public issue. -2. **Regression in the latest published release:** up one level. This can give +2. **Panic.** The library panics: a Go `panic` in ch-go code, not in the + caller's code, and not in `cht`, `internal/`, `examples/`, or the tests. + The level is at least `High`, at any reach. Library code must not panic on + input from the network or from the caller (`AGENTS.md`), and a panic stops + the whole process unless the caller recovers it. +3. **Ingestion.** The defect is on the insert path (`Client.Do` with + `Query.Input` or `OnInput`, block encoding, the `Col*` encoders), and the + client sends data that is lost, corrupted, or different from the given + value, with no error. This includes a missing column value, and a column + that gets a default value in place of the given value: up one level. This + can give `Urgent`. Wrong data in a table stays wrong after the fix; a defect + on the read path does not change the stored data. +4. **Regression in the latest published release:** up one level. This can give `Urgent`. It is a regression only when the latest release shows the problem and the release before it does not. The tags are `vX.Y.Z` (for example `v0.76.0`). -3. **Customer request in Linear.** The issue links (`linear.app`) a Linear +5. **Customer request in Linear.** The issue links (`linear.app`) a Linear issue for a customer request: up one level, but never to `Urgent` (`High` stays `High`). +A defect on the read path (`Query.Result`, `OnResult`, the `Col*` decoders) +that does not panic gets neither of rules 2 and 3. So at the same reach and +severity, a read defect ranks below a panic and below an ingestion defect. For +code that clickhouse-go calls, the clickhouse-go rules have the same two rules. + ## 5. Confidence A missing reproduction lowers the confidence, not the level. Record the From dca1d9e66f1740574b060f6b823cf0a7eb103875 Mon Sep 17 00:00:00 2001 From: Polyglot AI <293096396+polyglotAI-bot@users.noreply.github.com> Date: Wed, 18 Nov 2026 17:47:54 +0000 Subject: [PATCH 04/11] docs(agents): handle vulnerabilities that are not public yet in issue priority A security issue must not stay public with a description of how to reproduce it. A confirmed vulnerability that is not public yet goes to a private GitHub vulnerability report; the public issue gets no Priority, and the rating goes into the report as the proposed severity. Co-Authored-By: Claude Opus 5.5 --- .claude/skills/issue-priority/SKILL.md | 27 +++++++++++++++++++++++--- 1 file changed, 24 insertions(+), 3 deletions(-) diff --git a/.claude/skills/issue-priority/SKILL.md b/.claude/skills/issue-priority/SKILL.md index ca74004d..3983af21 100644 --- a/.claude/skills/issue-priority/SKILL.md +++ b/.claude/skills/issue-priority/SKILL.md @@ -33,6 +33,26 @@ Set no priority when one of these is true: - The issue is a question, or it is about CI, the release process, or a discussion. +## Vulnerabilities that are not public yet + +A security issue must not stay public with a description of how to reproduce +it. When a reproduction confirms a vulnerability that is not public yet +(credentials or data are exposed, a value changes the meaning of a query, a TLS +or identity check is skipped or weakened, or input that an untrusted party +controls stops the client): + +- Report it in a private GitHub vulnerability report for this repository + (**Security** → **Report a vulnerability**), not in a public issue or + comment. +- Set no Priority on the public issue. The issue is closed with a comment that + gives no details, and a repository administrator can delete it. +- Rate the vulnerability with the rules below, and put the level and its reason + into the private report as the proposed severity. + +A vulnerability that is already public (a published CVE or GHSA, for example in +a dependency), and an authentication method that does not work or is missing, +get a Priority on the issue as usual. + ## 1. Reach **Reach** tells how many applications can hit the defect. It comes from the @@ -125,9 +145,10 @@ Apply them in this order: reaches the defect: `Urgent` at any reach. Skip the other modifiers. A defect in the encoding of query parameters (`query_params.go`) that lets a parameter value change the meaning of the query is a candidate: look for - such a path. If none is shown, rate the defect by the - failure that it shows. A report that discloses a vulnerability goes to a - private channel, not to a public issue. + such a path. If none is shown, rate the defect by the failure that it shows. + A vulnerability that is not public yet goes to a private vulnerability + report, not to a public issue (see "Vulnerabilities that are not public + yet"). 2. **Panic.** The library panics: a Go `panic` in ch-go code, not in the caller's code, and not in `cht`, `internal/`, `examples/`, or the tests. The level is at least `High`, at any reach. Library code must not panic on From 319e835ea130097d3d43cd3cd88c165d5141cc7d Mon Sep 17 00:00:00 2001 From: Polyglot AI <293096396+polyglotAI-bot@users.noreply.github.com> Date: Wed, 18 Nov 2026 17:56:43 +0000 Subject: [PATCH 05/11] docs(agents): align the private-report rule with the security severity row Review feedback (Copilot on clickhouse-js#1155, Bugbot on clickhouse-cpp#613): - the private-report rule also applies when code inspection confirms the vulnerability; - copy the issue text into the private report, and ask an administrator to delete the issue: closing does not hide its text; - the impact Security names memory corruption, and input from the application's users that stops the client; a hang or a crash that only a hostile server or network causes is Stability. AGENTS.md: a vulnerability that is not public yet goes into a private security report, never into an issue or a pull request. Co-Authored-By: Claude Opus 5.5 --- .claude/CLAUDE.md | 2 ++ .claude/skills/issue-priority/SKILL.md | 23 ++++++++++++++--------- 2 files changed, 16 insertions(+), 9 deletions(-) diff --git a/.claude/CLAUDE.md b/.claude/CLAUDE.md index 298f2dfa..c6fd4eec 100644 --- a/.claude/CLAUDE.md +++ b/.claude/CLAUDE.md @@ -100,6 +100,8 @@ runtime catching it?* If yes, redesign. To set, check, or explain the Priority of an issue, follow [`.claude/skills/issue-priority/SKILL.md`](/.claude/skills/issue-priority/SKILL.md). It is the single source of truth for the priority rules. +A vulnerability that is not public yet goes into a private security report (**Security** → **Report a vulnerability**), never into an issue or a pull request. The section "Vulnerabilities that are not public yet" of that skill says how to handle it. + --- ## Workflow diff --git a/.claude/skills/issue-priority/SKILL.md b/.claude/skills/issue-priority/SKILL.md index 3983af21..6028f936 100644 --- a/.claude/skills/issue-priority/SKILL.md +++ b/.claude/skills/issue-priority/SKILL.md @@ -36,16 +36,21 @@ Set no priority when one of these is true: ## Vulnerabilities that are not public yet A security issue must not stay public with a description of how to reproduce -it. When a reproduction confirms a vulnerability that is not public yet -(credentials or data are exposed, a value changes the meaning of a query, a TLS -or identity check is skipped or weakened, or input that an untrusted party -controls stops the client): +it. This section applies when a reproduction or code inspection confirms a +vulnerability that is not public yet (impact Security, part vulnerability, in +section 2): a leak of credentials or data, a value that changes the meaning of +a query, a TLS or identity check that is skipped or weakened, memory +corruption, or input from the application's users that stops the client. A +hang or a crash that only a hostile server or network causes is not one: rate +it by the failure, as usual. - Report it in a private GitHub vulnerability report for this repository - (**Security** → **Report a vulnerability**), not in a public issue or - comment. -- Set no Priority on the public issue. The issue is closed with a comment that - gives no details, and a repository administrator can delete it. + (**Security** → **Report a vulnerability**), never in a public issue, + comment, or pull request. If a public issue reports it, copy the title, the + text, and the comments of the issue into the report first. +- Set no Priority on the public issue. Close it with a comment that gives no + details, and ask a repository administrator to delete it: closing does not + hide the text of the issue. - Rate the vulnerability with the rules below, and put the level and its reason into the private report as the proposed severity. @@ -103,7 +108,7 @@ every ClickHouse client repository. An issue has none, one, or more of them: | Impact | Use when | | -------------- | -------- | -| Security | a **vulnerability**: a defect makes the protection weaker: it exposes credentials or data, lets a value change the meaning of a query, skips or weakens a TLS or identity check, or lets a remote party stop the client. Also **authentication**: an authentication method that does not work or is missing | +| Security | a **vulnerability**: a defect makes the protection weaker: it exposes credentials or data, lets a value change the meaning of a query, skips or weakens a TLS or identity check, corrupts memory (an out-of-bounds write, a use after free), or lets input that the application takes from its users stop the client (a hang or a crash that only a hostile server or network causes is Stability). Also **authentication**: an authentication method that does not work or is missing | | Data integrity | data that the caller wrote, or a result that the caller reads, is missing, incomplete, or different from the value given or stored, and the client reports no error; this includes a failed operation that the client reports as a success | | Stability | the process stops in a way that the caller cannot handle as a normal error, a call does not return, or a resource leaks until none is left | | Performance | the result is correct, but the operation is too slow, or uses too much memory or CPU | From 90529bfb6c499b3a6ecb5d4bf4b67357d7fdd909 Mon Sep 17 00:00:00 2001 From: Polyglot AI <293096396+polyglotAI-bot@users.noreply.github.com> Date: Wed, 18 Nov 2026 18:15:57 +0000 Subject: [PATCH 06/11] docs(agents): code inspection can show an impact in issue priority Review feedback (Bugbot on clickhouse-js#1155): the private-report rule accepts a vulnerability that code inspection confirms, but section 2 gave an impact only when the issue or a reproduction showed it. Section 2 now also accepts code inspection, as section 5 already does (confidence MEDIUM). Co-Authored-By: Claude Opus 5.5 --- .claude/skills/issue-priority/SKILL.md | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.claude/skills/issue-priority/SKILL.md b/.claude/skills/issue-priority/SKILL.md index 6028f936..8b9e4d13 100644 --- a/.claude/skills/issue-priority/SKILL.md +++ b/.claude/skills/issue-priority/SKILL.md @@ -113,8 +113,8 @@ every ClickHouse client repository. An issue has none, one, or more of them: | Stability | the process stops in a way that the caller cannot handle as a normal error, a call does not return, or a resource leaks until none is left | | Performance | the result is correct, but the operation is too slow, or uses too much memory or CPU | -Give an impact only when the issue or a reproduction shows it. Most issues have -none. +Give an impact only when the issue, a reproduction, or code inspection of the +current code shows it. Most issues have none. Then use the first severity row that fits. With more than one impact, the highest row applies: From 9af26c9932f962c70eaf2892c5ff911eb140fc97 Mon Sep 17 00:00:00 2001 From: Polyglot AI <293096396+polyglotAI-bot@users.noreply.github.com> Date: Wed, 18 Nov 2026 18:17:22 +0000 Subject: [PATCH 07/11] docs(agents): memory corruption stays a vulnerability with a hostile server Security review (ConnectorSec on clickhouse-odbc#615): the exclusion "a hang or a crash that only a hostile server or network causes" also covered memory corruption, which a crafted server response causes and which anyone on the network path can send over plain HTTP. The exclusion now covers hangs and crashes with no memory corruption only, and a crash on server data must have memory corruption ruled out by code inspection before it is rated by its failure. Co-Authored-By: Claude Opus 5.5 --- .claude/skills/issue-priority/SKILL.md | 13 ++++++++----- 1 file changed, 8 insertions(+), 5 deletions(-) diff --git a/.claude/skills/issue-priority/SKILL.md b/.claude/skills/issue-priority/SKILL.md index 8b9e4d13..20eefb0b 100644 --- a/.claude/skills/issue-priority/SKILL.md +++ b/.claude/skills/issue-priority/SKILL.md @@ -39,10 +39,13 @@ A security issue must not stay public with a description of how to reproduce it. This section applies when a reproduction or code inspection confirms a vulnerability that is not public yet (impact Security, part vulnerability, in section 2): a leak of credentials or data, a value that changes the meaning of -a query, a TLS or identity check that is skipped or weakened, memory -corruption, or input from the application's users that stops the client. A -hang or a crash that only a hostile server or network causes is not one: rate -it by the failure, as usual. +a query, a TLS or identity check that is skipped or weakened, memory corruption +(also when only a hostile server or network causes it), or input from the +application's users that stops the client. A hang, or a crash with no memory +corruption, that only a hostile server or network causes is not one: rate it by +the failure, as usual. A crash while the client reads data from the server (for +example an access violation or `SIGSEGV`) can be memory corruption: rule that +out by code inspection before you rate it by the failure. - Report it in a private GitHub vulnerability report for this repository (**Security** → **Report a vulnerability**), never in a public issue, @@ -108,7 +111,7 @@ every ClickHouse client repository. An issue has none, one, or more of them: | Impact | Use when | | -------------- | -------- | -| Security | a **vulnerability**: a defect makes the protection weaker: it exposes credentials or data, lets a value change the meaning of a query, skips or weakens a TLS or identity check, corrupts memory (an out-of-bounds write, a use after free), or lets input that the application takes from its users stop the client (a hang or a crash that only a hostile server or network causes is Stability). Also **authentication**: an authentication method that does not work or is missing | +| Security | a **vulnerability**: a defect makes the protection weaker: it exposes credentials or data, lets a value change the meaning of a query, skips or weakens a TLS or identity check, corrupts memory (an out-of-bounds write, a use after free, also when only a hostile server or network causes it), or lets input that the application takes from its users stop the client (a hang, or a crash with no memory corruption, that only a hostile server or network causes is Stability). Also **authentication**: an authentication method that does not work or is missing | | Data integrity | data that the caller wrote, or a result that the caller reads, is missing, incomplete, or different from the value given or stored, and the client reports no error; this includes a failed operation that the client reports as a success | | Stability | the process stops in a way that the caller cannot handle as a normal error, a call does not return, or a resource leaks until none is left | | Performance | the result is correct, but the operation is too slow, or uses too much memory or CPU | From 44b9f0837eff68503d1c8a9705485fbf76c4c998 Mon Sep 17 00:00:00 2001 From: Polyglot AI <293096396+polyglotAI-bot@users.noreply.github.com> Date: Wed, 18 Nov 2026 18:37:31 +0000 Subject: [PATCH 08/11] docs(agents): add the issue-classification skill; issue priority uses it Each ClickHouse client repository gets the same classification skill (.claude/skills/issue-classification/SKILL.md): the impacts (Security, Data integrity, Stability, Performance), the areas, the boundaries, the test for a vulnerability that is not public yet, and how to write the classification. Any agent can then classify an issue in the repository. A section "This repository" at the end holds local changes. The issue-priority skill no longer copies the impact definitions: it points to the classification skill and keeps the reach tiers, severity rows, matrix, modifiers, and the handling of a vulnerability. AGENTS.md points to both skills. Co-Authored-By: Claude Opus 5.5 --- .claude/CLAUDE.md | 4 +- .claude/skills/issue-classification/SKILL.md | 171 +++++++++++++++++++ .claude/skills/issue-priority/SKILL.md | 42 ++--- 3 files changed, 190 insertions(+), 27 deletions(-) create mode 100644 .claude/skills/issue-classification/SKILL.md diff --git a/.claude/CLAUDE.md b/.claude/CLAUDE.md index c6fd4eec..3a69d37e 100644 --- a/.claude/CLAUDE.md +++ b/.claude/CLAUDE.md @@ -100,7 +100,9 @@ runtime catching it?* If yes, redesign. To set, check, or explain the Priority of an issue, follow [`.claude/skills/issue-priority/SKILL.md`](/.claude/skills/issue-priority/SKILL.md). It is the single source of truth for the priority rules. -A vulnerability that is not public yet goes into a private security report (**Security** → **Report a vulnerability**), never into an issue or a pull request. The section "Vulnerabilities that are not public yet" of that skill says how to handle it. +To classify an issue (its impacts and its area), follow [`.claude/skills/issue-classification/SKILL.md`](/.claude/skills/issue-classification/SKILL.md). + +A vulnerability that is not public yet goes into a private security report (**Security** → **Report a vulnerability**), never into an issue or a pull request. The classification skill defines such a vulnerability, and the priority skill says how to handle the public issue. --- diff --git a/.claude/skills/issue-classification/SKILL.md b/.claude/skills/issue-classification/SKILL.md new file mode 100644 index 00000000..2858784e --- /dev/null +++ b/.claude/skills/issue-classification/SKILL.md @@ -0,0 +1,171 @@ +--- +name: issue-classification +description: > + The classes of an issue in this ClickHouse client repository: the impacts + (Security, Data integrity, Stability, Performance) and the area (Connectivity, + Data types & formats, Queries, Configuration, API & diagnostics, Environment, + Docs & project, Other). Use this skill when the task is to "classify an + issue" or "give the classes of an issue", and when you triage, file, or + prioritize an issue: the issue-priority skill uses the impacts. +--- + +# Issue classification + +The classes name **what kind of problem an issue is about**, with the same words in every +ClickHouse client repo. They are an input to the priority, and they make issue counts +comparable across clients. + +An issue has: + +- **Impacts** — what goes wrong: none, one, or more of the four impact classes. +- **One area** — the part of the client whose behavior is wrong or missing. + +The classes do not replace the kind of request (bug, feature, question) or the reach tier of +a repo's priority rules. + +Every ClickHouse client repository has a copy of this file, so that any agent can classify an +issue in the repository. Keep the copies the same where you can, so that the classes mean the +same in every client. Put a change that applies only to this repository in the section "This +repository" at the end. + +## Rules + +1. Give each impact that applies, and one area. +2. Use only what the issue, a reproduction, or code inspection of the current code + **shows**. Do not give a class for an effect + that is only possible. Classes can raise the priority, so each class needs evidence. +3. Classify by the **observed effect**, not by the location of the code. Example: a + connection-string defect that makes the client drop rows with no error has the impact + Data integrity. +4. Data integrity and Stability are for defects only. Security and Performance are also for + feature requests: a new authentication method, a request to make an operation faster. +5. An issue with no harm has no impact. This is the normal case. + +## Impact classes + +| Impact | Use when | +|---|---| +| **Security** | Two parts. A **vulnerability**: a defect makes the protection weaker: it exposes credentials or data, lets a value change the meaning of a query (injection), skips or weakens a TLS or identity check, corrupts memory (an out-of-bounds write, a use after free, also when only a hostile server or network causes it), or lets input that the application takes from its users stop the client; also a vulnerable dependency. A hang, or a crash with no memory corruption, that only a hostile server or network causes is Stability, not Security. **Authentication**: an authentication method that does not work or is missing, and the handling of secrets. Say which part applies: the priority rules of a repo rate the two parts differently. | +| **Data integrity** | Data that the caller wrote, or a result that the caller reads, is missing, incomplete, or different from the value given or stored, and the client reports no error. This includes a failed operation that the client reports as a success, a server error that the client ignores, overflow, lost precision, a time zone shift, a wrong decode, a stream that loses synchronization, a duplicate write, and a write to the wrong table. | +| **Stability** | The process stops in a way that the caller cannot handle as a normal error (abort, segmentation fault, unrecovered panic, stack overflow), a call does not return (deadlock, hang), or a resource leaks until none is left (connections, sockets, memory). Also a thread-safety defect. | +| **Performance** | The result is correct, but the operation is too slow, or uses too much memory or CPU. Also a request to make an operation faster. | + +Boundaries: + +- **Data integrity needs "no error".** When the client rejects a value with an error, the + issue has no Data integrity impact. When the caller gets an error, but the error is wrong + or not clear, the issue has no Data integrity impact either: it has the area API & + diagnostics. +- **Security and values that are not quoted.** A value or an identifier that the client + does not quote or escape gets Security only when the issue shows a path from untrusted + input. A string value that leaves its literal because the client does not escape it is + such a path. An identifier that the client does not quote, with no such path, is the area + Queries with no impact. +- **TLS.** A TLS check that the client skips or weakens is Security. A connection with TLS + that fails has no impact; its area is Connectivity. +- **Memory.** High memory use without a failure is Performance, not Stability. +- **An error is not Stability.** A normal exception or error value is not a crash. In Go + and Rust, a panic that the library does not recover is Stability. In Java, a + `StackOverflowError`, `OutOfMemoryError`, or `VerifyError` is Stability. + +## A vulnerability that is not public yet + +A security issue must not stay public with a description of how to reproduce it. An issue +is a **confirmed vulnerability** when a run or code inspection shows one of these: + +- credentials or data are exposed to a party that must not get them; +- a value changes the meaning of a query (injection); +- a TLS or identity check is skipped or weakened; +- memory corruption (an out-of-bounds write, a use after free), also when only a hostile + server or network causes it; +- input that the application takes from its users stops the client. + +A hang, or a crash with no memory corruption, that only a hostile server or network causes is +not a vulnerability: it is Stability, and it is triaged in public. A crash while the client +reads data from the server (for example an access violation or `SIGSEGV`) can be memory +corruption: rule that out by code inspection before you treat it as Stability. + +Never put a confirmed vulnerability into a public comment, issue, pull request, or +Classification line. Report it in a private GitHub vulnerability report for this repository +(**Security** → **Report a vulnerability**). The issue-priority skill of this repository says +how to handle the public issue and how to rate the vulnerability. When you can neither confirm +nor rule out a vulnerability, do not discuss it in public either: ask a maintainer in private, +or send a private report that says what is not confirmed. + +These are not affected: a vulnerability that is already public (a published CVE or GHSA, for +example in a dependency), and the part authentication (a method that does not work or is +missing). Classify them as usual. + +## Area classes + +| Area | Scope | +|---|---| +| **Connectivity** | Connect and handshake, a connection with TLS, proxies and redirects, the connection pool, keep-alive, reconnect and failover, retries, timeouts, cancellation, the transport (HTTP, native TCP), compression on the wire. | +| **Data types & formats** | Parsing of type names, encoding and decoding of values, the mapping to language types and to rows or objects (POJO, serde, struct), data formats (Native, RowBinary, JSON, Parquet, Arrow), support for a new type or format. | +| **Queries** | How the client builds a statement: parameters and placeholders, quoting and escaping, SQL parsing in the client, size limits of the statement and its parameters. How the client runs a statement: batches and streaming inserts, sessions and roles, external data, totals, asynchronous inserts, the queries that the client sends on its own (`DESCRIBE`, server information), caches of table structure. | +| **Configuration** | Reading and passing options: connection strings, DSNs, URLs, and option objects (parsing, validation, defaults); ClickHouse settings for a connection or a query; settings that the client sends on its own. | +| **API & diagnostics** | The shape of the public API (a missing method or overload, a wrong type signature), and conformance to a standard interface that the client implements (JDBC, ODBC, ADO.NET, `database/sql`, DB-API, SQLAlchemy, R2DBC), including metadata and catalog functions. Errors that are wrong, incomplete, or not clear. Logging, metrics, tracing, progress, the query ID. | +| **Environment** | A build from sources, support for a compiler, runtime, operating system, or architecture, package managers, released artifacts, installers, dependencies. Also a failure with one ClickHouse server version only, or with one third-party tool only (Power BI, Tableau, Spark, DBeaver). | +| **Docs & project** | Documentation, examples, or the changelog are wrong or missing. Tests, CI, the release process, refactoring. | +| **Other** | No area fits. | + +Boundaries: + +- **Configuration or the area that an option controls.** If the client reads an option + correctly but the behavior that the option controls is wrong, use the area of that + behavior. Example: a keep-alive option that has no effect is Connectivity. +- **Authentication.** An authentication issue has the impact Security and the area + Connectivity. +- **Environment or the area of the failure.** Use Environment when the same call works in + general, and fails only with one server version, one platform, or one third-party tool. + A failure with all server versions and without the tool has the area of the failure. +- **API & diagnostics or the area of the failure.** When the problem is the quality of an + error, use API & diagnostics. When the problem is that the operation fails at all, use + the area of the operation. + +Rules for **Other**: + +- Other is the last choice. Say why no area fits. +- Other does not raise the priority. +- A subject that repeats in Other is a sign that a class is missing: report it. + +## Examples + +| Issue | Impacts | Area | +|---|---|---| +| A bare `Enum(...)` type hint is written as `Enum8`, which corrupts the data | Data integrity | Data types & formats | +| A flush returns no error when the server rejects the INSERT | Data integrity | Queries | +| The connection pool leaks connections until none is left | Stability | Connectivity | +| String parameters are not escaped | Security (vulnerability) | Queries | +| `LowCardinality(Nullable(String))` cannot be read: the client returns an error | none | Data types & formats | +| A server error loses its code when the response arrives in two chunks | none | API & diagnostics | +| A request for Kerberos authentication | Security (authentication) | Connectivity | +| Each compressed read fails on one new server version | none | Environment | +| Parameter binding takes quadratic time | Performance | Queries | + +## How to write the classification + +One line, in this form. In a triage comment, the line has the name **Classification**: + +`impact: · area: ()` + +For Security, add the part in parentheses: `Security (vulnerability)` or +`Security (authentication)`. + +The **subject** names what the issue is about inside the area, in one to four words. Use the +names that ClickHouse or the client API uses: + +- **Data types & formats:** always the ClickHouse types or the data format, for example + `(Enum8, Enum16)`, `(Map)`, `(DateTime64)`, `(RowBinary)`, `(Parquet)`. "Data types & + formats" alone does not say which type. +- **Other areas:** the feature, for example `(cancellation)`, `(TLS)`, `(connection pool)`, + `(query parameters)`, `(sessions)`, `(mid-stream errors)`, `(logging)`, `(release process)`. +- With two areas, give a subject after each one. + +Examples: `impact: Data integrity · area: Data types & formats (Map)`, +`impact: none · area: Configuration (URL parameters)`, +`impact: Security (vulnerability), Stability · area: Connectivity (TLS)`. + +## This repository + +No changes to the shared text. diff --git a/.claude/skills/issue-priority/SKILL.md b/.claude/skills/issue-priority/SKILL.md index 20eefb0b..bfd2e56d 100644 --- a/.claude/skills/issue-priority/SKILL.md +++ b/.claude/skills/issue-priority/SKILL.md @@ -2,11 +2,11 @@ name: issue-priority description: > Decide the priority of a `ClickHouse/ch-go` issue: `Urgent`, `High`, - `Medium`, or `Low`, for the org issue field **Priority**. Use this skill when - the task is to "prioritize", "set the priority of", "rate", or "triage" an - issue, or to explain why an issue has a given priority. It defines the reach - tiers of the packages, the impact classes, the severity rows, the base-level - matrix, the modifiers, and the confidence. + `Medium`, or `Low`, for the org issue field **Priority**. Use this skill + when the task is to "prioritize", "set the priority of", "rate", or "triage" + an issue, or to explain why an issue has a given priority. It defines the + reach tiers of the packages, the severity rows, the base-level matrix, the + modifiers, and the confidence. --- # Issue priority @@ -37,15 +37,12 @@ Set no priority when one of these is true: A security issue must not stay public with a description of how to reproduce it. This section applies when a reproduction or code inspection confirms a -vulnerability that is not public yet (impact Security, part vulnerability, in -section 2): a leak of credentials or data, a value that changes the meaning of -a query, a TLS or identity check that is skipped or weakened, memory corruption -(also when only a hostile server or network causes it), or input from the -application's users that stops the client. A hang, or a crash with no memory -corruption, that only a hostile server or network causes is not one: rate it by -the failure, as usual. A crash while the client reads data from the server (for -example an access violation or `SIGSEGV`) can be memory corruption: rule that -out by code inspection before you rate it by the failure. +vulnerability that is not public yet. The classification skill of this +repository defines it +([`../issue-classification/SKILL.md`](../issue-classification/SKILL.md), "A +vulnerability that is not public yet"): memory corruption is one also when only +a hostile server or network causes it, and a hang, or a crash with no memory +corruption, that only such a server or network causes is not one. - Report it in a private GitHub vulnerability report for this repository (**Security** → **Report a vulnerability**), never in a public issue, @@ -106,18 +103,11 @@ only direct ch-go users. ## 2. Severity -First name the **impacts** of the issue. The impact classes are the same in -every ClickHouse client repository. An issue has none, one, or more of them: - -| Impact | Use when | -| -------------- | -------- | -| Security | a **vulnerability**: a defect makes the protection weaker: it exposes credentials or data, lets a value change the meaning of a query, skips or weakens a TLS or identity check, corrupts memory (an out-of-bounds write, a use after free, also when only a hostile server or network causes it), or lets input that the application takes from its users stop the client (a hang, or a crash with no memory corruption, that only a hostile server or network causes is Stability). Also **authentication**: an authentication method that does not work or is missing | -| Data integrity | data that the caller wrote, or a result that the caller reads, is missing, incomplete, or different from the value given or stored, and the client reports no error; this includes a failed operation that the client reports as a success | -| Stability | the process stops in a way that the caller cannot handle as a normal error, a call does not return, or a resource leaks until none is left | -| Performance | the result is correct, but the operation is too slow, or uses too much memory or CPU | - -Give an impact only when the issue, a reproduction, or code inspection of the -current code shows it. Most issues have none. +First name the **impacts** of the issue with the classification skill of this +repository +([`../issue-classification/SKILL.md`](../issue-classification/SKILL.md)): none, +one, or more of Security (part vulnerability or part authentication), Data +integrity, Stability, and Performance. Most issues have none. Then use the first severity row that fits. With more than one impact, the highest row applies: From e00a5421287f4e7a6750007c2650faa0bf04acdc Mon Sep 17 00:00:00 2001 From: Polyglot AI <293096396+polyglotAI-bot@users.noreply.github.com> Date: Wed, 18 Nov 2026 18:49:48 +0000 Subject: [PATCH 09/11] docs(agents): rate speed requests and dependency CVEs; leaked secrets are vulnerabilities Review feedback (Bugbot on clickhouse-cpp#613): - a request to make an operation faster has the impact Performance but is a feature request ("Cosmetic, docs, feature"); only a Performance defect uses "Workaround exists"; - authentication means how the client takes credentials; a secret that leaks is a vulnerability, not authentication; - a dependency with a published CVE or GHSA uses "Wrong data or security" when the client calls the vulnerable code, else it is a dependency update; an unpublished dependency vulnerability goes to the private report. Co-Authored-By: Claude Opus 5.5 --- .claude/skills/issue-classification/SKILL.md | 5 ++++- .claude/skills/issue-priority/SKILL.md | 8 ++++++++ 2 files changed, 12 insertions(+), 1 deletion(-) diff --git a/.claude/skills/issue-classification/SKILL.md b/.claude/skills/issue-classification/SKILL.md index 2858784e..d2b31b8a 100644 --- a/.claude/skills/issue-classification/SKILL.md +++ b/.claude/skills/issue-classification/SKILL.md @@ -39,13 +39,14 @@ repository" at the end. Data integrity. 4. Data integrity and Stability are for defects only. Security and Performance are also for feature requests: a new authentication method, a request to make an operation faster. + The priority rules rate such requests as feature requests. 5. An issue with no harm has no impact. This is the normal case. ## Impact classes | Impact | Use when | |---|---| -| **Security** | Two parts. A **vulnerability**: a defect makes the protection weaker: it exposes credentials or data, lets a value change the meaning of a query (injection), skips or weakens a TLS or identity check, corrupts memory (an out-of-bounds write, a use after free, also when only a hostile server or network causes it), or lets input that the application takes from its users stop the client; also a vulnerable dependency. A hang, or a crash with no memory corruption, that only a hostile server or network causes is Stability, not Security. **Authentication**: an authentication method that does not work or is missing, and the handling of secrets. Say which part applies: the priority rules of a repo rate the two parts differently. | +| **Security** | Two parts. A **vulnerability**: a defect makes the protection weaker: it exposes credentials or data, lets a value change the meaning of a query (injection), skips or weakens a TLS or identity check, corrupts memory (an out-of-bounds write, a use after free, also when only a hostile server or network causes it), or lets input that the application takes from its users stop the client; also a dependency with a published vulnerability (CVE or GHSA) in code that the client calls. A hang, or a crash with no memory corruption, that only a hostile server or network causes is Stability, not Security. **Authentication**: an authentication method that does not work or is missing, or how the client takes credentials (for example a token provider or a credentials file). A secret that leaks (to a log, an error message, a URL, or another host) is a vulnerability, not authentication. Say which part applies: the priority rules of a repo rate the two parts differently. | | **Data integrity** | Data that the caller wrote, or a result that the caller reads, is missing, incomplete, or different from the value given or stored, and the client reports no error. This includes a failed operation that the client reports as a success, a server error that the client ignores, overflow, lost precision, a time zone shift, a wrong decode, a stream that loses synchronization, a duplicate write, and a write to the wrong table. | | **Stability** | The process stops in a way that the caller cannot handle as a normal error (abort, segmentation fault, unrecovered panic, stack overflow), a call does not return (deadlock, hang), or a resource leaks until none is left (connections, sockets, memory). Also a thread-safety defect. | | **Performance** | The result is correct, but the operation is too slow, or uses too much memory or CPU. Also a request to make an operation faster. | @@ -78,6 +79,8 @@ is a **confirmed vulnerability** when a run or code inspection shows one of thes - a TLS or identity check is skipped or weakened; - memory corruption (an out-of-bounds write, a use after free), also when only a hostile server or network causes it; +- a vulnerability in a dependency that is not published yet (also report it to the + maintainers of that dependency); - input that the application takes from its users stops the client. A hang, or a crash with no memory corruption, that only a hostile server or network causes is diff --git a/.claude/skills/issue-priority/SKILL.md b/.claude/skills/issue-priority/SKILL.md index bfd2e56d..177f5b87 100644 --- a/.claude/skills/issue-priority/SKILL.md +++ b/.claude/skills/issue-priority/SKILL.md @@ -125,6 +125,14 @@ authentication method that does not work by its failure ("Broken, no workaround" or "Workaround exists"), and a request for a missing method as a feature request. +A request to make an operation faster has the impact Performance, but it is a +feature request: use "Cosmetic, docs, feature". Only a defect with the impact +Performance (a correct result that is too slow) uses "Workaround exists". + +A dependency with a published vulnerability (a CVE or GHSA) uses "Wrong data or +security" when the client calls the vulnerable code. When it does not, the +issue asks for a dependency update: use "Cosmetic, docs, feature". + ## 3. Base level | Severity ↓ / Reach → | Core | Common | Narrow | Satellite | From da00be656c7aaad78fa2bd8ef51cd92b76a4e123 Mon Sep 17 00:00:00 2001 From: Polyglot AI <293096396+polyglotAI-bot@users.noreply.github.com> Date: Wed, 18 Nov 2026 19:02:32 +0000 Subject: [PATCH 10/11] docs(agents): unpublished dependency vulnerabilities; report upstream in private Review feedback (Bugbot on clickhouse-odbc#615): the impact Security and the priority mapping named only a published CVE or GHSA, so an unpublished dependency vulnerability had no Security mapping; and the report to the dependency's maintainers did not say that it must be private. Both now cover a published or unpublished vulnerability, and the upstream report goes through the dependency's security policy, never a public issue. Co-Authored-By: Claude Opus 5.5 --- .claude/skills/issue-classification/SKILL.md | 5 +++-- .claude/skills/issue-priority/SKILL.md | 7 ++++--- 2 files changed, 7 insertions(+), 5 deletions(-) diff --git a/.claude/skills/issue-classification/SKILL.md b/.claude/skills/issue-classification/SKILL.md index d2b31b8a..1d1de2dc 100644 --- a/.claude/skills/issue-classification/SKILL.md +++ b/.claude/skills/issue-classification/SKILL.md @@ -46,7 +46,7 @@ repository" at the end. | Impact | Use when | |---|---| -| **Security** | Two parts. A **vulnerability**: a defect makes the protection weaker: it exposes credentials or data, lets a value change the meaning of a query (injection), skips or weakens a TLS or identity check, corrupts memory (an out-of-bounds write, a use after free, also when only a hostile server or network causes it), or lets input that the application takes from its users stop the client; also a dependency with a published vulnerability (CVE or GHSA) in code that the client calls. A hang, or a crash with no memory corruption, that only a hostile server or network causes is Stability, not Security. **Authentication**: an authentication method that does not work or is missing, or how the client takes credentials (for example a token provider or a credentials file). A secret that leaks (to a log, an error message, a URL, or another host) is a vulnerability, not authentication. Say which part applies: the priority rules of a repo rate the two parts differently. | +| **Security** | Two parts. A **vulnerability**: a defect makes the protection weaker: it exposes credentials or data, lets a value change the meaning of a query (injection), skips or weakens a TLS or identity check, corrupts memory (an out-of-bounds write, a use after free, also when only a hostile server or network causes it), or lets input that the application takes from its users stop the client; also a vulnerability in a dependency, in code that the client calls (published as a CVE or GHSA, or not published yet). A hang, or a crash with no memory corruption, that only a hostile server or network causes is Stability, not Security. **Authentication**: an authentication method that does not work or is missing, or how the client takes credentials (for example a token provider or a credentials file). A secret that leaks (to a log, an error message, a URL, or another host) is a vulnerability, not authentication. Say which part applies: the priority rules of a repo rate the two parts differently. | | **Data integrity** | Data that the caller wrote, or a result that the caller reads, is missing, incomplete, or different from the value given or stored, and the client reports no error. This includes a failed operation that the client reports as a success, a server error that the client ignores, overflow, lost precision, a time zone shift, a wrong decode, a stream that loses synchronization, a duplicate write, and a write to the wrong table. | | **Stability** | The process stops in a way that the caller cannot handle as a normal error (abort, segmentation fault, unrecovered panic, stack overflow), a call does not return (deadlock, hang), or a resource leaks until none is left (connections, sockets, memory). Also a thread-safety defect. | | **Performance** | The result is correct, but the operation is too slow, or uses too much memory or CPU. Also a request to make an operation faster. | @@ -80,7 +80,8 @@ is a **confirmed vulnerability** when a run or code inspection shows one of thes - memory corruption (an out-of-bounds write, a use after free), also when only a hostile server or network causes it; - a vulnerability in a dependency that is not published yet (also report it to the - maintainers of that dependency); + maintainers of that dependency in private, through their security policy, never in a + public issue); - input that the application takes from its users stops the client. A hang, or a crash with no memory corruption, that only a hostile server or network causes is diff --git a/.claude/skills/issue-priority/SKILL.md b/.claude/skills/issue-priority/SKILL.md index 177f5b87..154cfa48 100644 --- a/.claude/skills/issue-priority/SKILL.md +++ b/.claude/skills/issue-priority/SKILL.md @@ -129,9 +129,10 @@ A request to make an operation faster has the impact Performance, but it is a feature request: use "Cosmetic, docs, feature". Only a defect with the impact Performance (a correct result that is too slow) uses "Workaround exists". -A dependency with a published vulnerability (a CVE or GHSA) uses "Wrong data or -security" when the client calls the vulnerable code. When it does not, the -issue asks for a dependency update: use "Cosmetic, docs, feature". +A vulnerability in a dependency (published as a CVE or GHSA, or not published +yet) uses "Wrong data or security" when the client calls the vulnerable code. +When it does not, the issue asks for a dependency update: use "Cosmetic, docs, +feature". ## 3. Base level From 3570a572b63d6f19282ac6d7fcab6e70865f9b83 Mon Sep 17 00:00:00 2001 From: Polyglot AI <293096396+polyglotAI-bot@users.noreply.github.com> Date: Wed, 18 Nov 2026 19:25:00 +0000 Subject: [PATCH 11/11] docs(agents): an unpublished dependency vulnerability stays private Review feedback (Bugbot on clickhouse-odbc#615): the classification kept every unpublished dependency vulnerability private, but the severity rule rated one in code that the client does not call as a public dependency update. Now an unpublished one stays private also then; the low level is only the proposed severity of the private report. Co-Authored-By: Claude Opus 5.5 --- .claude/skills/issue-classification/SKILL.md | 8 ++++---- .claude/skills/issue-priority/SKILL.md | 10 ++++++---- 2 files changed, 10 insertions(+), 8 deletions(-) diff --git a/.claude/skills/issue-classification/SKILL.md b/.claude/skills/issue-classification/SKILL.md index 1d1de2dc..b7b7fdec 100644 --- a/.claude/skills/issue-classification/SKILL.md +++ b/.claude/skills/issue-classification/SKILL.md @@ -46,7 +46,7 @@ repository" at the end. | Impact | Use when | |---|---| -| **Security** | Two parts. A **vulnerability**: a defect makes the protection weaker: it exposes credentials or data, lets a value change the meaning of a query (injection), skips or weakens a TLS or identity check, corrupts memory (an out-of-bounds write, a use after free, also when only a hostile server or network causes it), or lets input that the application takes from its users stop the client; also a vulnerability in a dependency, in code that the client calls (published as a CVE or GHSA, or not published yet). A hang, or a crash with no memory corruption, that only a hostile server or network causes is Stability, not Security. **Authentication**: an authentication method that does not work or is missing, or how the client takes credentials (for example a token provider or a credentials file). A secret that leaks (to a log, an error message, a URL, or another host) is a vulnerability, not authentication. Say which part applies: the priority rules of a repo rate the two parts differently. | +| **Security** | Two parts. A **vulnerability**: a defect makes the protection weaker: it exposes credentials or data, lets a value change the meaning of a query (injection), skips or weakens a TLS or identity check, corrupts memory (an out-of-bounds write, a use after free, also when only a hostile server or network causes it), or lets input that the application takes from its users stop the client; also a vulnerability in a dependency: a published one (CVE or GHSA) in code that the client calls, and any one that is not published yet. A hang, or a crash with no memory corruption, that only a hostile server or network causes is Stability, not Security. **Authentication**: an authentication method that does not work or is missing, or how the client takes credentials (for example a token provider or a credentials file). A secret that leaks (to a log, an error message, a URL, or another host) is a vulnerability, not authentication. Say which part applies: the priority rules of a repo rate the two parts differently. | | **Data integrity** | Data that the caller wrote, or a result that the caller reads, is missing, incomplete, or different from the value given or stored, and the client reports no error. This includes a failed operation that the client reports as a success, a server error that the client ignores, overflow, lost precision, a time zone shift, a wrong decode, a stream that loses synchronization, a duplicate write, and a write to the wrong table. | | **Stability** | The process stops in a way that the caller cannot handle as a normal error (abort, segmentation fault, unrecovered panic, stack overflow), a call does not return (deadlock, hang), or a resource leaks until none is left (connections, sockets, memory). Also a thread-safety defect. | | **Performance** | The result is correct, but the operation is too slow, or uses too much memory or CPU. Also a request to make an operation faster. | @@ -79,9 +79,9 @@ is a **confirmed vulnerability** when a run or code inspection shows one of thes - a TLS or identity check is skipped or weakened; - memory corruption (an out-of-bounds write, a use after free), also when only a hostile server or network causes it; -- a vulnerability in a dependency that is not published yet (also report it to the - maintainers of that dependency in private, through their security policy, never in a - public issue); +- a vulnerability in a dependency that is not published yet, also in code that the client + does not call (also report it to the maintainers of that dependency in private, through + their security policy, never in a public issue); - input that the application takes from its users stops the client. A hang, or a crash with no memory corruption, that only a hostile server or network causes is diff --git a/.claude/skills/issue-priority/SKILL.md b/.claude/skills/issue-priority/SKILL.md index 154cfa48..57117f00 100644 --- a/.claude/skills/issue-priority/SKILL.md +++ b/.claude/skills/issue-priority/SKILL.md @@ -129,10 +129,12 @@ A request to make an operation faster has the impact Performance, but it is a feature request: use "Cosmetic, docs, feature". Only a defect with the impact Performance (a correct result that is too slow) uses "Workaround exists". -A vulnerability in a dependency (published as a CVE or GHSA, or not published -yet) uses "Wrong data or security" when the client calls the vulnerable code. -When it does not, the issue asks for a dependency update: use "Cosmetic, docs, -feature". +A vulnerability in a dependency uses "Wrong data or security" when the client +calls the vulnerable code. When it does not, use "Cosmetic, docs, feature": for +a published one (a CVE or GHSA), the issue asks for a dependency update. One +that is not published yet stays private also then (see "Vulnerabilities that +are not public yet"), and this level is the proposed severity of the private +report. ## 3. Base level