@bli-cockpit/cli 0.2.51 → 0.2.53

package/dist/commands/session-sync-scan.js

@@ -0,0 +1,209 @@
+/**
+ * Reading both session stores, and settling what the reading owes.
+ *
+ * Codex and Claude are scanned once per tick each, under a window this step
+ * chooses: the normal live window, the 14-day first-run backfill, or all local
+ * history when a retry is pending. It also holds the BLI-3551 split that a
+ * scan's RETRY reason and a scan's FAILURE reason are two different claims —
+ * `repo_not_on_disk` widens the next window and never fails a sync.
+ */
+import path from "node:path";
+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 { CLAUDE_CURSOR_FILENAME } from "../cursors/raw-evidence-cursor.js";
+import { clearSourceRetryFailure, recordSourceRetryFailure, } from "../spool/local-spool.js";
+import { claudeAttributionReadFailureCount, codexAttributionReadFailureCount, } from "./agent-session-report.js";
+const CLAUDE_FIRST_RUN_BACKFILL_MINUTES = 14 * 24 * 60;
+/**
+ * Scan and attribute both session sources, then settle each source's scan-retry
+ * bookkeeping against what the scan actually found.
+ *
+ * Codex first, Claude second, and Claude's first-run window is decided between
+ * them because it depends on whether the Claude cursor file exists yet.
+ */
+export async function scanAndAttributeBothSources(options) {
+    const { plan } = options;
+    const codexAttribution = await scanCodexSessionsForSync({
+        homeDir: options.homeDir,
+        worktrees: options.worktrees,
+        now: options.now,
+        collectionRoots: plan.collectionRoots,
+        retryPending: plan.codexRetryPending,
+        allHistorySinceMinutes: plan.allHistorySinceMinutes,
+    });
+    // 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(options.paths.cursors_dir, CLAUDE_CURSOR_FILENAME));
+    const firstRunBackfill = plan.claudeEnabled && !claudeCursorExists;
+    const claudeAttribution = await scanClaudeSessionsForSync({
+        claudeEnabled: plan.claudeEnabled,
+        homeDir: options.homeDir,
+        worktrees: options.worktrees,
+        now: options.now,
+        collectionRoots: plan.collectionRoots,
+        retryPending: plan.claudeRetryPending,
+        allHistorySinceMinutes: plan.allHistorySinceMinutes,
+        firstRunBackfill,
+    });
+    await reconcileSourceScanRetry({
+        paths: options.paths,
+        source: "codex",
+        attemptedAt: options.now.toISOString(),
+        pendingBefore: plan.codexSourceRetryPending,
+        reason: sourceScanRetryReason("codex", codexAttribution),
+    });
+    if (plan.claudeEnabled) {
+        await reconcileSourceScanRetry({
+            paths: options.paths,
+            source: "claude_code",
+            attemptedAt: options.now.toISOString(),
+            pendingBefore: plan.claudeSourceRetryPending,
+            reason: sourceScanRetryReason("claude_code", claudeAttribution),
+        });
+    }
+    return { codexAttribution, claudeAttribution, firstRunBackfill };
+}
+/**
+ * Scan and attribute Codex sessions for this sync, widening the window to all
+ * local history when a retry is pending. Codex has no first-run backfill
+ * concept (that is a Claude-only window, see `scanClaudeSessionsForSync`) and
+ * is always scanned, unlike Claude which can be disabled entirely.
+ */
+async function scanCodexSessionsForSync(options) {
+    const sinceMinutes = options.retryPending
+        ? options.allHistorySinceMinutes
+        : CODEX_ATTRIBUTION_SCAN_WINDOW_MINUTES;
+    let scan = await scanAndAttributeCodexSessions({
+        sessionsDirs: defaultCodexSessionDirs(options.homeDir),
+        worktrees: options.worktrees,
+        now: options.now,
+        sinceMinutes,
+        limit: CODEX_ATTRIBUTION_SCAN_WINDOW_SESSION_LIMIT,
+        collectionRoots: options.collectionRoots,
+    });
+    if (scan.session_limit_applied) {
+        // Re-run once, bounded by exactly what the first pass discovered, so a
+        // capped scan still returns every session it found instead of silently
+        // truncating at the window's default limit.
+        scan = await scanAndAttributeCodexSessions({
+            sessionsDirs: defaultCodexSessionDirs(options.homeDir),
+            worktrees: options.worktrees,
+            now: options.now,
+            sinceMinutes,
+            limit: scan.discovered_file_count,
+            collectionRoots: options.collectionRoots,
+        });
+    }
+    return scan;
+}
+/**
+ * Scan and attribute Claude sessions for this sync — the Claude counterpart to
+ * `scanCodexSessionsForSync`. Disabled collection returns an empty scan
+ * up front; a first sync (no cursor yet) widens the window to 14 days instead
+ * of the normal 24h so it captures retroactive history.
+ */
+async function scanClaudeSessionsForSync(options) {
+    if (!options.claudeEnabled)
+        return emptyClaudeScan();
+    const sinceMinutes = options.retryPending
+        ? options.allHistorySinceMinutes
+        : options.firstRunBackfill
+            ? CLAUDE_FIRST_RUN_BACKFILL_MINUTES
+            : undefined;
+    const projectsDir = path.join(options.homeDir, ".claude", "projects");
+    let scan = await scanAndAttributeClaudeSessions({
+        projectsDir,
+        worktrees: options.worktrees,
+        now: options.now,
+        collectionRoots: options.collectionRoots,
+        sinceMinutes,
+    });
+    if (scan.session_limit_applied) {
+        scan = await scanAndAttributeClaudeSessions({
+            projectsDir,
+            worktrees: options.worktrees,
+            now: options.now,
+            collectionRoots: options.collectionRoots,
+            sinceMinutes,
+            limit: scan.discovered_session_count,
+        });
+    }
+    return scan;
+}
+export function sourceScanRetryReason(source, scan) {
+    const reasons = new Set();
+    const failure = sourceScanFailureReason(source, scan);
+    if (failure)
+        reasons.add(failure);
+    // Kept HERE and nowhere else (BLI-3551): a repo that is not on disk is a
+    // reason to widen the next scan window, because the transcript fallback can
+    // still attribute it. It is not a reason to call this sync failed — see
+    // `sourceScanFailureReason`.
+    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;
+}
+/**
+ * The part of the scan outcome that is a genuine FAILURE: the session store
+ * itself could not be read, so sessions that exist were not seen.
+ *
+ * Split from {@link sourceScanRetryReason} in BLI-3551. The two used to be one
+ * function, so `repo_not_on_disk` — a label the attribution umbrella finding
+ * already established is not a defect (nothing was deleted; the transcript
+ * names a path git no longer tracks) — failed the sync on every tick for three
+ * operators. A retry hint and a failure are different claims.
+ */
+export function sourceScanFailureReason(source, scan) {
+    const readFailureCount = source === "codex"
+        ? codexAttributionReadFailureCount(scan)
+        : claudeAttributionReadFailureCount(scan);
+    return readFailureCount > 0 ? `${source}_session_store_read_failed` : 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);
+    }
+}
+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,
+            attributed_fallback: 0,
+            ambiguous: 0,
+            unattributed: 0,
+            skipped: 0,
+            mains_oversized: 0,
+            oversized_lines_skipped: 0,
+            sessions_schema_drift: 0,
+            sidecars_capped: 0,
+        },
+    };
+}
+async function fileExists(filePath) {
+    const { stat } = await import("node:fs/promises");
+    return stat(filePath).then(() => true, () => false);
+}

package/dist/commands/session-sync-types.js

@@ -0,0 +1,12 @@
+/**
+ * The shapes one attributed sync pass hands from step to step.
+ *
+ * They live together, away from any step, because each one is a contract
+ * BETWEEN two steps: the plan the scan reads, the scan the upload reads, the
+ * upload the recorder reads. A step that owned its own output type would make
+ * the reader open the producer to learn what the consumer receives.
+ *
+ * Every name here is re-exported from `./session-sync.js`, which is the address
+ * callers already know.
+ */
+export {};

package/dist/commands/session-sync-upload.js

@@ -0,0 +1,215 @@
+/**
+ * Sending this tick's attributed transcripts, one worktree at a time.
+ *
+ * The whole loop shares ONE raw-evidence budget (D7b), so a parent-folder sync
+ * over many worktrees honours a single byte/object cap rather than N times it,
+ * and the Claude growth damper lives here because it is the only step that can
+ * see both what the cursor already made durable and what is about to be sent.
+ */
+import { startLocalWorkContext, startLocalWorkContextForAttributedTarget, } from "../local-state.js";
+import { LocalUploadBlockedError, syncLocalAmbientEnvelope, } from "../upload.js";
+import { RAW_EVIDENCE_DEFAULT_BYTE_BUDGET, RAW_EVIDENCE_DEFAULT_OBJECT_BUDGET, } from "../adapters/raw-evidence.js";
+import { liveSyncTargetKey, liveSyncTargetWorktrees, matchesLiveSyncWorktree, } from "./session-sync-attribution.js";
+const CLAUDE_DAMP_GROWTH_BYTES = 256 * 1024;
+const CLAUDE_DAMP_MAX_AGE_MS = 6 * 60 * 60 * 1000;
+/**
+ * Sync every worktree this tick is responsible for, in order, under one shared
+ * raw-evidence budget.
+ *
+ * The budget is per-sync (D7b), not per-worktree: a parent-folder sync over
+ * many worktrees honors a single byte/object cap rather than N times it.
+ */
+export async function syncEveryTargetWorktree(options) {
+    const { run, scan } = options;
+    const syncWorktrees = liveSyncTargetWorktrees(run.worktrees, [
+        ...scan.codexAttribution.results,
+        ...scan.claudeAttribution.results,
+    ]);
+    const discoveredWorktreeKeys = new Set(run.worktrees.map(liveSyncTargetKey));
+    // sessionId -> prior durable pointer for damped sessions (drives the
+    // growth_damped count + the skip_main decision).
+    const dampedClaudePointers = new Map();
+    const rawEvidenceBudget = {
+        remainingBytes: RAW_EVIDENCE_DEFAULT_BYTE_BUDGET,
+        remainingObjects: RAW_EVIDENCE_DEFAULT_OBJECT_BUDGET,
+    };
+    const outcomes = [];
+    let everyWorktreeUploaded = true;
+    for (const worktree of syncWorktrees) {
+        const outcome = await syncOneWorktree({
+            run,
+            now: options.now,
+            plan: options.plan,
+            scan,
+            worktree,
+            syncWorktrees,
+            rawEvidenceBudget,
+            // A target git discovery never produced is one the fallback attribution
+            // synthesized, and it syncs through its own attributed work context.
+            isDiscoveredWorktree: discoveredWorktreeKeys.has(liveSyncTargetKey(worktree)),
+            recordDampedClaudeSession: (sessionId, priorPointer) => {
+                dampedClaudePointers.set(sessionId, priorPointer);
+            },
+        });
+        everyWorktreeUploaded =
+            everyWorktreeUploaded && outcome.sync.status === "uploaded";
+        outcomes.push(outcome);
+    }
+    return {
+        outcomes,
+        everyWorktreeUploaded,
+        claudePriorDurablePointers: claudeDurablePointersFromCursor(options.plan.claudeCursorBefore),
+        growthDampedSessionCount: dampedClaudePointers.size,
+    };
+}
+/** Every Claude session the cursor already holds a durable pointer for. */
+function claudeDurablePointersFromCursor(claudeCursorBefore) {
+    const pointersBySessionId = new Map();
+    for (const [sessionId, entry] of Object.entries(claudeCursorBefore.sessions)) {
+        if (entry.uploaded_object_key) {
+            pointersBySessionId.set(sessionId, entry.uploaded_object_key);
+        }
+    }
+    return pointersBySessionId;
+}
+/**
+ * Sync one worktree's attributed transcripts, starting a work context first
+ * when this target needs one.
+ *
+ * A newly cloned repo has no work context yet. Capture is permissive and ticket
+ * binding comes later, so a `missing_context` refusal starts general ambient
+ * capture for that repo and retries, instead of blocking every other repo's
+ * sync until someone runs `cockpit start` by hand.
+ */
+async function syncOneWorktree(options) {
+    const { run, worktree } = options;
+    const attributedSyntheticTarget = options.isDiscoveredWorktree
+        ? null
+        : worktree;
+    const contextOptions = {
+        homeDir: run.homeDir,
+        repoRoot: worktree.repo_root,
+        activeTicketId: run.activeTicketId,
+        operatorId: run.operatorId,
+        sessionId: run.sessionId,
+        ...(attributedSyntheticTarget ? {} : { branch: run.branch }),
+    };
+    const ensureContext = () => attributedSyntheticTarget
+        ? startLocalWorkContextForAttributedTarget(contextOptions, attributedSyntheticTarget)
+        : startLocalWorkContext(contextOptions);
+    let context = null;
+    if (run.startContexts || attributedSyntheticTarget) {
+        context = await ensureContext();
+    }
+    const syncOptions = ambientEnvelopeForWorktree(options);
+    let sync;
+    try {
+        sync = await syncLocalAmbientEnvelope(syncOptions);
+    }
+    catch (error) {
+        if (error instanceof LocalUploadBlockedError &&
+            error.blocker === "missing_context") {
+            context = await ensureContext();
+            sync = await syncLocalAmbientEnvelope(syncOptions);
+        }
+        else {
+            throw error;
+        }
+    }
+    return { worktree, context, sync };
+}
+/**
+ * Assemble what one worktree is about to upload: its sibling worktree
+ * inventory, its Codex mains, its Claude mains and sidecars, and its share of
+ * the sync-wide raw-evidence budget.
+ */
+function ambientEnvelopeForWorktree(options) {
+    const { run, worktree, scan } = options;
+    const claudeSessionFiles = claudeSessionFilesForWorktree({
+        worktree,
+        claudeResults: scan.claudeAttribution.results,
+        claudeCursorBefore: options.plan.claudeCursorBefore,
+        now: options.now,
+        recordDampedClaudeSession: options.recordDampedClaudeSession,
+    });
+    return {
+        homeDir: run.homeDir,
+        repoRoot: worktree.repo_root,
+        dashboardUrl: run.dashboardUrl,
+        worktreeInventory: worktreeInventoryForRepo(worktree, options.syncWorktrees),
+        codexSessionFiles: scan.codexAttribution.results
+            .filter((result) => matchesLiveSyncWorktree(result, worktree))
+            .map((result) => ({
+            local_path: result.file_path,
+            codex_session_id: result.codex_session_id,
+        })),
+        codexAttributionScan: scan.codexAttribution,
+        claudeSessionFiles,
+        claudeAttributionScan: scan.claudeAttribution,
+        rawEvidenceBudget: options.rawEvidenceBudget,
+        fetch: run.fetchImpl,
+    };
+}
+/**
+ * This worktree's Claude mains and sidecars, with the growth damper applied.
+ *
+ * A damped main is still reported — `skip_main` means "do not re-upload the
+ * body this tick", not "forget this session" — and its prior durable pointer is
+ * recorded so the session report can say `reused_existing` instead of flipping
+ * the row to not_uploaded.
+ */
+function claudeSessionFilesForWorktree(options) {
+    return options.claudeResults
+        .filter((result) => matchesLiveSyncWorktree(result, options.worktree))
+        .map((result) => {
+        const damped = !result.main_file_oversized &&
+            shouldDampClaudeMain(result, options.claudeCursorBefore, options.now);
+        if (damped) {
+            options.recordDampedClaudeSession(result.claude_session_id, options.claudeCursorBefore.sessions[result.claude_session_id]
+                ?.uploaded_object_key ?? null);
+        }
+        return {
+            local_path: result.file_path,
+            claude_session_id: result.claude_session_id,
+            main_file_oversized: result.main_file_oversized,
+            skip_main: damped,
+            sidecar_files: result.sidecar_files
+                .filter((sidecar) => !sidecar.skipped_reason)
+                .map((sidecar) => ({ local_path: sidecar.local_path })),
+        };
+    });
+}
+function shouldDampClaudeMain(result, cursor, now) {
+    const entry = cursor.sessions[result.claude_session_id];
+    if (!entry ||
+        !entry.uploaded_object_key ||
+        !entry.uploaded_at ||
+        entry.uploaded_byte_size == null) {
+        return false;
+    }
+    const grew = result.byte_size > entry.uploaded_byte_size;
+    if (!grew)
+        return false; // unchanged content reuses via the object cursor
+    const growth = result.byte_size - entry.uploaded_byte_size;
+    const ageMs = now.getTime() - Date.parse(entry.uploaded_at);
+    return (growth <= CLAUDE_DAMP_GROWTH_BYTES &&
+        Number.isFinite(ageMs) &&
+        ageMs <= CLAUDE_DAMP_MAX_AGE_MS);
+}
+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,
+    }));
+}