@bli-cockpit/cli 0.1.19 → 0.1.21

package/dist/agent-rules.js

@@ -15,7 +15,7 @@ export async function installAgentRules(options = {}) {
 }
 async function installAgentRulesForHost(host, options = {}) {
     const rulesFile = agentRulesFile(host, options.homeDir);
-    const block = cockpitAgentRulesBlock();
+    const block = cockpitAgentRulesBlock({ scopePath: options.scopePath });
     let existing = "";
     let existed = true;
     try {
@@ -24,7 +24,7 @@ async function installAgentRulesForHost(host, options = {}) {
     catch {
         existed = false;
     }
-    const prepared = prepareManagedBlockInstall(existing, block);
+    const prepared = prepareManagedBlockInstall(existing, block, options.scopePath);
     if (!prepared.next) {
         return agentRulesResult(host, rulesFile, "unchanged", block, prepared.state);
     }
@@ -78,7 +78,7 @@ export async function inspectAgentRules(options = {}) {
 }
 async function inspectAgentRulesForHost(host, options = {}) {
     const rulesFile = agentRulesFile(host, options.homeDir);
-    const block = cockpitAgentRulesBlock();
+    const block = cockpitAgentRulesBlock({ scopePath: options.scopePath });
     let existing = "";
     try {
         existing = await readFile(rulesFile, "utf8");
@@ -89,23 +89,28 @@ async function inspectAgentRulesForHost(host, options = {}) {
             installed: false,
         };
     }
-    const state = inspectAgentRulesContents(existing);
+    const state = inspectAgentRulesContents(existing, block, options.scopePath);
     const installed = state === "managed" || state === "equivalent";
     return {
         ...agentRulesResult(host, rulesFile, installed ? "unchanged" : "missing", block, state),
         installed,
     };
 }
-export function cockpitAgentRulesBlock() {
+export function cockpitAgentRulesBlock(options = {}) {
+    const scopePath = options.scopePath ? path.resolve(options.scopePath) : null;
+    const scopeLine = scopePath
+        ? `- This guidance only applies when the current working directory is inside the Cockpit-onboarded workspace/repo: \`${scopePath}\`. Outside that folder, do not run Cockpit ticket binding or sync commands for private chats or unrelated repos.`
+        : "- This guidance only applies when the current working directory is inside the workspace/repo that ran `cockpit onboard` or `cockpit agent-rules install`. Outside that folder, do not run Cockpit ticket binding or sync commands for private chats or unrelated repos.";
     return [
         MANAGED_BLOCK_START,
         "## Cockpit Ticket Binding",
         "",
-        "- For implementation, debugging, review, PR, or ship work tied to a clear Linear ticket, run `cockpit start --ticket <ticket-id> --repo \"$PWD\"` before the first code edit or mutating tool call. This starts attributing the session's work to that specific ticket in Cockpit.",
+        scopeLine,
+        "- For implementation, debugging, review, PR, or ship work tied to a clear Linear ticket, run `cockpit start --ticket <ticket-id> --workspace \"$PWD\"` before the first code edit or mutating tool call. This starts attributing the session's work to that specific ticket in Cockpit.",
         "- Use `--ticket`; do not invent `--ticketId` or other flag shapes.",
         "- If the user mentions ticketed work but no ticket ID is visible, ask once for the Linear ticket ID before editing. Agents cannot reliably infer it from context.",
         "- If there is truly no ticket, state that the work remains in general ambient capture and do not invent a ticket.",
-        "- After the first meaningful checkpoint, run `cockpit sync --repo \"$PWD\" --json` so Cockpit has fresh ticket/session binding metadata.",
+        "- After the first meaningful checkpoint, run `cockpit sync --workspace \"$PWD\" --json` so Cockpit has fresh ticket/session binding metadata.",
         MANAGED_BLOCK_END,
     ].join("\n");
 }
@@ -126,16 +131,19 @@ export function removeManagedBlock(contents) {
         return contents;
     return contents.replace(managedBlockPattern(), "").replace(/\n{3,}/gu, "\n\n").trimEnd() + "\n";
 }
-function prepareManagedBlockInstall(contents, block) {
+function prepareManagedBlockInstall(contents, block, scopePath) {
     if (!contents.trim())
         return { next: `${block}\n`, state: "missing" };
     if (hasManagedBlock(contents)) {
-        return { next: upsertManagedBlock(contents, block), state: "managed" };
+        return {
+            next: upsertManagedBlock(contents, block),
+            state: extractManagedBlock(contents) === block ? "managed" : "stale",
+        };
     }
-    if (hasEquivalentUnmanagedTicketBinding(contents)) {
+    if (hasEquivalentUnmanagedTicketBinding(contents, scopePath)) {
         return { next: null, state: "equivalent" };
     }
-    const staleBlock = findStaleUnmanagedTicketBindingBlock(contents);
+    const staleBlock = findStaleUnmanagedTicketBindingBlock(contents, scopePath);
     if (staleBlock) {
         return {
             next: replaceLineSpan(contents, staleBlock.startLine, staleBlock.endLine, block),
@@ -144,12 +152,13 @@ function prepareManagedBlockInstall(contents, block) {
     }
     return { next: `${contents.replace(/\s+$/u, "")}\n\n${block}\n`, state: "missing" };
 }
-function inspectAgentRulesContents(contents) {
-    if (hasManagedBlock(contents))
-        return "managed";
-    if (hasEquivalentUnmanagedTicketBinding(contents))
+function inspectAgentRulesContents(contents, block, scopePath) {
+    if (hasManagedBlock(contents)) {
+        return extractManagedBlock(contents) === block ? "managed" : "stale";
+    }
+    if (hasEquivalentUnmanagedTicketBinding(contents, scopePath))
         return "equivalent";
-    if (findStaleUnmanagedTicketBindingBlock(contents))
+    if (findStaleUnmanagedTicketBindingBlock(contents, scopePath))
         return "stale";
     return "missing";
 }
@@ -188,10 +197,17 @@ function aggregateAgentRulesResult(targets) {
 function managedBlockPattern() {
     return new RegExp(`${escapeRegExp(MANAGED_BLOCK_START)}[\\s\\S]*?${escapeRegExp(MANAGED_BLOCK_END)}`, "u");
 }
-function hasEquivalentUnmanagedTicketBinding(contents) {
+function extractManagedBlock(contents) {
+    return contents.match(managedBlockPattern())?.[0] ?? null;
+}
+function hasEquivalentUnmanagedTicketBinding(contents, scopePath) {
     const text = normalizeRuleText(contents);
     if (!hasTicketBindingCues(text))
         return false;
+    if (!hasRepoScopeGuard(text))
+        return false;
+    if (scopePath && !hasScopePath(text, scopePath))
+        return false;
     const signals = [
         /cockpit\s+start\s+--ticket\b/u,
         /before\s+(?:the\s+)?first\s+code\s+edit|before\s+ticketed\s+implementation/u,
@@ -203,7 +219,15 @@ function hasEquivalentUnmanagedTicketBinding(contents) {
     const score = signals.filter((signal) => signal.test(text)).length;
     return score >= 5;
 }
-function findStaleUnmanagedTicketBindingBlock(contents) {
+function hasScopePath(text, scopePath) {
+    return text.includes(normalizeRuleText(path.resolve(scopePath)));
+}
+function hasRepoScopeGuard(text) {
+    return (/only\s+applies\s+when\s+the\s+current\s+working\s+directory\s+is\s+inside/u.test(text) ||
+        /outside\s+that\s+(?:folder|workspace|repo).*(?:do\s+not|dont)\s+run\s+cockpit/u.test(text) ||
+        /private\s+chats\s+or\s+unrelated\s+repos/u.test(text));
+}
+function findStaleUnmanagedTicketBindingBlock(contents, scopePath) {
     const lines = contents.split("\n");
     for (let index = 0; index < lines.length; index += 1) {
         if (!/^#{1,6}\s+.*(?:cockpit\s+)?ticket\s+binding\b/iu.test(lines[index] ?? "")) {
@@ -218,7 +242,8 @@ function findStaleUnmanagedTicketBindingBlock(contents) {
         }
         const candidate = lines.slice(index, endLine).join("\n");
         const normalized = normalizeRuleText(candidate);
-        if (hasTicketBindingCues(normalized) && !hasEquivalentUnmanagedTicketBinding(candidate)) {
+        if (hasTicketBindingCues(normalized) &&
+            !hasEquivalentUnmanagedTicketBinding(candidate, scopePath)) {
             return { startLine: index, endLine };
         }
     }

package/dist/commands/local-args.js

@@ -5,6 +5,7 @@
 // Behavior-preserving extraction: functions moved verbatim, no logic change.
 import { DEFAULT_DASHBOARD_URL } from "../local-state.js";
 import { DEFAULT_AUTOSTART_INTERVAL_SECONDS } from "../autostart.js";
+import { IntentSourceSchema, WorkIntentSchema, WorkPhaseSchema, } from "@bli-cockpit/telemetry-core";
 const WORK_ROOT_FLAGS = ["--repo", "--workspace"];
 export function parseLocalArgs(argv) {
     const command = argv[0];
@@ -165,6 +166,12 @@ function parseStartArgs(args) {
             "--workspace",
             "--branch",
             "--ticket",
+            "--topic",
+            "--topic-summary",
+            "--intent",
+            "--phase",
+            "--intent-source",
+            "--intent-confidence",
             "--operator-id",
             "--session-id",
             "--json",
@@ -177,6 +184,12 @@ function parseStartArgs(args) {
             "--workspace",
             "--branch",
             "--ticket",
+            "--topic",
+            "--topic-summary",
+            "--intent",
+            "--phase",
+            "--intent-source",
+            "--intent-confidence",
             "--operator-id",
             "--session-id",
             "--max-depth",
@@ -184,12 +197,28 @@ function parseStartArgs(args) {
         ],
     });
     assertNoPositionals(values.positionals, "start");
+    const topicLabel = optionalNonEmpty(values.flags.get("--topic"));
+    const topicSummaryRedacted = optionalNonEmpty(values.flags.get("--topic-summary"));
+    const workIntent = optionalSchemaValue(WorkIntentSchema, values.flags.get("--intent"), "--intent");
+    const workPhase = optionalSchemaValue(WorkPhaseSchema, values.flags.get("--phase"), "--phase");
+    const intentConfidence = optionalConfidence(values.flags.get("--intent-confidence"), "--intent-confidence");
+    const explicitIntentMetadata = Boolean(topicLabel ||
+        topicSummaryRedacted ||
+        workIntent ||
+        workPhase ||
+        intentConfidence !== undefined);
     return {
         kind: "start",
         homeDir: optionalNonEmpty(values.flags.get("--home")),
         repoRoot: optionalNonEmpty(workRootFlagValue(values)),
         branch: optionalNonEmpty(values.flags.get("--branch")),
         activeTicketId: optionalNonEmpty(values.flags.get("--ticket")),
+        topicLabel,
+        topicSummaryRedacted,
+        workIntent,
+        workPhase,
+        intentSource: optionalSchemaValue(IntentSourceSchema, values.flags.get("--intent-source"), "--intent-source") ?? (explicitIntentMetadata ? "explicit_user" : undefined),
+        intentConfidence,
         operatorId: optionalNonEmpty(values.flags.get("--operator-id")),
         sessionId: optionalNonEmpty(values.flags.get("--session-id")),
         json: values.booleans.has("--json"),
@@ -345,8 +374,8 @@ function parseAutostartArgs(args) {
 }
 function parseAgentRulesArgs(args) {
     const values = parseNamedArgs(args, {
-        allowedFlags: ["--home", "--host", "--json"],
-        valueFlags: ["--home", "--host"],
+        allowedFlags: ["--home", "--host", "--repo", "--workspace", "--json"],
+        valueFlags: ["--home", "--host", "--repo", "--workspace"],
     });
     if (values.positionals.length > 1) {
         throw new Error("agent-rules accepts at most one action (install|uninstall|status).");
@@ -360,6 +389,7 @@ function parseAgentRulesArgs(args) {
         action,
         host: parseAgentRulesHost(values.flags.get("--host")),
         homeDir: optionalNonEmpty(values.flags.get("--home")),
+        repoRoot: optionalNonEmpty(workRootFlagValue(values)),
         json: values.booleans.has("--json"),
     };
 }
@@ -443,6 +473,25 @@ function optionalPositiveInteger(value, flag) {
     }
     return parsed;
 }
+function optionalConfidence(value, flag) {
+    if (value === undefined)
+        return undefined;
+    const parsed = Number(value);
+    if (!Number.isFinite(parsed) || parsed < 0 || parsed > 1) {
+        throw new Error(`${flag} must be a number between 0 and 1.`);
+    }
+    return parsed;
+}
+function optionalSchemaValue(schema, value, flag) {
+    const trimmed = optionalNonEmpty(value);
+    if (!trimmed)
+        return undefined;
+    const parsed = schema.safeParse(trimmed);
+    if (!parsed.success || parsed.data === undefined) {
+        throw new Error(`${flag} has an unsupported value.`);
+    }
+    return parsed.data;
+}
 export function normalizeUrl(value) {
     const trimmed = value.trim().replace(/\/+$/, "");
     if (!trimmed)

package/dist/commands/local.js

@@ -80,13 +80,13 @@ export function localCommandHelp(command) {
         "  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>] [--workspace <path>] [--branch <name>] [--max-depth <n>] [--max-repos <n>] [--json]",
+        "  cockpit start [--ticket <id>] [--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] [--json]",
+        "  cockpit agent-rules [install|uninstall|status] [--host codex|claude|all] [--workspace <path>] [--json]",
         "",
         `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");
@@ -138,11 +138,14 @@ function localSubcommandHelp(command) {
         [
             "start",
             [
-                "Usage: cockpit start [--ticket <id>] [--workspace <path>] [--branch <name>] [--json]",
+                "Usage: cockpit start [--ticket <id>] [--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.",
-                "`--repo <path>` remains supported and is still the canonical agent-rule spelling.",
+                "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.",
+                "`--repo <path>` remains supported as a backward-compatible alias; use --workspace in agent guidance.",
             ],
         ],
         [
@@ -209,13 +212,12 @@ function localSubcommandHelp(command) {
         [
             "agent-rules",
             [
-                "Usage: cockpit agent-rules [install|uninstall|status] [--host codex|claude|all] [--json]",
+                "Usage: cockpit agent-rules [install|uninstall|status] [--host codex|claude|all] [--workspace <path>] [--json]",
                 "",
                 "Installs a managed Cockpit Ticket Binding block into ~/.codex/AGENTS.md",
                 "and ~/.claude/CLAUDE.md by default. Pass --host to manage only one.",
-                "This gives Codex and Claude agents a user-scope rule to run",
-                "`cockpit start --ticket <id>` before ticketed implementation work, or ask",
-                "once when the ticket ID is missing.",
+                "The block is scoped to --workspace, or the current directory when omitted,",
+                "so Codex and Claude only run Cockpit ticket binding inside that onboarded folder.",
                 "Action defaults to `install`.",
             ],
         ],
@@ -314,19 +316,23 @@ async function maybeOfferAutostart(command, io) {
 async function maybeOfferAgentRules(command, io) {
     if (command.json || !isInteractiveStdin(io))
         return;
-    const current = await inspectAgentRules({ homeDir: command.homeDir });
+    const scopePath = path.resolve(command.repoRoot ?? process.cwd());
+    const current = await inspectAgentRules({
+        homeDir: command.homeDir,
+        scopePath,
+    });
     if (current.installed) {
         writeLine(io.stdout, onboardAgentRulesAlreadyInstalledLine(current));
         return;
     }
-    const answer = (await readLine(io, "Add Cockpit ticket-binding rules to AGENTS.md and CLAUDE.md? [Y/n] "))
+    const answer = (await readLine(io, `Add Cockpit ticket-binding rules scoped to ${scopePath} to AGENTS.md and CLAUDE.md? [Y/n] `))
         .trim()
         .toLowerCase();
     if (answer === "n" || answer === "no") {
-        writeLine(io.stdout, "Skipped agent rules. Run `cockpit agent-rules install` anytime.");
+        writeLine(io.stdout, "Skipped agent rules. Run `cockpit agent-rules install --workspace \"$PWD\"` anytime.");
         return;
     }
-    const result = await installAgentRules({ homeDir: command.homeDir });
+    const result = await installAgentRules({ homeDir: command.homeDir, scopePath });
     writeLine(io.stdout, `Agent rules: ${onboardAgentRulesInstallLine(result)}`);
     for (const target of result.targets) {
         writeLine(io.stdout, `${agentRuleHostLabel(target.host)}: ${target.rules_file}`);
@@ -776,7 +782,7 @@ function nextStepForOnboardBlocker(blocker) {
         case "install":
             return "Rerun `cockpit onboard` from the repo root; it will reinstall local config.";
         case "work_context":
-            return "Run `cockpit start --ticket <id> --repo \"$PWD\"`, then retry `cockpit sync`.";
+            return "Run `cockpit start --ticket <id> --workspace \"$PWD\"`, then retry `cockpit sync`.";
         default:
             return "Run `cockpit status --json` and report the blocker label plus last failure reason.";
     }
@@ -800,6 +806,12 @@ async function runStart(command, io) {
             repoRoot: worktree.repo_root,
             branch: command.branch,
             activeTicketId: command.activeTicketId,
+            topicLabel: command.topicLabel,
+            topicSummaryRedacted: command.topicSummaryRedacted,
+            workIntent: command.workIntent,
+            workPhase: command.workPhase,
+            intentSource: command.intentSource,
+            intentConfidence: command.intentConfidence,
             operatorId: command.operatorId,
             sessionId: command.sessionId,
         })));
@@ -822,6 +834,9 @@ async function runStart(command, io) {
     writeLine(io.stdout, `Repo: ${context.repo}`);
     writeLine(io.stdout, `Branch: ${context.branch}`);
     writeLine(io.stdout, `Ticket: ${displayTicketId(context.active_ticket_id)}`);
+    if (context.topic_label || context.work_intent || context.work_phase) {
+        writeLine(io.stdout, `Topic: ${context.topic_label ?? "unlabeled"} · ${context.work_intent ?? "unknown"} · ${context.work_phase ?? "unknown"}`);
+    }
     writeLine(io.stdout, `Context: ${context.work_context_id}`);
     return 0;
 }
@@ -1081,11 +1096,12 @@ async function runAutostart(command, io) {
 }
 async function runAgentRules(command, io) {
     const hosts = agentRuleHosts(command.host);
+    const scopePath = path.resolve(command.repoRoot ?? process.cwd());
     const result = command.action === "install"
-        ? await installAgentRules({ homeDir: command.homeDir, hosts })
+        ? await installAgentRules({ homeDir: command.homeDir, hosts, scopePath })
         : command.action === "uninstall"
             ? await uninstallAgentRules({ homeDir: command.homeDir, hosts })
-            : await inspectAgentRules({ homeDir: command.homeDir, hosts });
+            : await inspectAgentRules({ homeDir: command.homeDir, hosts, scopePath });
     if (command.json) {
         writeLine(io.stdout, JSON.stringify(result, null, 2));
         return 0;

package/dist/commands/public-root.js

@@ -25,9 +25,9 @@ function cockpitHelp() {
     "Install/update: `npm install -g @bli-cockpit/cli@latest`.",
     "Intern path: run `cockpit onboard` from the repo root; add `--ticket <id>` only when work already has a ticket.",
     "Already onboarded: run `cockpit sync --workspace \"$PWD\" --json`.",
-    "Agent setup: interactive `cockpit onboard` offers AGENTS.md/CLAUDE.md rules; use `cockpit agent-rules install` for repair/headless setup.",
+    "Agent setup: interactive `cockpit onboard` offers AGENTS.md/CLAUDE.md rules; use `cockpit agent-rules install --workspace \"$PWD\"` for repair/headless setup.",
     "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>]`, `sync`, `status`, `agent-rules`.",
+    "Manual collector path: `install`, `login`, `start [--ticket <id>] [--topic <label>] [--intent <intent>] [--phase <phase>]`, `sync`, `status`, `agent-rules`.",
   ].join("\n");
 }
 

package/dist/commands/session-sync.js

@@ -120,7 +120,9 @@ export async function runAttributedWorktreeSync(options) {
                 local_path: result.file_path,
                 codex_session_id: result.codex_session_id,
             })),
+            codexAttributionScan: codexAttribution,
             claudeSessionFiles,
+            claudeAttributionScan: claudeAttribution,
             rawEvidenceBudget,
             fetch: options.fetchImpl,
         };
@@ -480,8 +482,20 @@ function buildAgentSessionSummary(options) {
 function emptyClaudeScan() {
     return {
         results: [],
+        discovered_session_count: 0,
         scanned_session_count: 0,
+        since_minutes: 0,
+        session_limit: 0,
+        session_limit_applied: false,
+        max_file_bytes: 0,
+        max_sidecar_files: 0,
+        max_line_buffer_bytes: 0,
         project_dirs_skipped: 0,
+        project_dir_read_failed_count: 0,
+        session_stat_failed_count: 0,
+        sidecar_dir_read_failed_count: 0,
+        sidecar_stat_failed_count: 0,
+        disabled_reason: "claude_collection_disabled_by_config",
         counts: {
             attributed: 0,
             ambiguous: 0,

package/dist/local-state.js

@@ -170,6 +170,12 @@ export async function startLocalWorkContext(options = {}) {
         updated_at: now.toISOString(),
         active_ticket_id: options.activeTicketId ?? undefined,
         ticket_binding_candidates: ticketBindingCandidates,
+        topic_label: options.topicLabel,
+        topic_summary_redacted: options.topicSummaryRedacted,
+        work_intent: options.workIntent,
+        work_phase: options.workPhase,
+        intent_source: options.intentSource,
+        intent_confidence: options.intentConfidence,
         pull_request_url: existingContext?.pull_request_url,
         provenance: {
             capture_source: "collector_runtime",
@@ -285,7 +291,7 @@ export async function readLocalWorkContextForRepo(paths, repoRoot) {
         path.resolve(active.repo) === identity.repo_root) {
         return active;
     }
-    throw new Error(`Active work context missing for ${identity.worktree_label}. Run \`cockpit start --repo "${identity.repo_root}"\`.`);
+    throw new Error(`Active work context missing for ${identity.worktree_label}. Run \`cockpit start --workspace "${identity.repo_root}"\`.`);
 }
 async function readLocalWorkContextByFingerprint(paths, worktreeFingerprint) {
     return LocalWorkContextSchema.parse(await readJsonFile(workContextFile(paths, worktreeFingerprint)));

package/dist/upload.js

@@ -1,4 +1,4 @@
-import { AgentImageArtifactReportRequestSchema, TelemetryIngestEnvelopeSchema, TelemetryIngestEventDtoSchema, } from "@bli-cockpit/telemetry-core";
+import { AgentImageArtifactReportRequestSchema, EvidenceCompletenessPayloadSchema, TelemetryIngestEnvelopeSchema, TelemetryIngestEventDtoSchema, } from "@bli-cockpit/telemetry-core";
 import path from "node:path";
 import { getCollectorRuntimePaths, LOCAL_COLLECTOR_VERSION, readLocalCollectorConfig, readLocalCollectorSessionFile, readLocalSessionReference, readLocalWorkContextForRepo, } from "./local-state.js";
 import { runLocalSourceCollectors } from "./adapters/local-sources.js";
@@ -62,7 +62,9 @@ export async function buildLocalAmbientEnvelope(options = {}) {
         rawEvidenceIncludeCodexJsonl: options.rawEvidenceIncludeCodexJsonl,
         rawEvidenceIncludeClaudeJsonl: options.rawEvidenceIncludeClaudeJsonl,
         rawEvidenceCodexSessionFiles: options.codexSessionFiles,
+        rawEvidenceCodexAttributionScan: options.codexAttributionScan,
         rawEvidenceClaudeSessionFiles: options.claudeSessionFiles,
+        rawEvidenceClaudeAttributionScan: options.claudeAttributionScan,
         rawEvidenceSkipContentHashes: skipContentHashes,
         rawEvidenceByteBudget: options.rawEvidenceByteBudget,
         rawEvidenceObjectBudget: options.rawEvidenceObjectBudget,
@@ -534,12 +536,29 @@ function pruneUndurablePointers(envelope, outcomes) {
         .filter((outcome) => outcome.upload_state === "upload_failed" &&
         !durablePointerIds.has(outcome.pointer.raw_evidence_pointer_id))
         .map((outcome) => outcome.pointer.raw_evidence_pointer_id));
+    const failedOutcomes = outcomes.filter((outcome) => failedPointerIds.has(outcome.pointer.raw_evidence_pointer_id));
     if (failedPointerIds.size === 0)
         return envelope;
     return {
         ...envelope,
         events: envelope.events.map((event) => ({
             ...event,
+            metrics: {
+                ...event.metrics,
+                evidence_failed_count: (event.metrics["evidence_failed_count"] ?? 0) +
+                    failedOutcomes.length,
+            },
+            attributes: event.evidence_completeness
+                ? {
+                    ...event.attributes,
+                    evidence_completeness_schema_version: event.evidence_completeness.schema_version,
+                    evidence_completeness_status: "partial",
+                    evidence_incomplete: true,
+                }
+                : event.attributes,
+            evidence_completeness: event.evidence_completeness
+                ? markCompletenessUploadFailures(event.evidence_completeness, failedOutcomes)
+                : event.evidence_completeness,
             raw_evidence_pointers: event.raw_evidence_pointers.filter((pointer) => !failedPointerIds.has(pointer.raw_evidence_pointer_id)),
             redaction: {
                 ...event.redaction,
@@ -548,6 +567,71 @@ function pruneUndurablePointers(envelope, outcomes) {
         })),
     };
 }
+function markCompletenessUploadFailures(completeness, failedOutcomes) {
+    const failureCounts = new Map();
+    for (const outcome of failedOutcomes) {
+        const source = outcome.kind ?? "raw_evidence";
+        failureCounts.set(source, (failureCounts.get(source) ?? 0) + 1);
+    }
+    const totalFailures = [...failureCounts.values()].reduce((sum, count) => sum + count, 0);
+    const sourceCounts = [...completeness.source_counts];
+    for (const [source, count] of failureCounts) {
+        const existingIndex = sourceCounts.findIndex((entry) => entry.source === source);
+        if (existingIndex === -1) {
+            sourceCounts.push({
+                source,
+                scanned_count: 0,
+                included_count: 0,
+                skipped_count: 0,
+                truncated_count: 0,
+                deferred_count: 0,
+                reused_count: 0,
+                failed_count: count,
+            });
+            continue;
+        }
+        const existing = sourceCounts[existingIndex];
+        if (!existing)
+            continue;
+        sourceCounts[existingIndex] = {
+            ...existing,
+            failed_count: existing.failed_count + count,
+        };
+    }
+    const failureReasons = [...completeness.failure_reasons];
+    for (const [source, count] of failureCounts) {
+        const reason = "upload_failed";
+        const existingIndex = failureReasons.findIndex((entry) => entry.source === source && entry.reason === reason);
+        if (existingIndex === -1) {
+            failureReasons.push({ source, reason, count });
+        }
+        else {
+            const existing = failureReasons[existingIndex];
+            if (existing) {
+                failureReasons[existingIndex] = {
+                    ...existing,
+                    count: existing.count + count,
+                };
+            }
+        }
+    }
+    return EvidenceCompletenessPayloadSchema.parse({
+        ...completeness,
+        status: "partial",
+        source_counts: sourceCounts,
+        totals: {
+            ...completeness.totals,
+            failed_count: completeness.totals.failed_count + totalFailures,
+        },
+        failure_reasons: failureReasons.sort((a, b) => `${a.source}:${a.reason}`.localeCompare(`${b.source}:${b.reason}`)),
+        notes: [
+            ...new Set([
+                ...completeness.notes,
+                "Some collected evidence did not become durable; downstream analysis should lower confidence.",
+            ]),
+        ],
+    });
+}
 function makeUploadWorkContext(options) {
     const provenance = makeCollectorProvenance({
         context: options.activeContext,
@@ -575,6 +659,7 @@ function makeSourceScanCompletedEvent(options) {
         throw new Error("Upload work context is missing provenance.");
     }
     const rawEvidencePointers = options.rawEvidenceFacts?.pointers ?? [];
+    const evidenceCompleteness = options.rawEvidenceFacts?.evidence_completeness;
     const hasRawEvidence = rawEvidencePointers.length > 0;
     const eventPrivacyClassification = hasRawEvidence
         ? "redacted_summary"
@@ -617,6 +702,13 @@ function makeSourceScanCompletedEvent(options) {
             raw_evidence_byte_size: options.rawEvidenceFacts?.byte_size ?? 0,
             raw_evidence_skipped_count: options.rawEvidenceFacts?.skipped_count ?? 0,
             raw_evidence_reused_count: options.rawEvidenceFacts?.reused_count ?? 0,
+            evidence_scanned_count: evidenceCompleteness?.totals.scanned_count ?? 0,
+            evidence_included_count: evidenceCompleteness?.totals.included_count ?? 0,
+            evidence_skipped_count: evidenceCompleteness?.totals.skipped_count ?? 0,
+            evidence_truncated_count: evidenceCompleteness?.totals.truncated_count ?? 0,
+            evidence_deferred_count: evidenceCompleteness?.totals.deferred_count ?? 0,
+            evidence_reused_count: evidenceCompleteness?.totals.reused_count ?? 0,
+            evidence_failed_count: evidenceCompleteness?.totals.failed_count ?? 0,
         },
         attributes: {
             repo_label: options.context.repo,
@@ -634,7 +726,31 @@ function makeSourceScanCompletedEvent(options) {
                 ? "remote_durable_raw_evidence"
                 : "metadata_only",
             raw_payload_included: false,
+            evidence_completeness_schema_version: evidenceCompleteness?.schema_version ?? "evidence-completeness.v1",
+            evidence_completeness_status: evidenceCompleteness?.status ?? "unknown",
+            evidence_incomplete: evidenceCompleteness
+                ? evidenceCompleteness.status !== "complete"
+                : true,
+            ...(options.context.topic_label
+                ? { topic_label: options.context.topic_label }
+                : {}),
+            ...(options.context.topic_summary_redacted
+                ? { topic_summary_redacted: options.context.topic_summary_redacted }
+                : {}),
+            ...(options.context.work_intent
+                ? { work_intent: options.context.work_intent }
+                : {}),
+            ...(options.context.work_phase
+                ? { work_phase: options.context.work_phase }
+                : {}),
+            ...(options.context.intent_source
+                ? { intent_source: options.context.intent_source }
+                : {}),
+            ...(options.context.intent_confidence !== undefined
+                ? { intent_confidence: options.context.intent_confidence }
+                : {}),
         },
+        evidence_completeness: evidenceCompleteness,
         ticket_binding: options.ticketBinding ?? undefined,
         risk_flags: options.riskFlags,
         raw_evidence_pointers: rawEvidencePointers,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bli-cockpit/cli",
-  "version": "0.1.19",
+  "version": "0.1.21",
   "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.5"
+    "@bli-cockpit/telemetry-core": "0.1.7"
   }
 }