@bli-cockpit/cli 0.1.27 → 0.1.29

package/README.md

@@ -45,11 +45,11 @@ cockpit onboard --email <APPROVED_EMAIL> --workspace ~/BLI --workspace ~/side-pr
 The CLI defaults to the production dashboard. Normal intern/operator setup,
 updates, and syncs omit `--dashboard-url`. Pass `--dashboard-url` only for
 staging, a custom dashboard, or deliberately forcing a different dashboard
-pairing. Already-onboarded users update with
-`npm install -g @bli-cockpit/cli@latest`, then run
-`cockpit onboard` from anywhere to refresh pairing, agent rules, autostart, and
-an initial sync against saved roots. `--repo <path>` remains supported for older
-prompts and the agent ticket-binding guardrail.
+pairing. Already-onboarded users update with `cockpit update` from anywhere. It
+installs the latest public CLI from npm, then reruns onboarding checks to
+refresh pairing, agent rules, autostart, and an initial sync against saved
+roots. `cockpit upgrade` is a compatibility alias. `--repo <path>` remains
+supported for older prompts and the agent ticket-binding guardrail.
 
 On machines where Codex or Claude agents will do ticketed work, `cockpit
 onboard` refreshes `~/.codex/AGENTS.md` and `~/.claude/CLAUDE.md` after harvest
@@ -137,6 +137,9 @@ cockpit sync \
 
 No ticket is required for setup, chatting, planning, or general ambient capture.
 Only pass `--ticket` when the work really belongs to a visible ticket.
+Omitting `--ticket` preserves any existing ticket binding; run
+`cockpit start --clear-ticket --workspace "$PWD"` when you intentionally want
+to return a previously bound work context to general ambient capture.
 
 When the work is important but ticketless, label it explicitly before syncing so
 later analysis does not have to guess the topic:

package/dist/commands/local-args.js

@@ -12,6 +12,9 @@ export function parseLocalArgs(argv) {
     switch (command) {
         case "onboard":
             return parseOnboardArgs(argv.slice(1));
+        case "update":
+        case "upgrade":
+            return parseUpdateArgs(command, argv.slice(1));
         case "install":
             return parseInstallArgs(argv.slice(1));
         case "login":
@@ -33,11 +36,13 @@ export function parseLocalArgs(argv) {
             return parseAutostartArgs(argv.slice(1));
         case "agent-rules":
             return parseAgentRulesArgs(argv.slice(1));
+        case "release":
+            return parseReleaseArgs(argv.slice(1));
         default:
             throw new Error(`Unknown local command: ${command ?? ""}`);
     }
 }
-function parseOnboardArgs(args) {
+function parseOnboardLikeArgs(args, command) {
     const values = parseNamedArgs(args, {
         allowedFlags: [
             "--home",
@@ -69,13 +74,13 @@ function parseOnboardArgs(args) {
             "--max-repos",
         ],
     });
-    assertNoPositionals(values.positionals, "onboard");
+    assertNoPositionals(values.positionals, command);
     return {
-        kind: "onboard",
         homeDir: optionalNonEmpty(values.flags.get("--home")),
         repoRoot: optionalNonEmpty(workRootFlagValue(values)),
         collectionRoots: optionalNonEmptyList(workRootFlagValues(values)),
         dashboardUrl: normalizeUrl(values.flags.get("--dashboard-url") ?? DEFAULT_DASHBOARD_URL),
+        dashboardUrlExplicit: values.flags.has("--dashboard-url"),
         claimedOwnerEmail: optionalEmail(values.flags.get("--email")),
         deviceName: optionalNonEmpty(values.flags.get("--device-name")),
         activeTicketId: optionalNonEmpty(values.flags.get("--ticket")),
@@ -87,6 +92,16 @@ function parseOnboardArgs(args) {
         maxRepos: optionalPositiveInteger(values.flags.get("--max-repos"), "--max-repos"),
     };
 }
+function parseOnboardArgs(args) {
+    return { kind: "onboard", ...parseOnboardLikeArgs(args, "onboard") };
+}
+function parseUpdateArgs(alias, args) {
+    return {
+        kind: "update",
+        alias,
+        ...parseOnboardLikeArgs(args, alias),
+    };
+}
 function parseInstallArgs(args) {
     const values = parseNamedArgs(args, {
         allowedFlags: [
@@ -115,6 +130,30 @@ function parseInstallArgs(args) {
         json: values.booleans.has("--json"),
     };
 }
+function parseReleaseArgs(args) {
+    const values = parseNamedArgs(args, {
+        allowedFlags: [
+            "--dry-run",
+            "--tag",
+            "--access",
+            "--otp",
+            "--skip-checks",
+        ],
+        valueFlags: ["--tag", "--access", "--otp"],
+    });
+    assertNoPositionals(values.positionals, "release");
+    const releaseArgs = [];
+    if (values.booleans.has("--dry-run"))
+        releaseArgs.push("--dry-run");
+    if (values.booleans.has("--skip-checks"))
+        releaseArgs.push("--skip-checks");
+    for (const flag of ["--tag", "--access", "--otp"]) {
+        const value = values.flags.get(flag);
+        if (value !== undefined)
+            releaseArgs.push(flag, value);
+    }
+    return { kind: "release", args: releaseArgs };
+}
 function parseLoginArgs(args) {
     const values = parseNamedArgs(args, {
         allowedFlags: [
@@ -167,6 +206,7 @@ function parseStartArgs(args) {
             "--workspace",
             "--branch",
             "--ticket",
+            "--clear-ticket",
             "--topic",
             "--topic-summary",
             "--intent",
@@ -198,6 +238,11 @@ function parseStartArgs(args) {
         ],
     });
     assertNoPositionals(values.positionals, "start");
+    const activeTicketId = optionalNonEmpty(values.flags.get("--ticket"));
+    const clearTicket = values.booleans.has("--clear-ticket");
+    if (activeTicketId && clearTicket) {
+        throw new Error("--ticket and --clear-ticket cannot be combined.");
+    }
     const topicLabel = optionalNonEmpty(values.flags.get("--topic"));
     const topicSummaryRedacted = optionalNonEmpty(values.flags.get("--topic-summary"));
     const workIntent = optionalSchemaValue(WorkIntentSchema, values.flags.get("--intent"), "--intent");
@@ -213,7 +258,8 @@ function parseStartArgs(args) {
         homeDir: optionalNonEmpty(values.flags.get("--home")),
         repoRoot: optionalNonEmpty(workRootFlagValue(values)),
         branch: optionalNonEmpty(values.flags.get("--branch")),
-        activeTicketId: optionalNonEmpty(values.flags.get("--ticket")),
+        activeTicketId,
+        clearTicket,
         topicLabel,
         topicSummaryRedacted,
         workIntent,

package/dist/commands/local.js

@@ -1,4 +1,5 @@
-import { execFile } from "node:child_process";
+import { execFile, spawn } from "node:child_process";
+import { readFile } from "node:fs/promises";
 import os from "node:os";
 import path from "node:path";
 import { createCollectorServer } from "../server.js";
@@ -14,6 +15,8 @@ import { runAttributedWorktreeSync, } from "./session-sync.js";
 import { COLLECTION_ROOT_REQUIRED, resolveOnboardingRoots, } from "../onboarding-roots.js";
 export const rootCommandNames = new Set([
     "onboard",
+    "update",
+    "upgrade",
     "install",
     "login",
     "pair",
@@ -25,6 +28,7 @@ export const rootCommandNames = new Set([
     "serve",
     "autostart",
     "agent-rules",
+    "release",
 ]);
 export async function runLocalCockpitCli(argv, io = defaultIo()) {
     if (isLocalHelpRequest(argv)) {
@@ -47,6 +51,8 @@ export async function runLocalCockpitCli(argv, io = defaultIo()) {
                 return await runInstall(command, io);
             case "onboard":
                 return await runOnboard(command, io);
+            case "update":
+                return await runUpdate(command, io);
             case "login":
                 return await runLogin(command, io);
             case "logout":
@@ -65,6 +71,8 @@ export async function runLocalCockpitCli(argv, io = defaultIo()) {
                 return await runAutostart(command, io);
             case "agent-rules":
                 return await runAgentRules(command, io);
+            case "release":
+                return await runRelease(command, io);
         }
     }
     catch (error) {
@@ -77,17 +85,20 @@ export function localCommandHelp(command) {
         return localSubcommandHelp(command);
     return [
         "  cockpit onboard [--ticket <id>] [--email <owner@email>] [--device-name <name>] [--dashboard-url <url>] [--workspace <path>] [--branch <name>] [--max-depth <n>] [--max-repos <n>] [--json]",
+        "  cockpit update [--email <owner@email>] [--device-name <name>] [--dashboard-url <url>] [--workspace <path>] [--json]",
+        "  cockpit upgrade [same flags as update]",
         "  cockpit install [--dashboard-url <url>] [--workspace <path>] [--json]",
         "  cockpit login [--email <owner@email>] [--device-name <name>] [--dashboard-url <url>] [--json]",
         "  cockpit pair [--email <owner@email>] [--device-name <name>] [--dashboard-url <url>] [--json]",
         "  cockpit logout",
-        "  cockpit start [--ticket <id>] [--topic <label>] [--intent <intent>] [--phase <phase>] [--workspace <path>] [--branch <name>] [--max-depth <n>] [--max-repos <n>] [--json]",
+        "  cockpit start [--ticket <id>|--clear-ticket] [--topic <label>] [--intent <intent>] [--phase <phase>] [--workspace <path>] [--branch <name>] [--max-depth <n>] [--max-repos <n>] [--json]",
         "  cockpit sync [--workspace <path>] [--dashboard-url <url>] [--max-depth <n>] [--max-repos <n>] [--json]",
         "  cockpit status [--workspace <path>] [--max-depth <n>] [--max-repos <n>] [--json]",
         "  cockpit sessions [--source codex|claude] [--workspace <path>] [--max-depth <n>] [--max-repos <n>] [--json]",
         "  cockpit serve [--port <port>] [--workspace <path>]",
         "  cockpit autostart [install|uninstall|status] [--workspace <path>] [--dashboard-url <url>] [--interval-seconds <n>] [--json]",
         "  cockpit agent-rules [install|uninstall|status] [--host codex|claude|all] [--workspace <path>] [--json]",
+        "  cockpit release [--dry-run] [--skip-checks] [--tag <tag>] [--access <public|restricted>] [--otp <code>]",
         "",
         `Default dashboard: ${DEFAULT_DASHBOARD_URL}. Omit --dashboard-url for normal production use; pass it only for staging/custom dashboards or to force a different pairing.`,
     ].join("\n");
@@ -118,6 +129,25 @@ function localSubcommandHelp(command) {
                 "Omit --dashboard-url for the production dashboard; pass it only for staging/custom dashboards.",
             ],
         ],
+        [
+            "update",
+            [
+                "Usage: cockpit update [--email <owner@email>] [--device-name <name>] [--dashboard-url <url>] [--workspace <path>] [--json]",
+                "",
+                "Updates the global public CLI from npm, then reruns `cockpit onboard`",
+                "with the same setup flags so pairing, saved roots, agent rules,",
+                "autostart, and the initial sync are refreshed in one command.",
+                "`cockpit upgrade` is an alias.",
+            ],
+        ],
+        [
+            "upgrade",
+            [
+                "Usage: cockpit upgrade [same flags as cockpit update]",
+                "",
+                "Alias for `cockpit update`.",
+            ],
+        ],
         [
             "login",
             [
@@ -139,10 +169,11 @@ function localSubcommandHelp(command) {
         [
             "start",
             [
-                "Usage: cockpit start [--ticket <id>] [--topic <label>] [--topic-summary <summary>] [--intent <intent>] [--phase <phase>] [--intent-confidence <0..1>] [--workspace <path>] [--branch <name>] [--json]",
+                "Usage: cockpit start [--ticket <id>|--clear-ticket] [--topic <label>] [--topic-summary <summary>] [--intent <intent>] [--phase <phase>] [--intent-confidence <0..1>] [--workspace <path>] [--branch <name>] [--json]",
                 "",
                 "Starts local ambient capture. Parent folders start each child git worktree.",
-                "Add --ticket only when the work already has a visible ticket.",
+                "Add --ticket only when the work already has a visible ticket; omit it to preserve an existing binding.",
+                "Use --clear-ticket to intentionally return the context to general ambient capture.",
                 "Use --topic/--intent/--phase for planning, discovery, and learning work that has no ticket yet.",
                 "Supported intents: implementation, bug_fix, root_cause_analysis, planning, discovery, review, testing, documentation, release, learning, coordination, maintenance, analysis, unknown, other.",
                 "Supported phases: planning, discovery, implementation, debugging, review, testing, documentation, release, handoff, analysis, unknown, other.",
@@ -222,6 +253,17 @@ function localSubcommandHelp(command) {
                 "Action defaults to `install`.",
             ],
         ],
+        [
+            "release",
+            [
+                "Usage: cockpit release [--dry-run] [--skip-checks] [--tag <tag>] [--access <public|restricted>] [--otp <code>]",
+                "",
+                "Maintainer-only helper. Run from inside the bli-cockpit repo checkout.",
+                "Requires a clean `main` branch and runs `git pull --ff-only` before publishing.",
+                "Delegates to `npm run publish:public -- ...` so public packages are",
+                "built, checked, and published in the safe telemetry-core then CLI order.",
+            ],
+        ],
     ]);
     return (helpByCommand.get(command) ?? [localCommandHelp()]).join("\n");
 }
@@ -244,6 +286,186 @@ async function runInstall(command, io) {
     writeLine(io.stdout, "Next: run `cockpit login`, then `cockpit start` inside the repo; add `--ticket <id>` only when ticket work begins.");
     return 0;
 }
+async function runUpdate(command, io) {
+    const exec = io.exec ?? defaultExec();
+    const installArgs = [
+        "install",
+        "-g",
+        "@bli-cockpit/cli@latest",
+        "--prefer-online",
+    ];
+    if (!command.json) {
+        writeLine(io.stdout, "Updating Cockpit CLI from npm...");
+    }
+    const install = await exec("npm", installArgs);
+    writeExecOutput(io, install, { stdout: !command.json, stderr: true });
+    if (install.code !== 0) {
+        if (command.json) {
+            writeLine(io.stdout, JSON.stringify({
+                status: "blocked",
+                step: "npm_install",
+                command: `npm ${installArgs.join(" ")}`,
+                exit_code: install.code,
+            }, null, 2));
+        }
+        else {
+            writeLine(io.stderr, "BLOCKED: npm install failed; Cockpit CLI was not refreshed.");
+        }
+        return install.code || 1;
+    }
+    if (!command.json) {
+        writeLine(io.stdout, "Cockpit CLI updated. Rechecking onboarding...");
+    }
+    const onboard = await exec("cockpit", [
+        "onboard",
+        ...updateOnboardArgs(command),
+    ]);
+    writeExecOutput(io, onboard, { stdout: true, stderr: true });
+    return onboard.code;
+}
+async function runRelease(command, io) {
+    const releaseRoot = await findPublicReleaseRoot(process.cwd());
+    if (!releaseRoot) {
+        writeLine(io.stderr, "cockpit release must be run inside the bli-cockpit repo checkout (missing publish:public script).");
+        return 1;
+    }
+    const exec = io.exec ?? defaultExec();
+    const gitReady = await prepareReleaseMainBranch(releaseRoot, exec, io);
+    if (!gitReady)
+        return 1;
+    writeLine(io.stdout, "Running Cockpit public package release...");
+    const npmArgs = ["--prefix", releaseRoot, "run", "publish:public"];
+    if (command.args.length > 0)
+        npmArgs.push("--", ...command.args);
+    const releaseExec = io.interactiveExec ?? defaultInteractiveExec();
+    const result = await releaseExec("npm", npmArgs);
+    writeExecOutput(io, result, { stdout: true, stderr: true });
+    return result.code;
+}
+async function prepareReleaseMainBranch(releaseRoot, exec, io) {
+    const branch = await exec("git", [
+        "-C",
+        releaseRoot,
+        "rev-parse",
+        "--abbrev-ref",
+        "HEAD",
+    ]);
+    writeExecOutput(io, branch, { stdout: false, stderr: true });
+    if (branch.code !== 0) {
+        writeLine(io.stderr, "BLOCKED: cockpit release could not read the current git branch.");
+        return false;
+    }
+    const currentBranch = branch.stdout.trim();
+    if (currentBranch !== "main") {
+        writeLine(io.stderr, `BLOCKED: cockpit release only publishes from main. Current branch is ${currentBranch || "unknown"}.`);
+        writeLine(io.stderr, "Merge the release changes, switch to main, then rerun `cockpit release`.");
+        return false;
+    }
+    const status = await exec("git", [
+        "-C",
+        releaseRoot,
+        "status",
+        "--porcelain",
+    ]);
+    writeExecOutput(io, status, { stdout: false, stderr: true });
+    if (status.code !== 0) {
+        writeLine(io.stderr, "BLOCKED: cockpit release could not inspect git status.");
+        return false;
+    }
+    if (status.stdout.trim()) {
+        writeLine(io.stderr, "BLOCKED: cockpit release requires a clean main checkout.");
+        writeLine(io.stderr, "Commit or discard local changes, then rerun `cockpit release`.");
+        return false;
+    }
+    writeLine(io.stdout, "Syncing main with git pull --ff-only...");
+    const pull = await exec("git", ["-C", releaseRoot, "pull", "--ff-only"]);
+    writeExecOutput(io, pull, { stdout: true, stderr: true });
+    if (pull.code !== 0) {
+        writeLine(io.stderr, "BLOCKED: git pull --ff-only failed; main is not safely current.");
+        return false;
+    }
+    return true;
+}
+async function findPublicReleaseRoot(startDir) {
+    let current = path.resolve(startDir);
+    while (true) {
+        const packageJsonPath = path.join(current, "package.json");
+        try {
+            const packageJson = JSON.parse(await readFile(packageJsonPath, "utf8"));
+            if (packageJson.scripts?.["publish:public"] !== undefined)
+                return current;
+        }
+        catch {
+            // Keep walking: nested packages may be missing package.json or have one
+            // without the release script.
+        }
+        const parent = path.dirname(current);
+        if (parent === current)
+            return null;
+        current = parent;
+    }
+}
+function updateOnboardArgs(command) {
+    const args = [];
+    if (command.homeDir)
+        args.push("--home", command.homeDir);
+    for (const root of updateCollectionRoots(command)) {
+        args.push("--workspace", root);
+    }
+    if (command.dashboardUrlExplicit) {
+        args.push("--dashboard-url", command.dashboardUrl);
+    }
+    if (command.claimedOwnerEmail)
+        args.push("--email", command.claimedOwnerEmail);
+    if (command.deviceName)
+        args.push("--device-name", command.deviceName);
+    if (command.activeTicketId)
+        args.push("--ticket", command.activeTicketId);
+    if (command.branch)
+        args.push("--branch", command.branch);
+    if (command.pollIntervalMs !== undefined) {
+        args.push("--poll-interval-ms", String(command.pollIntervalMs));
+    }
+    if (command.timeoutMs !== undefined) {
+        args.push("--timeout-ms", String(command.timeoutMs));
+    }
+    if (command.maxDepth !== undefined)
+        args.push("--max-depth", String(command.maxDepth));
+    if (command.maxRepos !== undefined)
+        args.push("--max-repos", String(command.maxRepos));
+    if (command.json)
+        args.push("--json");
+    return args;
+}
+function updateCollectionRoots(command) {
+    const roots = command.collectionRoots?.length
+        ? command.collectionRoots
+        : command.repoRoot
+            ? [command.repoRoot]
+            : [];
+    const seen = new Set();
+    const deduped = [];
+    for (const root of roots) {
+        if (seen.has(root))
+            continue;
+        seen.add(root);
+        deduped.push(root);
+    }
+    return deduped;
+}
+function writeExecOutput(io, result, options) {
+    if (options.stdout)
+        writeRaw(io.stdout, result.stdout);
+    if (options.stderr)
+        writeRaw(io.stderr, result.stderr);
+}
+function writeRaw(stream, text) {
+    if (!text)
+        return;
+    stream.write(text);
+    if (!text.endsWith("\n"))
+        stream.write("\n");
+}
 function isInteractiveStdin(io) {
     return Boolean(io.stdin.isTTY);
 }
@@ -965,6 +1187,7 @@ async function runStart(command, io) {
             repoRoot: worktree.repo_root,
             branch: command.branch,
             activeTicketId: command.activeTicketId,
+            clearTicket: command.clearTicket,
             topicLabel: command.topicLabel,
             topicSummaryRedacted: command.topicSummaryRedacted,
             workIntent: command.workIntent,
@@ -1343,6 +1566,17 @@ function defaultExec() {
         });
     });
 }
+function defaultInteractiveExec() {
+    return (cmd, args) => new Promise((resolve) => {
+        const child = spawn(cmd, args, { stdio: "inherit" });
+        child.on("error", (error) => {
+            resolve({ code: 1, stdout: "", stderr: errorMessage(error) });
+        });
+        child.on("close", (code) => {
+            resolve({ code: code ?? 1, stdout: "", stderr: "" });
+        });
+    });
+}
 function defaultIo() {
     if (!globalThis.fetch) {
         throw new Error("global fetch is unavailable; use Node.js 20 or newer.");
@@ -1354,6 +1588,7 @@ function defaultIo() {
         env: process.env,
         fetch: globalThis.fetch.bind(globalThis),
         exec: defaultExec(),
+        interactiveExec: defaultInteractiveExec(),
     };
 }
 function writeLine(stream, text) {

package/dist/commands/public-root.js

@@ -22,13 +22,15 @@ function cockpitHelp() {
     "Usage:",
     localCommandHelp(),
     "",
-    "Install/update: `npm install -g @bli-cockpit/cli@latest`.",
+    "Install: `npm install -g @bli-cockpit/cli@latest`.",
+    "Update: run `cockpit update` to refresh the global CLI and rerun onboarding checks.",
     "Intern path: run `cockpit onboard`; it confirms a `/BLI` collection root before syncing.",
     "Headless/reused laptop path: `cockpit onboard --email <email> --workspace ~/BLI`.",
-    "Already onboarded: rerun `cockpit onboard` from anywhere to refresh pairing, roots, agent rules, autostart, and sync.",
+    "Already onboarded: run `cockpit update` from anywhere to refresh pairing, roots, agent rules, autostart, and sync.",
     "Agent setup: `cockpit onboard` refreshes AGENTS.md/CLAUDE.md rules; use `cockpit agent-rules install --workspace ~/BLI` for repair.",
     "Dashboard URL is optional for normal production use; pass `--dashboard-url` only for staging/custom dashboards or forced re-pairing.",
     "Manual collector path: `install`, `login`, `start [--ticket <id>] [--topic <label>] [--intent <intent>] [--phase <phase>]`, `sync`, `status`, `agent-rules`.",
+    "Maintainer release path: merge to main first, then run `cockpit release --dry-run` and `cockpit release` from a clean main checkout.",
   ].join("\n");
 }
 

package/dist/commands/session-sync.js

@@ -114,6 +114,7 @@ export async function runAttributedWorktreeSync(options) {
             homeDir: options.homeDir,
             repoRoot: worktree.repo_root,
             dashboardUrl: options.dashboardUrl,
+            worktreeInventory: worktreeInventoryForRepo(worktree, options.worktrees),
             codexSessionFiles: codexAttribution.results
                 .filter((result) => result.state === "attributed" &&
                 result.worktree?.worktree_fingerprint ===
@@ -510,6 +511,23 @@ function emptyClaudeScan() {
         },
     };
 }
+function worktreeInventoryForRepo(current, worktrees) {
+    return worktrees
+        .filter((worktree) => worktree.repo_fingerprint
+        ? worktree.repo_fingerprint === current.repo_fingerprint
+        : worktree.repo_label === current.repo_label)
+        .map((worktree) => ({
+        repo: worktree.repo_root,
+        repo_label: worktree.repo_label,
+        repo_fingerprint: worktree.repo_fingerprint,
+        repo_origin_url: worktree.repo_origin_url ?? undefined,
+        head_sha: worktree.head_sha ?? undefined,
+        worktree_label: worktree.worktree_label,
+        worktree_fingerprint: worktree.worktree_fingerprint,
+        worktree_is_primary: worktree.worktree_is_primary,
+        branch: worktree.branch,
+    }));
+}
 async function isClaudeCollectionEnabled(paths) {
     const config = await readLocalCollectorConfig(paths).catch(() => null);
     return config?.collect_claude_jsonl !== false;

package/dist/local-state.js

@@ -4,7 +4,7 @@ import { readFileSync } from "node:fs";
 import fs from "node:fs/promises";
 import os from "node:os";
 import path from "node:path";
-import { resolveRepoWorktreeIdentity, } from "./repo-identity.js";
+import { resolveRepoWorktreeIdentity, stableWorktreeFingerprint, stableWorktreeRoot, } from "./repo-identity.js";
 import { normalizeCollectionRoots } from "./root-normalization.js";
 import { summarizeLocalUploadSpool } from "./spool/local-spool.js";
 const localCollectorPackage = JSON.parse(readFileSync(new URL("../package.json", import.meta.url), "utf8"));
@@ -138,6 +138,9 @@ export async function logoutLocalCollector(options = {}) {
     return { removed, session_file: paths.session_file };
 }
 export async function startLocalWorkContext(options = {}) {
+    if (options.activeTicketId && options.clearTicket) {
+        throw new Error("--ticket and --clear-ticket cannot be combined.");
+    }
     const now = options.now ?? new Date();
     const homeDir = options.homeDir ?? os.homedir();
     const repoRoot = path.resolve(options.repoRoot ?? process.cwd());
@@ -161,6 +164,9 @@ export async function startLocalWorkContext(options = {}) {
         worktreeFingerprint: identity.worktree_fingerprint,
     });
     const existingContext = await readLocalWorkContextByFingerprint(paths, identity.worktree_fingerprint).catch(() => null);
+    const activeTicketId = options.clearTicket
+        ? undefined
+        : (options.activeTicketId ?? existingContext?.active_ticket_id);
     const ticketBindingCandidates = options.activeTicketId
         ? [
             {
@@ -170,7 +176,9 @@ export async function startLocalWorkContext(options = {}) {
                 evidence_labels: ["cockpit_start_ticket"],
             },
         ]
-        : [];
+        : options.clearTicket
+            ? []
+            : (existingContext?.ticket_binding_candidates ?? []);
     const context = LocalWorkContextSchema.parse({
         work_context_id: workContextId,
         repo: identity.repo_root,
@@ -186,7 +194,7 @@ export async function startLocalWorkContext(options = {}) {
         session_id: sessionId,
         started_at: existingContext?.started_at ?? now.toISOString(),
         updated_at: now.toISOString(),
-        active_ticket_id: options.activeTicketId ?? undefined,
+        active_ticket_id: activeTicketId,
         ticket_binding_candidates: ticketBindingCandidates,
         topic_label: options.topicLabel,
         topic_summary_redacted: options.topicSummaryRedacted,
@@ -229,8 +237,8 @@ export async function inspectLocalCollectorStatus(options = {}) {
     const identity = await resolveIdentityOrFallback(repoRoot, options.branch);
     const context = await readLocalWorkContextForRepo(paths, repoRoot).catch(() => null);
     const branch = options.branch ?? identity.branch;
-    const freshness = classifyCollectorFreshness(context, now);
     const uploadSpool = await summarizeLocalUploadSpool(paths);
+    const freshness = classifyCollectorFreshness(context, uploadSpool.last_upload_success_at, now);
     const uploadState = !config
         ? "not_installed"
         : uploadSpool.pending_upload_count > 0
@@ -381,14 +389,14 @@ function workContextFile(paths, worktreeFingerprint) {
     return path.join(paths.work_contexts_dir, `${worktreeFingerprint}.json`);
 }
 async function resolveIdentityOrFallback(repoRoot, branchOverride) {
-    const resolvedRoot = path.resolve(repoRoot);
+    const resolvedRoot = await stableWorktreeRoot(repoRoot);
     const identity = await resolveRepoWorktreeIdentity(resolvedRoot).catch(() => null);
     if (identity) {
         return branchOverride ? { ...identity, branch: branchOverride } : identity;
     }
     const repoLabel = path.basename(resolvedRoot) || "workspace";
     const repoFingerprint = `repo-${sha256(`local:${resolvedRoot}`).slice(0, 24)}`;
-    const worktreeFingerprint = `wt-${sha256(`${repoFingerprint}:${resolvedRoot}`).slice(0, 24)}`;
+    const worktreeFingerprint = stableWorktreeFingerprint(resolvedRoot);
     const branch = branchOverride ?? (await resolveGitBranch(resolvedRoot));
     return {
         requested_path: resolvedRoot,
@@ -426,13 +434,24 @@ async function writeJsonFile(filePath, value) {
         await fs.chmod(filePath, 0o600).catch(() => undefined);
     }
 }
-function classifyCollectorFreshness(context, now) {
+export function classifyCollectorFreshness(context, lastUploadSuccessAt, now) {
     if (!context)
         return "missing";
-    const updatedAt = Date.parse(context.updated_at ?? context.started_at);
-    if (!Number.isFinite(updatedAt))
+    const latestActivityAt = latestTimestamp([
+        context.updated_at ?? context.started_at,
+        lastUploadSuccessAt,
+    ]);
+    if (latestActivityAt === null)
         return "stale";
-    return now.getTime() - updatedAt <= 5 * 60 * 1000 ? "fresh" : "stale";
+    return now.getTime() - latestActivityAt <= 5 * 60 * 1000 ? "fresh" : "stale";
+}
+function latestTimestamp(values) {
+    const timestamps = values
+        .map((value) => Date.parse(value ?? ""))
+        .filter((value) => Number.isFinite(value));
+    if (timestamps.length === 0)
+        return null;
+    return Math.max(...timestamps);
 }
 function normalizeDashboardUrl(value) {
     const normalized = value.trim().replace(/\/+$/, "");

package/dist/repo-identity.js

@@ -18,7 +18,7 @@ const SKIPPED_DIR_NAMES = new Set([
 export async function resolveRepoWorktreeIdentity(repoRoot) {
     const requestedPath = path.resolve(repoRoot);
     const gitRoot = await runGit(["rev-parse", "--show-toplevel"], requestedPath);
-    const resolvedRoot = path.resolve(gitRoot.trim() || requestedPath);
+    const resolvedRoot = await stableWorktreeRoot(gitRoot.trim() || requestedPath);
     const branch = await resolveGitBranchWithGit(resolvedRoot);
     const headSha = await runGit(["rev-parse", "HEAD"], resolvedRoot).then((value) => value.trim() || null, () => null);
     const absoluteGitDir = await runGit(["rev-parse", "--absolute-git-dir"], resolvedRoot)
@@ -36,11 +36,6 @@ export async function resolveRepoWorktreeIdentity(repoRoot) {
         ? `origin:${repoOriginUrl}`
         : `local:${sha256(commonGitDir ?? resolvedRoot)}`;
     const repoFingerprint = `repo-${sha256(repoMaterial).slice(0, 24)}`;
-    const worktreeMaterial = [
-        repoFingerprint,
-        resolvedRoot,
-        commonGitDir ?? "",
-    ].join("\n");
     const gitFilePath = path.join(resolvedRoot, ".git");
     const worktreeIsPrimary = await fs.stat(gitFilePath).then((stat) => stat.isDirectory(), () => false);
     return {
@@ -52,7 +47,7 @@ export async function resolveRepoWorktreeIdentity(repoRoot) {
         branch,
         head_sha: headSha,
         worktree_label: path.basename(resolvedRoot),
-        worktree_fingerprint: `wt-${sha256(worktreeMaterial).slice(0, 24)}`,
+        worktree_fingerprint: stableWorktreeFingerprint(resolvedRoot),
         worktree_is_primary: worktreeIsPrimary,
     };
 }
@@ -144,10 +139,9 @@ async function hasGitMarker(dir) {
     return fs.stat(path.join(dir, ".git")).then((stat) => stat.isDirectory() || stat.isFile(), () => false);
 }
 async function fallbackFilesystemIdentity(repoRoot) {
-    const resolvedRoot = path.resolve(repoRoot);
+    const resolvedRoot = await stableWorktreeRoot(repoRoot);
     const repoLabel = path.basename(resolvedRoot) || "repo";
     const repoFingerprint = `repo-${sha256(`local:${resolvedRoot}`).slice(0, 24)}`;
-    const worktreeFingerprint = `wt-${sha256(`${repoFingerprint}:${resolvedRoot}`).slice(0, 24)}`;
     return {
         requested_path: resolvedRoot,
         repo_root: resolvedRoot,
@@ -157,10 +151,17 @@ async function fallbackFilesystemIdentity(repoRoot) {
         branch: await resolveBranchFromHead(resolvedRoot),
         head_sha: null,
         worktree_label: repoLabel,
-        worktree_fingerprint: worktreeFingerprint,
+        worktree_fingerprint: stableWorktreeFingerprint(resolvedRoot),
         worktree_is_primary: true,
     };
 }
+export async function stableWorktreeRoot(repoRoot) {
+    const resolvedRoot = path.resolve(repoRoot);
+    return fs.realpath(resolvedRoot).catch(() => resolvedRoot);
+}
+export function stableWorktreeFingerprint(repoRoot) {
+    return `wt-${sha256(`worktree:${normalizeFingerprintPath(repoRoot)}`).slice(0, 24)}`;
+}
 async function resolveBranchFromHead(repoRoot) {
     try {
         const gitPath = path.join(repoRoot, ".git");
@@ -244,6 +245,10 @@ async function runGit(args, cwd) {
     });
     return stdout;
 }
+function normalizeFingerprintPath(repoRoot) {
+    const resolved = path.resolve(repoRoot);
+    return process.platform === "win32" ? resolved.toLowerCase() : resolved;
+}
 function sha256(value) {
     return crypto.createHash("sha256").update(value, "utf8").digest("hex");
 }

package/dist/upload.js

@@ -101,6 +101,7 @@ export async function buildLocalAmbientEnvelope(options = {}) {
         collector_version: LOCAL_COLLECTOR_VERSION,
         session_reference: sanitizeSessionReference(session),
         work_context: uploadWorkContext,
+        worktree_inventory: options.worktreeInventory ?? [],
         source_scan_results: sanitizeSourceScanResults(sourceCollection.scans, repoLabel),
         events,
     });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bli-cockpit/cli",
-  "version": "0.1.27",
+  "version": "0.1.29",
   "private": false,
   "type": "module",
   "bin": {
@@ -26,6 +26,6 @@
     "test": "node dist/cli.js --help && node ../../scripts/assert-public-package-pack.mjs --workspace=@bli-cockpit/cli"
   },
   "dependencies": {
-    "@bli-cockpit/telemetry-core": "0.1.8"
+    "@bli-cockpit/telemetry-core": "0.1.9"
   }
 }