@blastin-dev/clocktopus-cli 0.2.0 → 0.2.1

package/dist/src/commands/agent/doctor.js

@@ -3,81 +3,143 @@ import { isAfter, parseISO } from "date-fns";
 import { findShadowedExports, maskToken, resolveAgentCredentials, } from "../../lib/agent-config.js";
 import { readLastRun } from "../../lib/agent-hook-state.js";
 import { verifyReceiver } from "../../lib/agent-receiver.js";
-import { readInstalledTelemetry, SettingsParseError, TELEMETRY_ENV_KEYS, } from "../../lib/claude-settings.js";
+import { isConfigParseError, surveyAgents } from "../../lib/agents.js";
 import { isLoggedIn } from "../../lib/config.js";
 import { formatAgo } from "../../lib/format.js";
 import { fetchRepoStatus, repoChecks } from "../../lib/repo-guidance.js";
 export async function doctorCommand() {
+    const sections = [];
+    sections.push({
+        title: "This machine",
+        checks: [
+            {
+                label: "Logged in",
+                ok: isLoggedIn(),
+                detail: isLoggedIn() ? "yes" : "no",
+                fix: "clocktopus login",
+            },
+        ],
+    });
+    const survey = surveyAgents();
+    const relevant = survey.filter((entry) => entry.installed || entry.configured || entry.unreadable);
+    if (relevant.length === 0) {
+        sections[0].checks.push({
+            label: "Agents",
+            ok: false,
+            detail: `none of ${survey.map((e) => e.agent.binary).join(", ")} found on PATH`,
+            fix: "Install a supported agent, then run 'clocktopus agent setup'",
+        });
+    }
+    for (const entry of relevant) {
+        sections.push({
+            title: `${entry.agent.label}${entry.version ? ` ${entry.version}` : ""}`,
+            checks: await agentChecks(entry),
+        });
+    }
+    // Past this point the pipeline works; these decide whether what it carries
+    // can be turned into a number. Both are server-side facts about the
+    // repository, not about any one agent.
+    const tail = [];
+    const repoStatus = await fetchRepoStatus();
+    if (repoStatus)
+        tail.push(...repoChecks(repoStatus));
+    tail.push(checkLastHookRun());
+    sections.push({ title: "Repository and delivery", checks: tail });
+    report(sections);
+}
+async function agentChecks(entry) {
     const checks = [];
+    if (entry.unreadable) {
+        return [
+            {
+                label: "Config",
+                ok: false,
+                detail: "could not be parsed",
+                fix: entry.unreadable,
+            },
+        ];
+    }
     checks.push({
-        label: "Logged in",
-        ok: isLoggedIn(),
-        detail: isLoggedIn() ? "yes" : "no",
-        fix: "clocktopus login",
+        label: "Installed",
+        ok: entry.installed ? true : "warn",
+        detail: entry.installed
+            ? `${entry.agent.binary} ${entry.version ?? ""}`.trim()
+            : `${entry.agent.binary} is not on PATH`,
+        fix: "Config here is harmless, but nothing will report until it is installed",
     });
-    let installed = null;
+    let state;
     try {
-        installed = readInstalledTelemetry();
-        checks.push({
-            label: "settings.json",
-            ok: installed.exists,
-            detail: installed.exists
-                ? `${installed.path} (modified ${formatAgo(installed.modifiedAt?.toISOString() ?? null)})`
-                : `${installed.path} does not exist`,
-            fix: "clocktopus agent setup",
-        });
+        state = entry.agent.read();
     }
     catch (error) {
-        if (error instanceof SettingsParseError) {
-            checks.push({
-                label: "settings.json",
+        if (!isConfigParseError(error))
+            throw error;
+        return [
+            {
+                label: "Config",
                 ok: false,
-                detail: "is not valid JSON",
-                fix: "Fix or move the file, then run 'clocktopus agent setup'",
-            });
-            report(checks);
-            return;
-        }
-        throw error;
+                detail: "could not be parsed",
+                fix: error.message,
+            },
+        ];
     }
-    const missingEnv = TELEMETRY_ENV_KEYS.filter((key) => !installed?.env[key]);
     checks.push({
-        label: "Exporter config",
-        ok: missingEnv.length === 0,
-        detail: missingEnv.length === 0
-            ? `all ${TELEMETRY_ENV_KEYS.length} variables set`
-            : // Listing nine names when none are set is noise; the useful
-                // signal there is simply "nothing is configured".
-                missingEnv.length === TELEMETRY_ENV_KEYS.length
-                    ? "not configured in settings.json"
-                    : `missing ${missingEnv.join(", ")}`,
-        fix: "clocktopus agent setup",
+        label: "Config",
+        ok: state.token !== null,
+        detail: state.token !== null
+            ? `${state.paths.join(", ")} (modified ${formatAgo(state.modifiedAt?.toISOString() ?? null)})`
+            : `not configured in ${state.paths.join(", ")}`,
+        fix: `clocktopus agent setup --agent ${entry.agent.id}`,
     });
     // Both events are required, and for different reasons: SessionStart is the
     // only source of the *before* SHA and of `cwd`, SessionEnd is the only
     // source of the exact commit list. One without the other silently
     // degrades what can be attributed.
-    const hookStart = installed.hookCommands.SessionStart;
-    const hookEnd = installed.hookCommands.SessionEnd;
+    const hookStart = state.hookCommands.SessionStart;
+    const hookEnd = state.hookCommands.SessionEnd;
     checks.push({
         label: "Hooks installed",
         ok: Boolean(hookStart && hookEnd),
         detail: hookStart && hookEnd
             ? `SessionStart, SessionEnd → ${hookStart}`
-            : `missing ${[!hookStart && "SessionStart", !hookEnd && "SessionEnd"].filter(Boolean).join(", ")}`,
-        fix: "clocktopus agent setup",
+            : `missing ${[!hookStart && "SessionStart", !hookEnd && "SessionEnd"]
+                .filter(Boolean)
+                .join(", ")}`,
+        fix: `clocktopus agent setup --agent ${entry.agent.id}`,
     });
-    if (hookStart) {
+    if (hookStart)
         checks.push(checkHookRuns(hookStart));
+    // A warning, not a failure: a plugin from an older generation still
+    // reports. What it does not have is whatever the newer one fixed, and
+    // nothing else in this report would ever say so — the token is valid, the
+    // hook resolves, the receiver answers.
+    const stale = entry.agent.staleReason?.() ?? null;
+    if (stale) {
+        checks.push({
+            label: "Generated config",
+            ok: "warn",
+            detail: stale,
+            fix: `clocktopus agent setup --agent ${entry.agent.id}`,
+        });
+    }
+    for (const action of entry.agent.pendingActions()) {
+        checks.push({
+            label: "Hooks enabled",
+            ok: "warn",
+            detail: "installed but not yet approved by the agent",
+            fix: action,
+        });
     }
-    const credentials = resolveAgentCredentials();
+    const credentials = resolveAgentCredentials(entry.agent.id);
     checks.push({
         label: "Token in force",
         ok: credentials.token !== null,
         detail: credentials.token
-            ? `${maskToken(credentials.token)} (from ${credentials.tokenSource})`
+            ? `${maskToken(credentials.token)} (from ${credentials.tokenSource === "settings"
+                ? credentials.sourcePath
+                : credentials.tokenSource})`
             : "none resolved",
-        fix: "clocktopus agent setup",
+        fix: `clocktopus agent setup --agent ${entry.agent.id}`,
     });
     if (credentials.token && credentials.endpoint) {
         const check = await verifyReceiver(credentials.endpoint, credentials.token);
@@ -96,23 +158,19 @@ export async function doctorCommand() {
                 : "clocktopus agent setup --force  (mints a replacement token)",
         });
     }
-    // Past this point the pipeline works; these two decide whether what it
-    // carries can be turned into a number. Both are server-side facts about
-    // the repository, not about this machine.
-    const repoStatus = await fetchRepoStatus();
-    if (repoStatus)
-        checks.push(...repoChecks(repoStatus));
-    checks.push(checkShadowedExports());
-    checks.push(checkRestartNeeded(installed.modifiedAt));
-    checks.push(checkLastHookRun());
-    report(checks);
+    // Only Claude Code applies config `env` over the inherited environment,
+    // so only it can be shadowed by a shell export.
+    if (entry.agent.id === "claude")
+        checks.push(checkShadowedExports());
+    checks.push(checkRestartNeeded(entry, state.modifiedAt));
+    return checks;
 }
 /**
  * Runs the installed hook command with empty stdin.
  *
  * This is a genuine no-op — the hook returns immediately when stdin carries
  * no payload — so it sends nothing and records nothing, while still proving
- * the exact command line in settings.json resolves and executes. Worth
+ * the exact command line in the agent's config resolves and executes. Worth
  * checking directly: hooks run under a shell whose PATH may differ from the
  * interactive one, and a command that fails to resolve there fails
  * silently, costing every session its repository context.
@@ -165,25 +223,31 @@ function checkShadowedExports() {
  * The exporter and the hook both read their configuration once, at process
  * start, so a session already open when setup ran is still using the old
  * values. This is the most common reason a correct configuration looks dead.
+ *
+ * Scoped to the agent whose hook last ran: one receipt file is shared by all
+ * of them, and comparing Claude Code's last run against Codex's config
+ * mtime would report a restart that has already happened, or miss one that
+ * has not.
  */
-function checkRestartNeeded(settingsModifiedAt) {
+function checkRestartNeeded(entry, configModifiedAt) {
     const lastRun = readLastRun();
-    if (!settingsModifiedAt || !lastRun?.at) {
+    const ranThisAgent = lastRun?.provider === entry.agent.provider;
+    if (!configModifiedAt || !lastRun?.at || !ranThisAgent) {
         return {
             label: "Restart",
             ok: "warn",
-            detail: "the hook has not run since this configuration was written",
-            fix: "Restart Claude Code, then run 'clocktopus agent status'",
+            detail: `${entry.agent.label} has not run a hook since this configuration was written`,
+            fix: `Restart ${entry.agent.label}, then run 'clocktopus agent status'`,
         };
     }
-    const ranAfterConfig = isAfter(parseISO(lastRun.at), settingsModifiedAt);
+    const ranAfterConfig = isAfter(parseISO(lastRun.at), configModifiedAt);
     return {
         label: "Restart",
         ok: ranAfterConfig ? true : "warn",
         detail: ranAfterConfig
             ? "a session has run since the last configuration change"
-            : "settings.json changed after the last session started",
-        fix: "Restart Claude Code so the exporter and hook pick up the new values",
+            : "the config changed after the last session started",
+        fix: `Restart ${entry.agent.label} so the exporter and hook pick up the new values`,
     };
 }
 function checkLastHookRun() {
@@ -192,36 +256,43 @@ function checkLastHookRun() {
         return {
             label: "Last hook run",
             ok: "warn",
-            detail: "no record — the hook has not run on this machine",
-            fix: "Restart Claude Code and start a session",
+            detail: "no record — no hook has run on this machine",
+            fix: "Restart your agent and start a session",
         };
     }
     const failed = lastRun.status === null ||
         lastRun.status === undefined ||
         lastRun.status < 200 ||
         lastRun.status >= 300;
+    const who = lastRun.provider ? ` (${lastRun.provider})` : "";
     return {
         label: "Last hook run",
         ok: !failed,
         detail: failed
-            ? `${formatAgo(lastRun.at)} — ${lastRun.status ? `HTTP ${lastRun.status}` : (lastRun.error ?? "no response")}`
-            : `${formatAgo(lastRun.at)} — HTTP ${lastRun.status}`,
+            ? `${formatAgo(lastRun.at)}${who} — ${lastRun.status ? `HTTP ${lastRun.status}` : (lastRun.error ?? "no response")}`
+            : `${formatAgo(lastRun.at)}${who} — HTTP ${lastRun.status}`,
         fix: lastRun.status === 401
             ? "clocktopus agent setup --force  (the token was rejected)"
             : "Check network access to the receiver",
     };
 }
-function report(checks) {
-    console.log("\nAgent telemetry diagnosis\n");
-    for (const check of checks) {
-        const symbol = check.ok === true ? "✓" : check.ok === "warn" ? "⚠" : "✗";
-        console.log(`  ${symbol} ${check.label.padEnd(18)}${check.detail}`);
-        if (check.ok !== true && check.fix) {
-            console.log(`    → ${check.fix}`);
+function report(sections) {
+    console.log("\nAgent telemetry diagnosis");
+    for (const section of sections) {
+        if (section.checks.length === 0)
+            continue;
+        console.log(`\n${section.title}\n`);
+        for (const check of section.checks) {
+            const symbol = check.ok === true ? "✓" : check.ok === "warn" ? "⚠" : "✗";
+            console.log(`  ${symbol} ${check.label.padEnd(18)}${check.detail}`);
+            if (check.ok !== true && check.fix) {
+                console.log(`    → ${check.fix}`);
+            }
         }
     }
-    const failures = checks.filter((check) => check.ok === false).length;
-    const warnings = checks.filter((check) => check.ok === "warn").length;
+    const all = sections.flatMap((section) => section.checks);
+    const failures = all.filter((check) => check.ok === false).length;
+    const warnings = all.filter((check) => check.ok === "warn").length;
     console.log("");
     if (failures === 0 && warnings === 0) {
         console.log("Everything checks out. 'clocktopus agent status' shows what has arrived.");

package/dist/src/commands/agent/hook.d.ts

@@ -1,2 +1,5 @@
-export declare function hookCommand(): Promise<void>;
+export declare function hookCommand(options: {
+    provider?: string;
+    detached?: boolean;
+}): Promise<void>;
 //# sourceMappingURL=hook.d.ts.map

package/dist/src/commands/agent/hook.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"hook.d.ts","sourceRoot":"","sources":["../../../../src/commands/agent/hook.ts"],"names":[],"mappings":"AAuRA,wBAAsB,WAAW,IAAI,OAAO,CAAC,IAAI,CAAC,CAMjD"}
+{"version":3,"file":"hook.d.ts","sourceRoot":"","sources":["../../../../src/commands/agent/hook.ts"],"names":[],"mappings":"AAwaA,wBAAsB,WAAW,CAAC,OAAO,EAAE;IACzC,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,QAAQ,CAAC,EAAE,OAAO,CAAC;CACpB,GAAG,OAAO,CAAC,IAAI,CAAC,CAahB"}

package/dist/src/commands/agent/hook.js

@@ -1,14 +1,22 @@
-import { execFileSync } from "node:child_process";
+import { execFileSync, spawn } from "node:child_process";
+import { resolve as resolvePath } from "node:path";
 import { maskToken, resolveAgentCredentials } from "../../lib/agent-config.js";
 import { clearStartState, listStartStates, readStartState, recordLastRun, writeStartState, } from "../../lib/agent-hook-state.js";
+import { AGENTS } from "../../lib/agents.js";
 /**
- * Claude Code SessionStart / SessionEnd hook → Clocktopus.
+ * SessionStart / SessionEnd hook → Clocktopus. Serves every agent.
  *
- * Claude Code pipes its hook JSON to stdin. That JSON is the only place
- * `cwd` appears anywhere in the telemetry pipeline — the OTLP metric export
- * carries no path, repository or branch data at all — so without this hook
- * every agent session is unattributable and the ledger can only show
- * totals.
+ * Claude Code and Codex both pipe their hook JSON to stdin, and — verified
+ * against 2.1.234 and 0.147.0 — they pipe the *same* JSON: `session_id`,
+ * `cwd`, `hook_event_name`, `source`, `reason`, same spellings. That is why
+ * one subcommand handles both, and also why `--provider` exists: nothing in
+ * the payload says which agent sent it, so the answer has to come from how
+ * the hook was installed.
+ *
+ * That JSON is the only place `cwd` appears anywhere in the telemetry
+ * pipeline — neither agent's telemetry export carries path, repository or
+ * branch data — so without this hook every agent session is unattributable
+ * and the ledger can only show totals.
  *
  * Previously a standalone script under `scripts/agent-telemetry/`, which
  * meant `settings.json` had to reference an absolute path inside a checkout
@@ -18,6 +26,36 @@ import { clearStartState, listStartStates, readStartState, recordLastRun, writeS
  * Contract with the host process, all three parts load-bearing: never write
  * to stdout (Claude Code parses it), never throw, always exit 0. Telemetry
  * must not be able to break the session it measures.
+ *
+ * ## Getting off the session's critical path
+ *
+ * This hook does network I/O — its own POST, plus a sweep of abandoned
+ * sessions at SessionStart — and none of it may be charged to the developer
+ * waiting for their session to start.
+ *
+ * Claude Code solves this for us: `"async": true` in `settings.json` makes
+ * it background the hook. Codex does not, or not reliably — behaviour
+ * verified by running both binaries:
+ *
+ * | `async: true` on | Codex 0.147                    | Codex 0.148          |
+ * | ---------------- | ------------------------------ | -------------------- |
+ * | SessionStart     | **skips the hook**, with a warning | honoured, no warning |
+ * | SessionEnd       | runs it synchronously, with a warning | unchanged       |
+ *
+ * The 0.147 row is the dangerous one: a skipped SessionStart costs every
+ * Codex session its `cwd`, and with it the repository, the branch and the
+ * starting SHA — spend keeps arriving, attributed to nothing, with only a
+ * startup warning to say so.
+ *
+ * Rather than sniff the version, the Codex hooks carry no `async` key at
+ * all and this command backgrounds *itself*: it relays the payload to a
+ * detached copy and returns in a few milliseconds. One mechanism, correct
+ * on every version, and silent on all of them.
+ *
+ * SessionEnd needs it regardless of version. Codex still hard-clamps that
+ * hook to 3s — shorter than this file's own 4s request timeout — so a slow
+ * network would see the hook killed mid-POST and the session never closed.
+ * The clamp only has to cover a spawn.
  */
 const TIMEOUT_MS = 4000;
 /**
@@ -90,7 +128,7 @@ async function post(endpoint, token, body) {
  * receiver stamp one: this runs when the *next* session starts, potentially
  * a day later.
  */
-async function sweepAbandonedSessions(endpoint, token, currentSessionId) {
+async function sweepAbandonedSessions(endpoint, token, currentSessionId, fallbackProvider) {
     let swept = 0;
     for (const { sessionId, ageMs, lastActivityAt } of listStartStates()) {
         if (swept >= MAX_SWEEP_PER_RUN)
@@ -107,9 +145,20 @@ async function sweepAbandonedSessions(endpoint, token, currentSessionId) {
             clearStartState(sessionId);
             continue;
         }
+        // Kept alive only so a repeating SessionEnd could still diff against it.
+        // The session already ended properly; sweeping it would replace a real
+        // end with this moment's HEAD. Just collect the file.
+        if (state.closed) {
+            clearStartState(sessionId);
+            continue;
+        }
         const head = git(state.cwd, ["rev-parse", "HEAD"]);
         if (head) {
             await post(endpoint, token, {
+                // The agent that *opened* the session, not the one sweeping it.
+                // Closing a Codex session as `claude_code` would leave the real row
+                // hanging and create an empty duplicate under the wrong provider.
+                provider: readProvider(state.provider) ?? fallbackProvider,
                 session_id: sessionId,
                 hook_event_name: "SessionEnd",
                 cwd: state.cwd,
@@ -128,14 +177,59 @@ async function sweepAbandonedSessions(endpoint, token, currentSessionId) {
         clearStartState(sessionId);
     }
 }
+/**
+ * Reads a provider back off a state file written by an older CLI.
+ *
+ * Those files have no `provider` at all, and the only agent that could have
+ * written one was Claude Code — so `undefined` is not a missing value here,
+ * it is `claude_code`. That is the caller's fallback, applied by returning
+ * null rather than guessing here.
+ */
+function readProvider(value) {
+    const match = AGENTS.find((agent) => agent.provider === value);
+    return match?.provider ?? null;
+}
+/**
+ * Re-runs this command in a detached copy and hands it the payload.
+ *
+ * `detached: true` is what makes it survive: it puts the child in its own
+ * process group, so the host tearing down the session's group at exit —
+ * which is exactly when SessionEnd fires — cannot take the POST with it.
+ *
+ * Waiting for `stdin.end` to flush is not optional. The parent returns
+ * immediately afterwards, and an unflushed write would die with it; a hook
+ * payload is well under the pipe buffer, so this resolves without waiting
+ * for the child to read anything.
+ *
+ * Returns false if the spawn could not be arranged at all, in which case
+ * the caller does the work inline — a slow session start is worth more than
+ * a lost one.
+ */
+function detachSelf(provider, payload) {
+    const script = process.argv[1] ? resolvePath(process.argv[1]) : null;
+    if (!script)
+        return Promise.resolve(false);
+    try {
+        const child = spawn(process.execPath, [script, "agent", "hook", "--provider", provider, "--detached"], { detached: true, stdio: ["pipe", "ignore", "ignore"] });
+        child.unref();
+        return new Promise((settle) => {
+            child.once("error", () => settle(false));
+            child.stdin.once("error", () => settle(false));
+            child.stdin.end(payload, () => settle(true));
+        });
+    }
+    catch {
+        return Promise.resolve(false);
+    }
+}
 async function readStdin() {
     const chunks = [];
     for await (const chunk of process.stdin)
         chunks.push(chunk);
     return Buffer.concat(chunks).toString("utf8");
 }
-async function run() {
-    const { token, endpoint } = resolveAgentCredentials();
+async function run(agent, detached) {
+    const { token, endpoint } = resolveAgentCredentials(agent.id);
     if (!token || !endpoint) {
         // Not configured. Silence is correct: agent telemetry is opt-in, and a
         // machine that never ran `clocktopus agent setup` should notice nothing.
@@ -144,6 +238,15 @@ async function run() {
     const raw = await readStdin();
     if (!raw)
         return;
+    // After the empty-stdin check on purpose: `agent doctor` proves the hook
+    // command resolves by running it with no payload, and that probe must not
+    // leave a stray process behind.
+    if (!agent.hostRunsHooksAsync && !detached) {
+        if (await detachSelf(agent.provider, raw))
+            return;
+        // Could not spawn — fall through and do it inline. A slow session start
+        // is worth more than a lost session.
+    }
     let payload;
     try {
         payload = JSON.parse(raw);
@@ -165,6 +268,7 @@ async function run() {
     const head = git(cwd, ["rev-parse", "HEAD"]);
     const repositoryUrl = git(cwd, ["remote", "get-url", "origin"]);
     const body = {
+        provider: agent.provider,
         session_id: sessionId,
         hook_event_name: eventName,
         cwd,
@@ -183,7 +287,7 @@ async function run() {
     // environment.
     if (isSessionStart) {
         if (head)
-            writeStartState(sessionId, head, cwd);
+            writeStartState(sessionId, { sha: head, cwd, provider: agent.provider });
     }
     else {
         const before = readStartState(sessionId)?.sha;
@@ -198,7 +302,33 @@ async function run() {
         }
         if (before)
             body.git_head_before = before;
-        clearStartState(sessionId);
+        // A host that ends a session once is done with this file. One that can
+        // end it repeatedly — OpenCode, whose SessionEnd is `session.idle` after
+        // every turn — is not: deleting it here would cost the session every
+        // commit made after its first pause, because the next idle would have no
+        // starting SHA to diff against. Rewriting the *original* SHA keeps the
+        // range anchored at the session's start, so each idle re-declares the
+        // whole range; re-declaring is free, since a link is unique per commit
+        // and `declared` already outranks everything else.
+        //
+        // Rewriting rather than leaving it also refreshes the file's mtime, which
+        // is what the sweep ages sessions by — so the 12h abandonment clock runs
+        // from the last turn rather than from session start, and a long
+        // conversation is not swept out from under itself.
+        if (agent.hostRepeatsSessionEnd && before) {
+            writeStartState(sessionId, {
+                sha: before,
+                cwd,
+                provider: agent.provider,
+                // Already closed in the database. The sweep needs to know that, or
+                // it would "close" the session a second time 12h later and stamp it
+                // with whatever HEAD had become by then.
+                closed: true,
+            });
+        }
+        else {
+            clearStartState(sessionId);
+        }
     }
     // transcript_path is intentionally NOT forwarded. Claude Code provides it,
     // and it points at the full conversation on disk — exactly the content
@@ -207,6 +337,7 @@ async function run() {
     recordLastRun({
         at: new Date().toISOString(),
         event: eventName,
+        provider: agent.provider,
         sessionId,
         endpoint,
         tokenPrefix: maskToken(token),
@@ -218,12 +349,18 @@ async function run() {
     // network once per abandoned session and must not delay the event it is
     // piggybacking on.
     if (isSessionStart) {
-        await sweepAbandonedSessions(endpoint, token, sessionId);
+        await sweepAbandonedSessions(endpoint, token, sessionId, agent.provider);
     }
 }
-export async function hookCommand() {
+export async function hookCommand(options) {
     try {
-        await run();
+        // An unrecognised provider falls back to Claude Code rather than
+        // aborting: a hook installed by an older CLI has no flag at all, and
+        // dropping its sessions would be a worse failure than mislabelling a
+        // provider we do not know.
+        const agent = AGENTS.find((candidate) => candidate.provider === options.provider) ??
+            AGENTS[0];
+        await run(agent, options.detached === true);
     }
     catch {
         // Every failure path is silent by design.

package/dist/src/commands/agent/setup.d.ts

@@ -1,21 +1,28 @@
 /**
- * Configures this machine to report agent spend to Clocktopus.
+ * Configures this machine's coding agents to report spend to Clocktopus.
  *
- * Everything lands in one file — `~/.claude/settings.json` — holding both
- * the exporter's environment and the session hooks. A single source of
- * truth is not a tidiness preference: it is what makes `agent doctor` able
- * to say which value is in force. Configuration spread over `.envrc`, a
- * shell profile and a CLI config file can be reported on but never
- * resolved, and this project already lost real spend to exactly that (one
- * session split across two accounts, silently, because two files disagreed
- * about the token).
+ * One command, however many agents are installed. It looks for each
+ * supported CLI on PATH and configures what it finds — silently when
+ * there is only one, after a prompt when there are several, and from
+ * `--agent` when there is neither a person nor a terminal to ask.
+ *
+ * Everything for a given agent lands in that agent's own config, and
+ * nowhere else. A single source of truth per agent is not a tidiness
+ * preference: it is what makes `agent doctor` able to say which value is in
+ * force. Configuration spread over `.envrc`, a shell profile and a CLI
+ * config file can be reported on but never resolved, and this project
+ * already lost real spend to exactly that (one session split across two
+ * accounts, silently, because two files disagreed about the token).
  *
  * Idempotent by default. Re-running repairs the hooks and refreshes the
  * endpoint while keeping the existing token, so the common case — "did my
- * setup drift?" — costs nothing. `--force` mints a replacement instead.
+ * setup drift?" — costs nothing, and adding a newly-installed agent later
+ * reuses the token the first one already has. `--force` mints a
+ * replacement instead.
  */
 export declare function setupCommand(options: {
     name?: string;
     force?: boolean;
+    agent?: string[];
 }): Promise<void>;
 //# sourceMappingURL=setup.d.ts.map

package/dist/src/commands/agent/setup.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"setup.d.ts","sourceRoot":"","sources":["../../../../src/commands/agent/setup.ts"],"names":[],"mappings":"AA4BA;;;;;;;;;;;;;;;GAeG;AACH,wBAAsB,YAAY,CAAC,OAAO,EAAE;IAC1C,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,KAAK,CAAC,EAAE,OAAO,CAAC;CACjB,GAAG,OAAO,CAAC,IAAI,CAAC,CA+IhB"}
+{"version":3,"file":"setup.d.ts","sourceRoot":"","sources":["../../../../src/commands/agent/setup.ts"],"names":[],"mappings":"AAuBA;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,wBAAsB,YAAY,CAAC,OAAO,EAAE;IAC1C,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,KAAK,CAAC,EAAE,OAAO,CAAC;IAChB,KAAK,CAAC,EAAE,MAAM,EAAE,CAAC;CAClB,GAAG,OAAO,CAAC,IAAI,CAAC,CA8LhB"}