@bli-cockpit/cli 0.2.52 → 0.2.54

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,
+    }));
+}