@bli-cockpit/cli 0.2.5 → 0.2.8

package/dist/commands/public-root.js

@@ -7,6 +7,11 @@ export async function runCockpitCli(argv, io) {
     return 0;
   }
 
+  if (command === "--version" || command === "-V" || command === "version") {
+    writeLine(io?.stdout ?? process.stdout, "0.2.8");
+    return 0;
+  }
+
   if (rootCommandNames.has(command)) {
     return runLocalCockpitCli(argv, io);
   }
@@ -31,7 +36,7 @@ function cockpitHelp() {
     "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.",
+    "Maintainer release path: merge to main, publish to `next` with `cockpit release`, canary Windows plus Apple Silicon, then deliberately promote that exact version to `latest`.",
   ].join("\n");
 }
 

package/dist/commands/session-sync.js

@@ -5,24 +5,112 @@
 // Behavior-preserving extraction: moved verbatim from local.ts, no logic change.
 import os from "node:os";
 import path from "node:path";
-import { getCollectorRuntimePaths, startLocalWorkContext, readLocalCollectorConfig } from "../local-state.js";
+import { getCollectorRuntimePaths, readLocalCollectorConfig, startLocalWorkContext, startLocalWorkContextForAttributedTarget, } from "../local-state.js";
 import { CODEX_SESSION_ATTRIBUTION_STATE_RANK, } from "@bli-cockpit/telemetry-core";
-import { LocalUploadBlockedError, postCodexSessionReport, syncLocalAmbientEnvelope } from "../upload.js";
+import { flushPendingCodexSessionReports, LocalUploadBlockedError, queueCodexSessionReport, syncLocalAmbientEnvelope, } from "../upload.js";
 import { CODEX_ATTRIBUTION_SCAN_WINDOW_SESSION_LIMIT, CODEX_ATTRIBUTION_SCAN_WINDOW_MINUTES, defaultCodexSessionDirs, scanAndAttributeCodexSessions, } from "../adapters/codex-attribution.js";
 import { scanAndAttributeClaudeSessions } from "../adapters/claude-attribution.js";
 import { RAW_EVIDENCE_DEFAULT_BYTE_BUDGET, RAW_EVIDENCE_DEFAULT_OBJECT_BUDGET } from "../adapters/raw-evidence.js";
 import { CLAUDE_CURSOR_FILENAME, countStaleSessions, emptyRawEvidenceCursorState, readRawEvidenceCursor, recordSessionObservation, writeRawEvidenceCursor } from "../cursors/raw-evidence-cursor.js";
 import { normalizeCollectionRoots } from "../root-normalization.js";
+import { clearSourceRetryFailure, readLocalUploadSpoolState, recordSourceRetryFailure, } from "../spool/local-spool.js";
+import { isLiveRawEvidenceSyncAttribution, } from "../raw-evidence-attribution-policy.js";
 const CLAUDE_FIRST_RUN_BACKFILL_MINUTES = 14 * 24 * 60;
 const CLAUDE_DAMP_GROWTH_BYTES = 256 * 1024;
 const CLAUDE_DAMP_MAX_AGE_MS = 6 * 60 * 60 * 1000;
+/**
+ * Live sync remains reason-allowlisted even though historical backfill accepts
+ * every deterministic fallback state.
+ */
+export function isLiveSyncCollectableAttributionState(state, reason) {
+    return isLiveRawEvidenceSyncAttribution(state, reason);
+}
+function cursorHasUndurableCollectableSession(cursor) {
+    return Object.values(cursor.sessions).some((entry) => liveSyncCursorEntryRequiresRetry(entry));
+}
+export function liveSyncCursorEntryRequiresRetry(entry) {
+    return (!entry.uploaded_object_key &&
+        (isLiveSyncCollectableAttributionState(entry.state, entry.reason) ||
+            entry.reason === "repo_not_on_disk"));
+}
+function allLocalHistorySinceMinutes(now) {
+    // A cutoff just before the Unix epoch is effectively unbounded for Codex and
+    // Claude session files while keeping date arithmetic finite and portable.
+    return Math.ceil(now.getTime() / 60_000) + 24 * 60;
+}
+function codexAttributionReadFailureCount(scan) {
+    return scan.directory_read_failed_count + scan.stat_failed_count;
+}
+function claudeAttributionReadFailureCount(scan) {
+    return (scan.project_dir_read_failed_count +
+        scan.session_stat_failed_count +
+        scan.sidecar_dir_read_failed_count +
+        scan.sidecar_stat_failed_count);
+}
+export function sourceScanRetryReason(source, scan) {
+    const reasons = new Set();
+    const readFailureCount = source === "codex"
+        ? codexAttributionReadFailureCount(scan)
+        : claudeAttributionReadFailureCount(scan);
+    if (readFailureCount > 0) {
+        reasons.add(`${source}_session_store_read_failed`);
+    }
+    if (scan.results.some((result) => result.reason === "repo_not_on_disk")) {
+        reasons.add("repo_not_on_disk");
+    }
+    return reasons.size > 0 ? [...reasons].sort().join(",") : null;
+}
+async function reconcileSourceScanRetry(options) {
+    if (options.reason) {
+        await recordSourceRetryFailure(options.paths, {
+            source: options.source,
+            reason: options.reason,
+            attemptedAt: options.attemptedAt,
+        });
+        return;
+    }
+    if (options.pendingBefore) {
+        await clearSourceRetryFailure(options.paths, options.source, options.attemptedAt);
+    }
+}
+export function matchesLiveSyncWorktree(result, target) {
+    return (isLiveRawEvidenceSyncAttribution(result.state, result.reason) &&
+        result.worktree !== null &&
+        liveSyncTargetKey(result.worktree) === liveSyncTargetKey(target));
+}
+function liveSyncTargetKey(worktree) {
+    return `${worktree.repo_fingerprint}:${worktree.worktree_fingerprint}`;
+}
+/**
+ * Folder and deleted-repo fallbacks can intentionally synthesize a worktree
+ * identity that is not present in git discovery. Include those identities as
+ * sync targets so a wrapper-root session is not observed and then stranded.
+ */
+export function liveSyncTargetWorktrees(discovered, results) {
+    const targets = [...discovered];
+    const seen = new Set(discovered.map(liveSyncTargetKey));
+    for (const result of results) {
+        const targetKey = result.worktree
+            ? liveSyncTargetKey(result.worktree)
+            : null;
+        if (!isLiveSyncCollectableAttributionState(result.state, result.reason) ||
+            !result.worktree ||
+            !targetKey ||
+            seen.has(targetKey)) {
+            continue;
+        }
+        seen.add(targetKey);
+        targets.push(result.worktree);
+    }
+    return targets;
+}
 /**
  * Shared dual-source sync orchestration for single-repo and parent-folder
  * modes. Codex AND Claude Code sessions are scanned and attributed once across
- * every discovered worktree; each worktree syncs with only its own attributed
- * transcripts (codex + claude main + sidecars), and the
- * ambiguous/unattributed/skipped remainder is reported with reason labels and a
- * `source` discriminator instead of being duplicated into every repo or
+ * every discovered worktree; each worktree syncs its exact and deterministic
+ * fallback-attributed transcripts (Codex + Claude main + sidecars). The
+ * ambiguous/unattributed/skipped remainder is reported with reason labels and
+ * a `source` discriminator instead of being duplicated into every repo or
  * silently dropped. The session row's upload state maps ONLY from the main-file
  * outcome (D3); sidecar outcomes aggregate into CLI counts.
  */
@@ -32,36 +120,103 @@ export async function runAttributedWorktreeSync(options) {
     const paths = getCollectorRuntimePaths(options.homeDir);
     const config = await readLocalCollectorConfig(paths).catch(() => null);
     const claudeEnabled = config?.collect_claude_jsonl !== false;
-    const collectionRoots = fallbackCollectionRoots(config?.default_repo_paths ?? [], options.worktrees);
-    const codexAttribution = await scanAndAttributeCodexSessions({
+    const collectionRoots = normalizeCollectionRoots(options.collectionRoots ?? config?.default_repo_paths ?? []);
+    const [codexCursorBefore, claudeCursorBefore, uploadSpool] = await Promise.all([
+        readRawEvidenceCursor(paths).catch(() => emptyRawEvidenceCursorState()),
+        claudeEnabled
+            ? readRawEvidenceCursor(paths, {
+                filename: CLAUDE_CURSOR_FILENAME,
+            }).catch(() => emptyRawEvidenceCursorState())
+            : Promise.resolve(emptyRawEvidenceCursorState()),
+        readLocalUploadSpoolState(paths).catch(() => null),
+    ]);
+    const legacyRetryPending = Boolean(uploadSpool?.pending_uploads.some((entry) => entry.raw_evidence_file_count > 0 && entry.retry_sources.length === 0));
+    const codexSourceRetryPending = Boolean(uploadSpool?.pending_source_retries.some((entry) => entry.source === "codex"));
+    const claudeSourceRetryPending = Boolean(uploadSpool?.pending_source_retries.some((entry) => entry.source === "claude_code"));
+    const codexRetryPending = legacyRetryPending ||
+        codexSourceRetryPending ||
+        Boolean(uploadSpool?.pending_uploads.some((entry) => entry.retry_sources.includes("codex"))) ||
+        cursorHasUndurableCollectableSession(codexCursorBefore);
+    const claudeRetryPending = claudeEnabled &&
+        (legacyRetryPending ||
+            claudeSourceRetryPending ||
+            Boolean(uploadSpool?.pending_uploads.some((entry) => entry.retry_sources.includes("claude_code"))) ||
+            cursorHasUndurableCollectableSession(claudeCursorBefore));
+    const allHistorySinceMinutes = allLocalHistorySinceMinutes(now);
+    let codexAttribution = await scanAndAttributeCodexSessions({
         sessionsDirs: defaultCodexSessionDirs(homeDir),
         worktrees: options.worktrees,
         now,
-        sinceMinutes: CODEX_ATTRIBUTION_SCAN_WINDOW_MINUTES,
+        sinceMinutes: codexRetryPending
+            ? allHistorySinceMinutes
+            : CODEX_ATTRIBUTION_SCAN_WINDOW_MINUTES,
         limit: CODEX_ATTRIBUTION_SCAN_WINDOW_SESSION_LIMIT,
         collectionRoots,
     });
+    if (codexAttribution.session_limit_applied) {
+        codexAttribution = await scanAndAttributeCodexSessions({
+            sessionsDirs: defaultCodexSessionDirs(homeDir),
+            worktrees: options.worktrees,
+            now,
+            sinceMinutes: codexRetryPending
+                ? allHistorySinceMinutes
+                : CODEX_ATTRIBUTION_SCAN_WINDOW_MINUTES,
+            limit: codexAttribution.discovered_file_count,
+            collectionRoots,
+        });
+    }
     // First run (D B.4 §8): without a Claude cursor yet, widen the window to 14
     // days so the first sync captures retroactive history instead of only 24h.
     const claudeCursorExists = await fileExists(path.join(paths.cursors_dir, CLAUDE_CURSOR_FILENAME));
     const firstRunBackfill = claudeEnabled && !claudeCursorExists;
-    const claudeAttribution = claudeEnabled
+    let claudeAttribution = claudeEnabled
         ? await scanAndAttributeClaudeSessions({
             projectsDir: path.join(homeDir, ".claude", "projects"),
             worktrees: options.worktrees,
             now,
             collectionRoots,
-            sinceMinutes: firstRunBackfill
-                ? CLAUDE_FIRST_RUN_BACKFILL_MINUTES
-                : undefined,
+            sinceMinutes: claudeRetryPending
+                ? allHistorySinceMinutes
+                : firstRunBackfill
+                    ? CLAUDE_FIRST_RUN_BACKFILL_MINUTES
+                    : undefined,
         })
         : emptyClaudeScan();
-    // Read the Claude cursor up front: damping decisions need prior upload state.
-    const claudeCursorBefore = claudeEnabled
-        ? await readRawEvidenceCursor(paths, {
-            filename: CLAUDE_CURSOR_FILENAME,
-        }).catch(() => emptyRawEvidenceCursorState())
-        : emptyRawEvidenceCursorState();
+    if (claudeAttribution.session_limit_applied) {
+        claudeAttribution = await scanAndAttributeClaudeSessions({
+            projectsDir: path.join(homeDir, ".claude", "projects"),
+            worktrees: options.worktrees,
+            now,
+            collectionRoots,
+            sinceMinutes: claudeRetryPending
+                ? allHistorySinceMinutes
+                : firstRunBackfill
+                    ? CLAUDE_FIRST_RUN_BACKFILL_MINUTES
+                    : undefined,
+            limit: claudeAttribution.discovered_session_count,
+        });
+    }
+    await reconcileSourceScanRetry({
+        paths,
+        source: "codex",
+        attemptedAt: now.toISOString(),
+        pendingBefore: codexSourceRetryPending,
+        reason: sourceScanRetryReason("codex", codexAttribution),
+    });
+    if (claudeEnabled) {
+        await reconcileSourceScanRetry({
+            paths,
+            source: "claude_code",
+            attemptedAt: now.toISOString(),
+            pendingBefore: claudeSourceRetryPending,
+            reason: sourceScanRetryReason("claude_code", claudeAttribution),
+        });
+    }
+    const syncWorktrees = liveSyncTargetWorktrees(options.worktrees, [
+        ...codexAttribution.results,
+        ...claudeAttribution.results,
+    ]);
+    const discoveredWorktreeKeys = new Set(options.worktrees.map(liveSyncTargetKey));
     // sessionId -> prior durable pointer for damped sessions (drives the
     // growth_damped count + the skip_main decision).
     const dampedClaudePointers = new Map();
@@ -83,22 +238,27 @@ export async function runAttributedWorktreeSync(options) {
     };
     const outcomes = [];
     let ok = true;
-    for (const worktree of options.worktrees) {
+    for (const worktree of syncWorktrees) {
+        const attributedSyntheticTarget = discoveredWorktreeKeys.has(liveSyncTargetKey(worktree))
+            ? null
+            : worktree;
+        const contextOptions = {
+            homeDir: options.homeDir,
+            repoRoot: worktree.repo_root,
+            activeTicketId: options.activeTicketId,
+            operatorId: options.operatorId,
+            sessionId: options.sessionId,
+            ...(attributedSyntheticTarget ? {} : { branch: options.branch }),
+        };
+        const ensureContext = () => attributedSyntheticTarget
+            ? startLocalWorkContextForAttributedTarget(contextOptions, attributedSyntheticTarget)
+            : startLocalWorkContext(contextOptions);
         let context = null;
-        if (options.startContexts) {
-            context = await startLocalWorkContext({
-                homeDir: options.homeDir,
-                repoRoot: worktree.repo_root,
-                branch: options.branch,
-                activeTicketId: options.activeTicketId,
-                operatorId: options.operatorId,
-                sessionId: options.sessionId,
-            });
+        if (options.startContexts || attributedSyntheticTarget) {
+            context = await ensureContext();
         }
         const claudeSessionFiles = claudeAttribution.results
-            .filter((result) => result.state === "attributed" &&
-            result.worktree?.worktree_fingerprint ===
-                worktree.worktree_fingerprint)
+            .filter((result) => matchesLiveSyncWorktree(result, worktree))
             .map((result) => {
             const damped = !result.main_file_oversized &&
                 shouldDampClaudeMain(result, claudeCursorBefore, now);
@@ -120,11 +280,9 @@ export async function runAttributedWorktreeSync(options) {
             homeDir: options.homeDir,
             repoRoot: worktree.repo_root,
             dashboardUrl: options.dashboardUrl,
-            worktreeInventory: worktreeInventoryForRepo(worktree, options.worktrees),
+            worktreeInventory: worktreeInventoryForRepo(worktree, syncWorktrees),
             codexSessionFiles: codexAttribution.results
-                .filter((result) => result.state === "attributed" &&
-                result.worktree?.worktree_fingerprint ===
-                    worktree.worktree_fingerprint)
+                .filter((result) => matchesLiveSyncWorktree(result, worktree))
                 .map((result) => ({
                 local_path: result.file_path,
                 codex_session_id: result.codex_session_id,
@@ -146,11 +304,7 @@ export async function runAttributedWorktreeSync(options) {
             // `cockpit start` by hand.
             if (error instanceof LocalUploadBlockedError &&
                 error.blocker === "missing_context") {
-                context = await startLocalWorkContext({
-                    homeDir: options.homeDir,
-                    repoRoot: worktree.repo_root,
-                    branch: options.branch,
-                });
+                context = await ensureContext();
                 sync = await syncLocalAmbientEnvelope(syncOptions);
             }
             else {
@@ -167,6 +321,33 @@ export async function runAttributedWorktreeSync(options) {
         now,
         claudePriorDurablePointers,
     });
+    // Persist the metadata-only report before advancing either source cursor.
+    // If the process exits after this point, the spool keeps an exact retry copy.
+    // If queueing itself fails, the cursors remain at their prior retryable
+    // positions instead of aging an unreported session out of the live window.
+    const firstUploaded = outcomes.find((outcome) => outcome.sync.status === "uploaded");
+    const hadPendingSessionReports = (uploadSpool?.pending_session_reports.length ?? 0) > 0;
+    let queuedCurrentSessionReport = false;
+    if (firstUploaded && sessions.length > 0) {
+        const queued = await queueCodexSessionReport({
+            homeDir: options.homeDir,
+            dashboardUrl: firstUploaded.sync.dashboard_url,
+            generatedAt: now.toISOString(),
+            workContextId: firstUploaded.sync.work_context_id,
+            repoLabel: firstUploaded.worktree.repo_label,
+            branch: firstUploaded.worktree.branch,
+            repoFingerprint: firstUploaded.worktree.repo_fingerprint,
+            repoOriginUrl: firstUploaded.worktree.repo_origin_url,
+            worktreeLabel: firstUploaded.worktree.worktree_label,
+            worktreeFingerprint: firstUploaded.worktree.worktree_fingerprint,
+            worktreeIsPrimary: firstUploaded.worktree.worktree_is_primary,
+            sessions,
+        });
+        queuedCurrentSessionReport = Boolean(queued);
+    }
+    const reportRequired = sessions.length > 0 ||
+        hadPendingSessionReports ||
+        queuedCurrentSessionReport;
     // The sessions cursor is an optimization; a broken local state dir must not
     // turn already-completed syncs into a CLI crash.
     let codexStaleCount = 0;
@@ -180,6 +361,9 @@ export async function runAttributedWorktreeSync(options) {
             source: "codex",
             sessionIdOf: (result) => result.codex_session_id,
             now,
+            priorCursor: codexCursorBefore,
+            terminalizeMissingUndurable: codexRetryPending &&
+                codexAttributionReadFailureCount(codexAttribution) === 0,
         });
         codexCursor.updated_at = now.toISOString();
         await writeRawEvidenceCursor(paths, codexCursor);
@@ -197,6 +381,8 @@ export async function runAttributedWorktreeSync(options) {
                 sessionIdOf: (result) => result.claude_session_id,
                 now,
                 priorCursor: claudeCursorBefore,
+                terminalizeMissingUndurable: claudeRetryPending &&
+                    claudeAttributionReadFailureCount(claudeAttribution) === 0,
             });
             claudeCursorBefore.updated_at = now.toISOString();
             await writeRawEvidenceCursor(paths, claudeCursorBefore, {
@@ -208,13 +394,9 @@ export async function runAttributedWorktreeSync(options) {
             // Best-effort: a broken Claude cursor must not fail the sync.
         }
     }
-    const firstUploaded = outcomes.find((outcome) => outcome.sync.status === "uploaded");
-    const report = firstUploaded
-        ? await postCodexSessionReport({
+    const report = hadPendingSessionReports || queuedCurrentSessionReport
+        ? await flushPendingCodexSessionReports({
             homeDir: options.homeDir,
-            repoRoot: firstUploaded.worktree.repo_root,
-            dashboardUrl: options.dashboardUrl,
-            sessions,
             fetch: options.fetchImpl,
             now,
         })
@@ -232,6 +414,19 @@ export async function runAttributedWorktreeSync(options) {
         growthDamped: dampedClaudePointers.size,
         report,
     });
+    ok =
+        ok &&
+            !codexAttribution.session_limit_applied &&
+            !claudeAttribution.session_limit_applied &&
+            outcomes.every(({ sync }) => sync.raw_evidence_failed_count === 0 &&
+                !sync.raw_evidence_retry_required &&
+                sync.raw_evidence_deferred_byte_budget === 0 &&
+                sync.raw_evidence_deferred_object_budget === 0) &&
+            codexAttributionReadFailureCount(codexAttribution) === 0 &&
+            claudeAttributionReadFailureCount(claudeAttribution) === 0 &&
+            sourceScanRetryReason("codex", codexAttribution) === null &&
+            sourceScanRetryReason("claude_code", claudeAttribution) === null &&
+            (!reportRequired || report.posted);
     return { ok, outcomes, codexAttribution, claudeAttribution, summary };
 }
 export const ATTRIBUTION_STATE_RANK = CODEX_SESSION_ATTRIBUTION_STATE_RANK;
@@ -374,6 +569,20 @@ function buildAgentSessionReport(options) {
  */
 function recordSourceObservations(options) {
     const seen = new Set(options.results.map((result) => options.sessionIdOf(result)));
+    if (options.terminalizeMissingUndurable) {
+        for (const [sessionId, entry] of Object.entries(options.cursor.sessions)) {
+            if (seen.has(sessionId) ||
+                !liveSyncCursorEntryRequiresRetry(entry)) {
+                continue;
+            }
+            options.cursor.sessions[sessionId] = {
+                ...entry,
+                state: "skipped",
+                reason: "retry_source_missing",
+                last_seen_at: options.now.toISOString(),
+            };
+        }
+    }
     const stale = countStaleSessions(options.cursor, seen);
     for (const result of options.results) {
         const sessionId = options.sessionIdOf(result);
@@ -436,7 +645,7 @@ function shouldDampClaudeMain(result, cursor, now) {
 }
 function buildAgentSessionSummary(options) {
     const sidecarOutcomes = options.outcomes.flatMap((outcome) => outcome.sync.raw_evidence_outcomes.filter((upload) => upload.kind === "claude_jsonl_sidecar"));
-    const attributedClaude = options.claudeAttribution.results.filter((result) => result.state === "attributed");
+    const attributedClaude = options.claudeAttribution.results.filter((result) => isLiveRawEvidenceSyncAttribution(result.state, result.reason));
     const sidecarsCollected = attributedClaude.reduce((total, result) => total +
         result.sidecar_files.filter((sidecar) => !sidecar.skipped_reason).length, 0);
     const sidecarsSkipped = options.claudeAttribution.results.reduce((total, result) => total +
@@ -449,6 +658,7 @@ function buildAgentSessionSummary(options) {
         unattributed: options.codexAttribution.counts.unattributed,
         skipped: options.codexAttribution.counts.skipped,
         stale: options.codexStaleCount,
+        read_failures: codexAttributionReadFailureCount(options.codexAttribution),
     };
     const claude = {
         scanned: options.claudeAttribution.scanned_session_count,
@@ -458,6 +668,7 @@ function buildAgentSessionSummary(options) {
         unattributed: options.claudeAttribution.counts.unattributed,
         skipped: options.claudeAttribution.counts.skipped,
         stale: options.claudeStaleCount,
+        read_failures: claudeAttributionReadFailureCount(options.claudeAttribution),
         sidecars_collected: sidecarsCollected,
         sidecars_uploaded: sidecarOutcomes.filter((upload) => upload.upload_state === "uploaded" ||
             upload.upload_state === "reused_existing").length,
@@ -534,12 +745,6 @@ function worktreeInventoryForRepo(current, worktrees) {
         branch: worktree.branch,
     }));
 }
-function fallbackCollectionRoots(savedRoots, worktrees) {
-    return normalizeCollectionRoots([
-        ...savedRoots,
-        ...worktrees.map((worktree) => worktree.requested_path || worktree.repo_root),
-    ]);
-}
 async function fileExists(filePath) {
     const { stat } = await import("node:fs/promises");
     return stat(filePath).then(() => true, () => false);