Repository navigation
feat: anonymous install, version and per-feature usage events (1.8.2) - #40
Conversation
plugin_session_start at each session start (plugin and altimate-code versions, OS, a random install id kept in the plugin store) and plugin_feature_used for each panel, command and gate, sent in the background through altimate-code's `tool report-event`. ALTIMATE_TELEMETRY_DISABLED starts no CLI for any usage event and makes no install id; an older CLI's refusal is silent. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
|
|
||
| /** The anonymous install id: made on first run and kept in this plugin's store, so it stays the same across sessions. */ | ||
| export async function installId($: EngineInterface): Promise<string> { | ||
| const kept = await $.store.get(INSTALL_ID_KEY) |
There was a problem hiding this comment.
SUGGESTION: Concurrent first sends can create two different install ids
installId has no in-flight guard, so two send calls that start before the first write lands (the session-start event and the first feature/gate event, or two feature events) each read no stored id, each generate a UUID, and each write it. The event that already went out keeps the id that lost the write, so one machine can be counted as two installs on its first session — the exact metric this field feeds. Memoizing the promise (the same way ownVersion memoizes the version below) would make concurrent callers share one id and one write.
There was a problem hiding this comment.
Fixed in e1bd950. installId keeps one lookup in flight per plugin load, so events sent together on a first run share the id the first one makes. After writing, it reads the stored value back and uses that, so two sessions starting at the same moment converge on the id the store kept. Regression test: "events sent together on a first run share one install id" holds the store read while /runs sends a second event. It fails on the previous head.
| expect([...store.keys()].filter(key => key === 'usage.installId')).toHaveLength(1) | ||
| }) | ||
|
|
||
| test('an install id kept from an earlier run is sent as it is; one that is not a UUID is replaced', async ($, on) => { |
There was a problem hiding this comment.
SUGGESTION: Test name promises coverage it does not provide
The title says "one that is not a UUID is replaced", but this test only asserts that a stored UUID is sent unchanged; the replacement half is the next test (line 143). A future regression in the replacement path would look covered by this name.
| test('an install id kept from an earlier run is sent as it is; one that is not a UUID is replaced', async ($, on) => { | |
| test('an install id kept from an earlier run is sent as it is', async ($, on) => { |
There was a problem hiding this comment.
Fixed in 9d46b90: renamed to "an install id kept from an earlier run is sent as it is". The replacement cases are their own tests now: a path, a version 0 UUID, and a number.
Code Review SummaryStatus: No Issues Found | Recommendation: Merge This incremental pass covers
Deep checks on the new code: the store key the test throws on ( Files Reviewed (3 files)
Previous Review Summaries (6 snapshots, latest commit 4da9c8d)Current summary above is authoritative. Previous snapshots are kept for context only. Previous review (commit 4da9c8d)Status: 3 Issues Found | Recommendation: Address before merge This incremental pass covers Overview
Issue Details (click to expand)SUGGESTION
Files Reviewed (3 files)
Fix these issues in Kilo Cloud Previous review (commit a8b96f7)Status: 3 Issues Found | Recommendation: Address before merge This incremental pass covers Overview
Issue Details (click to expand)SUGGESTION
Files Reviewed (3 files)
Fix these issues in Kilo Cloud Previous review (commit 1c6af5b)Status: 3 Issues Found | Recommendation: Address before merge The two earlier test-quality findings are resolved: the fixture now counts writes of Overview
Issue Details (click to expand)SUGGESTION
Files Reviewed (5 files)
Fix these issues in Kilo Cloud Previous review (commit bb32c12)Status: 3 Issues Found | Recommendation: Address before merge The Overview
Issue Details (click to expand)SUGGESTION
Files Reviewed (13 files)
Fix these issues in Kilo Cloud Previous review (commit 9d46b90)Status: 2 Issues Found | Recommendation: Address before merge The two findings from the previous review are fixed: Overview
Issue Details (click to expand)SUGGESTION
Files Reviewed (7 files)
Fix these issues in Kilo Cloud Previous review (commit 8cc0051)Status: 2 Issues Found | Recommendation: Address before merge No critical or warning-level defects found: the event payloads match the documented allow-list, the opt-out is checked before any CLI process or install id, every event is scheduled through Overview
Issue Details (click to expand)SUGGESTION
Files Reviewed (21 files)
Reviewed by deepseek-v4.1-flash-1017 · Input: 0 · Output: 0 · Cached: 0 |
…re counted once; one install id per first run Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
…4 UUID) Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
| await clock.settle() | ||
| const ids = usage().map(argv => flag(argv, '--install-id')) | ||
| expect(usage().map(argv => argv[3])).toEqual(['plugin_session_start', 'plugin_feature_used']) | ||
| expect(new Set(ids).size).toBe(1) |
There was a problem hiding this comment.
SUGGESTION: This test cannot fail if the in-flight guard is removed
With readOrMakeId now writing the id and then reading it back, both callers converge on the last write even without idInFlight: the held store.get releases both callers, both store.set calls land before either read-back, and both send the same id. So the assertion holds if the memoization at usage.ts:56 is deleted — it proves the read-back, not that the second event waited. Counting writes would pin the guard, e.g. wrap store.set in the fixture and expect exactly one write for usage.installId, or assert the second store.get never runs.
There was a problem hiding this comment.
Fixed in 1c6af5b. The fixture counts writes of usage.installId, and the test expects exactly one. With the in-flight guard removed, the test fails (two writes), checked by removing the memo from a copy of usage.ts.
| surface: 'terminal', | ||
| } as any) | ||
| const before = usage().length | ||
| await band.press({ key: 'comments-open' }) |
There was a problem hiding this comment.
SUGGESTION: The band's new failed branch is untested
This test only presses Open with $.ui.open resolving, so the rejection handler added in comments.tsx (send comments failed, then rethrow) never runs; deleting that branch would keep the suite green. The fixture already supports openFails: true, so a second case pressing the button under it would cover the failed event and confirm the rethrow still reaches later's debug log.
…d count; an unplaced pane is failed Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
| try { | ||
| await load($, await $.session.root()) | ||
| await $.ui.open({ id: PANE, title: PANE_TITLE, ...PANE_SIZE, focus: true, closeOnEscape: true }) | ||
| await openTracked($, 'runs', () => $.ui.open({ id: PANE, title: PANE_TITLE, ...PANE_SIZE, focus: true, closeOnEscape: true })) |
There was a problem hiding this comment.
SUGGESTION: A failure before the open is now counted as nothing
openTracked only reports on the open itself, but this try also wraps await load(...). If load throws, the command still answers Could not open the dbt runs (the catch below), yet no plugin_feature_used is sent: the previous head sent runs failed from that catch. PRIVACY.md describes failed as covering a panel that "could not open", so this failure is now invisible. cte-profile (an update before openPane) and lineage (paneRequest inside openPane, before the tracked call) have the same gap; either send failed from those catches or narrow the docs.
There was a problem hiding this comment.
Fixed in 238fb92. /runs now reads its list inside openTracked, so a list that cannot be read sends runs failed, as the previous head did. Regression test: "/runs whose list cannot be read answers that it could not open, and sends runs failed". It fails on the previous head.
|
|
||
| test('a pane Claude Code could not place (isPlaced: false) is counted as failed, not opened', async ($, on) => { | ||
| const { clock, usage, flag } = await start($, on, { notPlaced: true }) | ||
| for (const [command, args, feature] of [ |
There was a problem hiding this comment.
SUGGESTION: The panel table is duplicated from the openFails test
These seven [command, args, feature] rows repeat the openFails test's table verbatim. A panel added to one list and not the other would get only one of opened/failed covered. Hoisting the table to a module constant and reusing it in both tests keeps the two outcome paths in step.
There was a problem hiding this comment.
Fixed in 238fb92: the panel table is one module constant, PANELS, which the openFails and isPlaced: false tests both walk.
…d's failed open; any SemVer number Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
|
|
||
| | Event | When | Fields | | ||
| |---|---|---| | ||
| | `plugin_session_start` | Each time Claude Code starts a session with the plugin enabled | `plugin_version`; `altimate_code_version` (added by the CLI); `host_os`: `macos`, `linux`, `windows`, `wsl` or `unknown`; `install_id` | |
There was a problem hiding this comment.
SUGGESTION: The documented field host_os is not the one the plugin sends
This row now names the field host_os, but sessionStarted sends --os (plugins/altimate-code/hooks/usage.ts:104) and the payload allow-list test only knows --os (plugins/altimate-code/hooks/usage.test.tsx:14). Nothing else in the repository mentions host_os, and the field names in this column track the flag names (plugin_version/--plugin-version, install_id/--install-id, feature/--feature). Either the flag and the allow-list need the same rename, or this cell should stay os; as written, the published field list disagrees with what the CLI receives.
There was a problem hiding this comment.
Fixed in 238fb92. The column lists the event fields as the CLI sends them, and the CLI names this one host_os so it stays apart from the os its other events carry as process.platform (#1775). The row now says the plugin passes it as --os.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
…e for both outcome tests Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
|
review-loop: APPROVED at 238fb92 (reviewers: gpt-6-astra high, gpt-6.1-sol high) |
sahrizvi
left a comment
There was a problem hiding this comment.
Consensus review: APPROVE. Panel: Claude (lead) and Codex (codex exec -s read-only, default model). Both Codex runs finished: the independent pass and the cross-check. Head 238fb92; merge base fc3e5d4 (current main).
No critical or major finding. What I checked:
- every event fires once per person action, with the right outcome;
- no hook waits on an event: a CLI that never answers, is missing, exits 1 or prints 10 MB changes nothing;
- the argv carries only the allowed flags, even under a secret-looking project path and with SQL, a model and a column given to
/dbt-show; - under the env opt-out no CLI starts and no install id is written;
- end to end, the altimate-code #1775 build sends both events to a local sink with exactly the allowed fields, and the npm 0.12.11 CLI exits 1 silently.
The 5 remaining minors are inline. Why none of them blocks:
usage.ts:68, two plugin loads can each make their own install id on a first run: an edge case (two sessions starting at the same moment on a first run).PRIVACY.md:19, "anonymous" and "cannot be joined" overclaim: wording, safe in a follow-up.PRIVACY.md:121, the field list misses the timestamp,ai.user.idand theOPENCODE_DISABLE_TELEMETRYalias: docs only.PRIVACY.md:120, the install id outlivesclaude plugin uninstall: docs only.PRIVACY.md:123, under the CLI's config-only opt-out the plugin still writes an id and starts the CLI each time: docs only, and nothing is sent.
Nits, tables and the merge-order note are in the PR comment that follows.
| async function readOrMakeId($: EngineInterface): Promise<string> { | ||
| const kept = await $.store.get(INSTALL_ID_KEY) | ||
| if (typeof kept === 'string' && UUID.test(kept)) return kept | ||
| await $.store.set(INSTALL_ID_KEY, crypto.randomUUID().toLowerCase()) |
There was a problem hiding this comment.
Minor (Codex and Claude): the read-back does not make two sessions that start together agree on one install id.
idInFlight only guards events inside one plugin load. Take two Claude Code sessions starting at the same moment on a first run, sharing one store:
- A and B both read nothing.
- A writes UUID-A, reads it back, and sends UUID-A.
- B writes UUID-B, reads it back, and sends UUID-B.
The store keeps UUID-B, so later sessions converge, but that first run counts two installs. Codex reproduced this with two separate imports of the helper. I reproduced it in the test kit by having "another session" write after this one's read-back: the ids went [ce1f…, 1111…]. The test at usage.test.tsx:322 covers only events inside one load.
Edge case: it needs two first-run sessions racing. A fix could be a write-if-absent, or re-reading once after a short delay. Or just say in the comment that the ids converge from the next session.
| - When a task **is** delegated, your task text is passed to the altimate-code CLI, which sends it to an LLM provider to plan and execute the work — the Altimate LLM Gateway by default, or a provider you configure (BYOK). | ||
| - Warehouse queries, dbt commands, and file edits run **locally on your machine, under your credentials**. Your warehouse credentials are never sent to Altimate. | ||
| - In a project linked to an Altimate workspace, the plugin copies the workspace's team skills into the project's `.claude/skills/` and refreshes them from Altimate in the background at session start and at most hourly. Their text loads into the Claude Code conversation like any project skill. `ALTIMATE_CLAUDE_SKILL_SYNC=0` turns this off and removes the copies at the next session start. | ||
| - The plugin counts its own use anonymously, through the altimate-code CLI's usage telemetry: one event at each session start (plugin and altimate-code versions, OS, a random install id) and one each time a panel or command opens or a gate holds or allows a command (its name and outcome). No session id, project, model, column or file names, SQL or session text, and nothing that links them to your account or to the CLI's other telemetry. `ALTIMATE_TELEMETRY_DISABLED=true` turns it off. See [Plugin usage events](#plugin-usage-events). |
There was a problem hiding this comment.
Minor (Codex and Claude): "anonymously" and "cannot be joined" overclaim.
Every event carries the same persistent install_id. It survives sessions, plugin updates and even uninstall (see the comment on line 120). That makes the events pseudonymous, not anonymous: one install's activity can be linked across sessions and days.
Line 121's "cannot be joined to the CLI's other telemetry" is also too strong. The ingestion endpoint sees the same client IP (Application Insights derives location from it) and near-identical timestamps on these events and on the CLI's other events from the same machine.
Suggested wording: "pseudonymous, keyed to a random per-install id that is not linked to your account or machine id". README line 184 repeats "anonymously" and needs the same change. This is wording only and does not block.
| | `plugin_feature_used` | A panel or command opens: `/lineage` or the summary's **Open lineage** (`lineage`), `/dbt-show` (`dbt_show`), `/profile-ctes` (`profile_ctes`), `/scan-cost` (`scan_cost`), `/comments` or the band's **Open** (`comments`), `/sql-graph` (`sql_graph`), `/health` (`health`), `/runs` (`runs`), `/to-model` (`to_model`); the cost check holds a dbt command or `/allow-scan` allows it (`cost_gate`); with "Project health blocks git push" on, the push gate holds or lets through a `git push` (`health_push_gate`). Panes the plugin opens on its own, following Claude, are not counted | `feature` (the name in brackets); `outcome`: `opened`, `failed` (the panel could not open or be shown), `held` or `allowed`; `plugin_version`; `install_id` | | ||
|
|
||
| - **`install_id`** is a random UUID the plugin makes the first time it sends an event and keeps in its own Claude Code plugin store (a JSON file under your Claude Code configuration directory), so it stays the same across sessions on this machine. It is not derived from your machine, account or project, and is not made while `ALTIMATE_TELEMETRY_DISABLED` is set. Removing the plugin's store data makes a new one. | ||
| - Beside these fields, each event carries only the CLI version (`cli_version`), the client name (`client`: `altimate-code`) and how the CLI was started (`source`: `cli`, unless `ALTIMATE_CLI_CLIENT` names another client). Unlike the CLI's other events, these carry no session id, no machine id, no project id, no per-launch id and never your Altimate account (no user id or tenant), even when you are signed in, so they cannot be joined to the CLI's other telemetry. |
There was a problem hiding this comment.
Minor (Codex, verified): the "carries only" list leaves out what the envelope adds, and one opt-out alias.
What the #1775 CLI sent to my local sink for each event:
- tags:
ai.user.id= theinstall_id,ai.session.id="",ai.cloud.role,ai.application.ver; - the event time;
- the iKey.
Only cli_version, client and source are listed here.
Also, OPENCODE_DISABLE_TELEMETRY (true/1/TRUE) turns the events off and stops the install id from being made (usage.ts:47). The CHANGELOG names it, but this section and the README don't. Docs only.
| | `plugin_session_start` | Each time Claude Code starts a session with the plugin enabled | `plugin_version`; `altimate_code_version` (added by the CLI); `host_os` (the plugin passes it as `--os`): `macos`, `linux`, `windows`, `wsl` or `unknown`; `install_id` | | ||
| | `plugin_feature_used` | A panel or command opens: `/lineage` or the summary's **Open lineage** (`lineage`), `/dbt-show` (`dbt_show`), `/profile-ctes` (`profile_ctes`), `/scan-cost` (`scan_cost`), `/comments` or the band's **Open** (`comments`), `/sql-graph` (`sql_graph`), `/health` (`health`), `/runs` (`runs`), `/to-model` (`to_model`); the cost check holds a dbt command or `/allow-scan` allows it (`cost_gate`); with "Project health blocks git push" on, the push gate holds or lets through a `git push` (`health_push_gate`). Panes the plugin opens on its own, following Claude, are not counted | `feature` (the name in brackets); `outcome`: `opened`, `failed` (the panel could not open or be shown), `held` or `allowed`; `plugin_version`; `install_id` | | ||
|
|
||
| - **`install_id`** is a random UUID the plugin makes the first time it sends an event and keeps in its own Claude Code plugin store (a JSON file under your Claude Code configuration directory), so it stays the same across sessions on this machine. It is not derived from your machine, account or project, and is not made while `ALTIMATE_TELEMETRY_DISABLED` is set. Removing the plugin's store data makes a new one. |
There was a problem hiding this comment.
Minor (Claude, Codex accepts): say where the install id is kept, and that uninstalling keeps it.
In Claude Code 2.1.328 $.store is one JSON file per plugin id: ~/.claude/plugins/store/altimate-code_<marketplace>-<sha256[:12]>.json (under CLAUDE_CONFIG_DIR when that is set). It is keyed by name and marketplace, not version, so plugin updates keep it.
I tested this in an isolated config dir. claude plugin uninstall altimate-code@altimate-claude-plugin left the file in place, and so did --keep-data. A reinstall therefore sends the same id. "Removing the plugin's store data makes a new one" is true, but the reader is not told where that file is or that uninstalling does not remove it.
Two related notes:
- A
--plugin-dirload has a different plugin id, so it gets a different store file and a different id. - From reading the binary, not tested: the store folder appears to be included in Claude Code's
cleanupPeriodDayssweep (30 days by default), so an install left unused that long may get a new id.
Docs only.
| - **`install_id`** is a random UUID the plugin makes the first time it sends an event and keeps in its own Claude Code plugin store (a JSON file under your Claude Code configuration directory), so it stays the same across sessions on this machine. It is not derived from your machine, account or project, and is not made while `ALTIMATE_TELEMETRY_DISABLED` is set. Removing the plugin's store data makes a new one. | ||
| - Beside these fields, each event carries only the CLI version (`cli_version`), the client name (`client`: `altimate-code`) and how the CLI was started (`source`: `cli`, unless `ALTIMATE_CLI_CLIENT` names another client). Unlike the CLI's other events, these carry no session id, no machine id, no project id, no per-launch id and never your Altimate account (no user id or tenant), even when you are signed in, so they cannot be joined to the CLI's other telemetry. | ||
| - No event contains project, model, column or file names, SQL, query results or session text. The CLI accepts each field only from a fixed list or pattern (a version, a UUID, one of the names above) and refuses anything else. | ||
| - **Turning it off:** `ALTIMATE_TELEMETRY_DISABLED=true` (or `1`) in the environment Claude Code starts in: the plugin then starts no CLI for these events, or for the lineage report's, and makes no install id. The CLI also drops them under its own opt-out (`ALTIMATE_TELEMETRY_DISABLED`, or `telemetry.disabled` in its config), as for every other event. |
There was a problem hiding this comment.
Minor (Claude, Codex accepts): with only the CLI's config opt-out, the plugin still makes the id and starts the CLI for every event.
usageOff reads only the two environment variables, as it must, because the plugin cannot read altimate-code's config. So with telemetry.disabled: true in that config and no env var set:
readOrMakeIdstill writesusage.installIdto the store;- every event still starts one
altimate tool report-eventprocess. Each took 2–4 s of wall time in my runs of the #1775 build, in the background.
The CLI then drops the event: nothing reached my local sink. But on a machine that already has ~/.altimate/machine-id, the first such launch sends the CLI's one-time telemetry_opted_out event, which carries the machine id. That behaviour predates this PR, and any CLI launch does it.
Suggest one sentence here: "with only the config opt-out, the plugin cannot tell; it still keeps an install id and starts the CLI, which sends nothing." Docs only.
|
Consensus review (Claude + Codex): nits, test tables and the merge-order note. The approval and its 5 inline minors are in the review above. Nits
Event table: what each person action sends (test kit, with the head's hooks)
Hook timing: head vs base (test kit, wall ms; the event's CLI is faked)
In the gate rows, "Base" means the same head code with the opt-out set, so the gate behaves as at base. The session-start gap comes from the kit running the event's own work during Argv captureSetup: project at Every argv the plugin built has this shape:
End to end: #1775 build (a0e1395d21) and a local sink
Opt-out table
Test results (run one after another)
I ran no live Merge-order noteThese events need altimate-code #1775 ( |
What
Anonymous, opt-out usage events for the plugin, so launch posts can be measured: distinct installs per day or week, plugin and altimate-code versions, OS, and how often each panel and gate is used. They go through the altimate-code CLI's existing telemetry (
altimate tool report-event). The plugin opens no network connection of its own.Depends on AltimateAI/altimate-code#1775, which adds the two actions to
tool report-eventwith a field allow-list. Until that release is installed, the CLI refuses them and nothing is sent or shown.Design
Events. Two new actions for
altimate tool report-event, sent by the Claude Code plugin:plugin_session_startplugin_version,altimate_code_version(stamped by the CLI),host_os(macos,linux,windows,wsl,unknown; apart from theosother events carry asprocess.platform),install_idplugin_feature_usedplugin_version,install_id,feature,outcomefeatureis one oflineage,dbt_show,profile_ctes,scan_cost,comments,sql_graph,health,runs,to_model,cost_gate,health_push_gate.outcomeis one ofopened,failed(the panel could not open, or Claude Code could not place it),held,allowed.install_idis a random UUID the plugin creates on first run and keeps in its own Claude Code plugin store. It is not derived from the machine, the user or the project.Allow-list. The CLI builds each event from these fields only, each checked against a fixed pattern or enum:
plugin_versionis a SemVer 2.0 version of up to 64 characters (any number of digits per part) (orunknown),install_ida lowercase v4 UUID, andos,featureandoutcomeenums. The plugin actions take no--session, and each action refuses a flag it does not take. Anything else, including any other flag, is refused with exit 1 and nothing is tracked. No project names, SQL, paths, column names or session text can reach the event.Transport and anonymity. The events go through the CLI's existing telemetry (
Telemetry.trackto Azure Application Insights, flushed on exit). No new network host. They are unlinkable: unlike every other CLI event, they carry no account (user_id,tenant), no machine id, no project id, no session id and nolaunch_id, which the same process'sfirst_launchrow would share.ai.user.idis the plugin's install id, so they cannot be joined to a signed-in row. Onlycli_version,clientandsourcecome from the envelope.Opt-out.
ALTIMATE_TELEMETRY_DISABLED(orOPENCODE_DISABLE_TELEMETRY) andtelemetry.disabledin the altimate-code config turn it off in the CLI, as for every other event. The plugin also checksALTIMATE_TELEMETRY_DISABLED/OPENCODE_DISABLE_TELEMETRYitself and then starts no CLI process and creates no install id.Older CLI. An altimate-code without these actions exits 1 with a message on stderr. The plugin runs every event in the background (scheduled with
later, never awaited by a hook), ignores the exit code and output, and shows nothing: no toast, no log line outside the debug log.Where each event comes from
hooks/usage.ts(new) hassessionStarted($),featureUsed($, feature, outcome),openTracked($, feature, open),usageOff($)andinstallId($).laterand never awaited. The helpers never throw into the hook that calls them.${$.plugin.root}/.claude-plugin/plugin.json. It must be SemVer, as the CLI reads it, or it is sent asunknown.$.session.info().platform.usage.installIdin$.store. One lookup is in flight per plugin load, so events sent together on a first run share it. After writing, the stored value is read back, so sessions starting at the same moment converge on one id. A stored value that is not a v4 UUID is replaced.integrations.tsx:sessionStarted($)insession.start.openTracked:openedonce the pane opens, orfailedwhen$.ui.openthrows or answersisPlaced: false./lineageand the task summary's Open lineage button (lineage.tsxopenPane)./dbt-show(dbt-mods.tsx)./commentsand the band's Open button (features/comments.tsx)./runs(a list that cannot be read counts asfailed),/sql-graph,/profile-ctesand/to-model(its pane, once the mapping is in).dbt show) are not counted: these count a person's use./healthand/scan-costanswer in text, so they sendopenedwhen run.features/cost.tsx:cost_gate heldfor every refusal of the gate. That covers over the limit, an estimate still coming in, and a project that could not be read.cost_gate allowedis sent when/allow-scanallows the held command, and nothing when nothing is held.features/health.tsx: with "Project health blocks git push" on,health_push_gate heldorallowedfor eachgit pushthe gate decides. Nothing is sent with the gate off, or for a command that is not a push.task-impact.tsx: the existinglineage_reportevents now check the same opt-out, so no CLI is started for them under it.PRIVACY.mdhas a new "Plugin usage events" section listing every event and field. Its short version, the "What the plugin does" paragraph, the lineage report section and the change log are updated too. The plugin README's "Data handling" covers the events as well.plugin.jsonand.claude-plugin/marketplace.json, with a CHANGELOG entry.Verification
claude plugin test plugins/altimate-code: 1225 pass, 1 fail at the head (earlier runs of this branch: 0 fail). The one failure isfeatures/runs.test.tsx› "a dbt call that starts while another call reads its artifact". That test waits on two 20 ms real-time sleeps and fails on main too: 2 of 6 runs of main'sruns.test.tsxalone, and once in a full run of main's sources with this PR's tests. Every other test passes on each run; earlier full runs of this branch had 0 fail./to-modelcounting only its pane, an unplaced pane counting asfailed, one install id for events sent together, no session id, and version and UUID rules.plugin_session_startper session start, with the plugin version, the OS and a v4 install id that matches the store, and no session id (usage.test.tsx).wsl,1.8.2+build.7, and1.8.2-01→unknown.plugin_feature_usedper panel and command:/lineage,/dbt-show,/profile-ctes,/scan-cost,/comments,/sql-graph,/health,/runsand/to-modeleach send exactly one, with their feature name andopened.failed. A bad argument before any pane sends nothing.task-impact.test.tsx) and the comments band's Open each send one. The pane following Claude's edit sends none.cost.test.tsx): held over the limit, held while the estimate is still coming in,/allow-scanallowed,/scan-costopened, and nothing when nothing is held.health.test.tsx): a push held,/healthopened, a push allowed, and nothing with the gate off.ALTIMATE_TELEMETRY_DISABLEDset totrue,1orTRUE, orOPENCODE_DISABLE_TELEMETRY=1, starts no CLI for any event and makes no install id. The cost and health gates still hold under it and send nothing. The lineage report still opens and sends nolineage_report.falseand0leave usage on, as the CLI reads them. The CLI's own opt-out is proven end to end in feat:tool report-eventtakes the Claude Code plugin's session start and feature-used events altimate-code#1775./work/acme_secret_project, with a modelfct_orders, a columnsecret_columnand SQL passed to/dbt-show, every event's argv has only the allowed flags, each value matching its pattern. None contains the project, model, column, SQL, path or session id. On the CLI side, the events are sent without account, machine id, project or session, and are keyed to the install id (#1775).altimateon PATH and analtimate-codewithoutreport-event./runs.claude plugin validate --strict .passes. The env reads it lists areALTIMATE_TELEMETRY_DISABLED,OPENCODE_DISABLE_TELEMETRYandWSL_DISTRO_NAME.bash tests/*.sh: all 8 pass.🤖 Generated with Claude Code