@bli-cockpit/cli 0.1.9 → 0.1.12

package/dist/commands/public-root.js

@@ -22,7 +22,10 @@ function cockpitHelp() {
     "Usage:",
     localCommandHelp(),
     "",
+    "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 --repo \"$PWD\" --json`.",
+    "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`.",
   ].join("\n");
 }

package/dist/commands/session-sync.js

@@ -0,0 +1,504 @@
+// Session attribution + ambient sync engine for the local collector. Split out
+// of commands/local.ts so the command runners read as a table of contents; this
+// is the core dual-source (Codex + Claude) scan/attribute/upload/report pass.
+//
+// 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 { LocalUploadBlockedError, postCodexSessionReport, syncLocalAmbientEnvelope } from "../upload.js";
+import { 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";
+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;
+/**
+ * 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
+ * silently dropped. The session row's upload state maps ONLY from the main-file
+ * outcome (D3); sidecar outcomes aggregate into CLI counts.
+ */
+export async function runAttributedWorktreeSync(options) {
+    const now = new Date();
+    const homeDir = options.homeDir ?? os.homedir();
+    const paths = getCollectorRuntimePaths(options.homeDir);
+    const claudeEnabled = await isClaudeCollectionEnabled(paths);
+    const codexAttribution = await scanAndAttributeCodexSessions({
+        sessionsDir: path.join(homeDir, ".codex", "sessions"),
+        worktrees: options.worktrees,
+        now,
+    });
+    // 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
+        ? await scanAndAttributeClaudeSessions({
+            projectsDir: path.join(homeDir, ".claude", "projects"),
+            worktrees: options.worktrees,
+            now,
+            sinceMinutes: 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();
+    // sessionId -> prior durable pointer for damped sessions (drives the
+    // growth_damped count + the skip_main decision).
+    const dampedClaudePointers = new Map();
+    // sessionId -> prior durable pointer for EVERY already-durable Claude session
+    // (superset of damped). A session that was durable before but had no fresh
+    // upload this sync (damped, spooled, budget-deferred) reports reused_existing
+    // with this pointer instead of not_uploaded, so the store row never flips.
+    const claudePriorDurablePointers = new Map();
+    for (const [sessionId, entry] of Object.entries(claudeCursorBefore.sessions)) {
+        if (entry.uploaded_object_key) {
+            claudePriorDurablePointers.set(sessionId, entry.uploaded_object_key);
+        }
+    }
+    // One shared budget for the whole sync (D7b is per-sync): a parent-folder
+    // sync over many worktrees honors a single byte/object cap rather than N×.
+    const rawEvidenceBudget = {
+        remainingBytes: RAW_EVIDENCE_DEFAULT_BYTE_BUDGET,
+        remainingObjects: RAW_EVIDENCE_DEFAULT_OBJECT_BUDGET,
+    };
+    const outcomes = [];
+    let ok = true;
+    for (const worktree of options.worktrees) {
+        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,
+            });
+        }
+        const claudeSessionFiles = claudeAttribution.results
+            .filter((result) => result.state === "attributed" &&
+            result.worktree?.worktree_fingerprint ===
+                worktree.worktree_fingerprint)
+            .map((result) => {
+            const damped = !result.main_file_oversized &&
+                shouldDampClaudeMain(result, claudeCursorBefore, now);
+            if (damped) {
+                dampedClaudePointers.set(result.claude_session_id, 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 })),
+            };
+        });
+        const syncOptions = {
+            homeDir: options.homeDir,
+            repoRoot: worktree.repo_root,
+            dashboardUrl: options.dashboardUrl,
+            codexSessionFiles: codexAttribution.results
+                .filter((result) => result.state === "attributed" &&
+                result.worktree?.worktree_fingerprint ===
+                    worktree.worktree_fingerprint)
+                .map((result) => ({
+                local_path: result.file_path,
+                codex_session_id: result.codex_session_id,
+            })),
+            claudeSessionFiles,
+            rawEvidenceBudget,
+            fetch: options.fetchImpl,
+        };
+        let sync;
+        try {
+            sync = await syncLocalAmbientEnvelope(syncOptions);
+        }
+        catch (error) {
+            // A newly cloned repo has no work context yet. Capture is permissive
+            // and ticket binding comes later, so start general ambient capture for
+            // it instead of blocking every other repo's sync until someone runs
+            // `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,
+                });
+                sync = await syncLocalAmbientEnvelope(syncOptions);
+            }
+            else {
+                throw error;
+            }
+        }
+        ok = ok && sync.status === "uploaded";
+        outcomes.push({ worktree, context, sync });
+    }
+    const sessions = buildAgentSessionReport({
+        codexResults: codexAttribution.results,
+        claudeResults: claudeAttribution.results,
+        outcomes,
+        now,
+        claudePriorDurablePointers,
+    });
+    // The sessions cursor is an optimization; a broken local state dir must not
+    // turn already-completed syncs into a CLI crash.
+    let codexStaleCount = 0;
+    let claudeStaleCount = 0;
+    try {
+        const codexCursor = await readRawEvidenceCursor(paths);
+        codexStaleCount = recordSourceObservations({
+            cursor: codexCursor,
+            results: codexAttribution.results,
+            sessions,
+            source: "codex",
+            sessionIdOf: (result) => result.codex_session_id,
+            now,
+        });
+        codexCursor.updated_at = now.toISOString();
+        await writeRawEvidenceCursor(paths, codexCursor);
+    }
+    catch {
+        // Best-effort: stale counts read 0 and observations re-record next sync.
+    }
+    if (claudeEnabled) {
+        try {
+            claudeStaleCount = recordSourceObservations({
+                cursor: claudeCursorBefore,
+                results: claudeAttribution.results,
+                sessions,
+                source: "claude_code",
+                sessionIdOf: (result) => result.claude_session_id,
+                now,
+                priorCursor: claudeCursorBefore,
+            });
+            claudeCursorBefore.updated_at = now.toISOString();
+            await writeRawEvidenceCursor(paths, claudeCursorBefore, {
+                filename: CLAUDE_CURSOR_FILENAME,
+                sessionsOnly: true,
+            });
+        }
+        catch {
+            // 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({
+            homeDir: options.homeDir,
+            repoRoot: firstUploaded.worktree.repo_root,
+            dashboardUrl: options.dashboardUrl,
+            sessions,
+            fetch: options.fetchImpl,
+            now,
+        })
+        : {
+            posted: false,
+            reason: sessions.length === 0 ? "no_sessions_observed" : "no_successful_sync",
+        };
+    const summary = buildAgentSessionSummary({
+        codexAttribution,
+        claudeAttribution,
+        outcomes,
+        codexStaleCount,
+        claudeStaleCount,
+        firstRunBackfill,
+        growthDamped: dampedClaudePointers.size,
+        report,
+    });
+    return { ok, outcomes, codexAttribution, claudeAttribution, summary };
+}
+const ATTRIBUTION_STATE_RANK = {
+    attributed: 3,
+    ambiguous: 2,
+    unattributed: 1,
+    skipped: 0,
+};
+function normalizeCodexResult(result) {
+    return {
+        source: "codex",
+        session_id: result.codex_session_id,
+        state: result.state,
+        reason: result.reason,
+        signals: result.signals,
+        attribution_score: result.attribution_score,
+        path_score: result.path_score,
+        content_hash_sha256: result.content_hash_sha256,
+        byte_size: result.byte_size,
+        session_file_mtime: result.session_file_mtime,
+        session_file_mtime_ms: result.session_file_mtime_ms,
+        worktree: result.worktree,
+        cwd_basename: result.cwd_basename,
+        cwd_hash: result.cwd_hash,
+    };
+}
+function normalizeClaudeResult(result) {
+    return {
+        source: "claude_code",
+        session_id: result.claude_session_id,
+        state: result.state,
+        reason: result.reason,
+        signals: result.signals,
+        attribution_score: result.attribution_score,
+        path_score: result.path_score,
+        content_hash_sha256: result.content_hash_sha256,
+        byte_size: result.byte_size,
+        session_file_mtime: result.session_file_mtime,
+        session_file_mtime_ms: result.session_file_mtime_ms,
+        worktree: result.worktree,
+        cwd_basename: result.cwd_basename,
+        cwd_hash: result.cwd_hash,
+    };
+}
+/**
+ * Generalizes the per-session report across sources. Dedupe is per
+ * `(source, session_id)` so a Codex session and a Claude session that happen to
+ * share an id are never collapsed. Upload state maps ONLY from the main-file
+ * outcome (kind `codex_jsonl` / `claude_jsonl`); sidecar outcomes never set a
+ * session's upload state (D3). Damped Claude sessions report `reused_existing`
+ * carrying their prior durable pointer.
+ */
+function buildAgentSessionReport(options) {
+    const normalized = [
+        ...options.codexResults.map(normalizeCodexResult),
+        ...options.claudeResults.map(normalizeClaudeResult),
+    ];
+    const bestByKey = new Map();
+    for (const result of normalized) {
+        const key = `${result.source}:${result.session_id}`;
+        const existing = bestByKey.get(key);
+        if (!existing ||
+            (ATTRIBUTION_STATE_RANK[result.state] ?? 0) >
+                (ATTRIBUTION_STATE_RANK[existing.state] ?? 0) ||
+            ((ATTRIBUTION_STATE_RANK[result.state] ?? 0) ===
+                (ATTRIBUTION_STATE_RANK[existing.state] ?? 0) &&
+                result.session_file_mtime_ms > existing.session_file_mtime_ms)) {
+            bestByKey.set(key, result);
+        }
+    }
+    // Main-file outcomes only (D3): a sidecar making it must never mark a session
+    // uploaded when the main did not.
+    const uploadByKey = new Map();
+    for (const outcome of options.outcomes) {
+        if (outcome.sync.status !== "uploaded")
+            continue;
+        for (const upload of outcome.sync.raw_evidence_outcomes) {
+            if (!upload.codex_session_id || !upload.raw_evidence_pointer_id)
+                continue;
+            const source = upload.kind === "claude_jsonl"
+                ? "claude_code"
+                : upload.kind === "codex_jsonl"
+                    ? "codex"
+                    : null;
+            if (!source)
+                continue; // sidecars and other kinds do not set session state
+            uploadByKey.set(`${source}:${upload.codex_session_id}`, upload);
+        }
+    }
+    return [...bestByKey.values()].map((result) => {
+        const key = `${result.source}:${result.session_id}`;
+        const upload = uploadByKey.get(key);
+        // A previously-durable Claude session with no fresh main upload this sync
+        // (damped / spooled / budget-deferred) reports reused_existing + its prior
+        // pointer rather than not_uploaded, so the store row never flips.
+        const priorDurablePointer = result.source === "claude_code"
+            ? (options.claudePriorDurablePointers.get(result.session_id) ?? null)
+            : null;
+        return {
+            codex_session_id: result.session_id,
+            source: result.source,
+            observed_at: options.now.toISOString(),
+            attribution_state: result.state,
+            attribution_reason: result.reason,
+            attribution_score: result.attribution_score,
+            path_score: result.path_score,
+            signals: result.signals,
+            ...(result.content_hash_sha256
+                ? { session_file_hash_sha256: result.content_hash_sha256 }
+                : {}),
+            session_file_byte_size: result.byte_size,
+            session_file_mtime: result.session_file_mtime,
+            ...(result.worktree
+                ? {
+                    repo_fingerprint: result.worktree.repo_fingerprint,
+                    worktree_fingerprint: result.worktree.worktree_fingerprint,
+                    repo_label: result.worktree.repo_label,
+                    branch: result.worktree.branch,
+                }
+                : {}),
+            ...(result.cwd_basename ? { cwd_basename: result.cwd_basename } : {}),
+            ...(result.cwd_hash ? { cwd_hash: result.cwd_hash } : {}),
+            ...(upload
+                ? {
+                    raw_evidence_pointer_id: upload.raw_evidence_pointer_id,
+                    upload_state: upload.upload_state,
+                }
+                : priorDurablePointer
+                    ? {
+                        raw_evidence_pointer_id: priorDurablePointer,
+                        upload_state: "reused_existing",
+                    }
+                    : result.state === "attributed"
+                        ? { upload_state: "not_uploaded" }
+                        : {}),
+        };
+    });
+}
+/**
+ * Records per-source session observations into its cursor and returns the stale
+ * count. Damped/reused Claude sessions carry forward their prior upload
+ * timestamp + byte size so the 6h damping window keeps counting from the real
+ * last upload (otherwise a slowly-growing file would never re-upload — D21).
+ */
+function recordSourceObservations(options) {
+    const seen = new Set(options.results.map((result) => options.sessionIdOf(result)));
+    const stale = countStaleSessions(options.cursor, seen);
+    for (const result of options.results) {
+        const sessionId = options.sessionIdOf(result);
+        const reported = options.sessions.find((session) => session.source === options.source &&
+            session.codex_session_id === sessionId);
+        const uploadedThisSync = reported?.upload_state === "uploaded";
+        const durableThisSync = reported?.upload_state === "uploaded" ||
+            reported?.upload_state === "reused_existing";
+        const prior = options.priorCursor?.sessions[sessionId];
+        // D21 / no-flip-flop: a sync that is spooled (offline), budget-deferred, or
+        // upload-failed for a session that was ALREADY durable must NOT wipe the
+        // prior durable state — otherwise damping is forfeited forever and the
+        // store row oscillates uploaded -> not_uploaded hourly. Carry the prior
+        // durable pointer/timestamp/size forward unless we durably uploaded anew.
+        const uploadedObjectKey = durableThisSync
+            ? (reported?.raw_evidence_pointer_id ?? prior?.uploaded_object_key ?? null)
+            : (prior?.uploaded_object_key ?? null);
+        const uploadedAt = uploadedThisSync
+            ? options.now.toISOString()
+            : (prior?.uploaded_at ?? (durableThisSync ? options.now.toISOString() : null));
+        const uploadedByteSize = uploadedThisSync
+            ? result.byte_size
+            : (prior?.uploaded_byte_size ??
+                (durableThisSync ? result.byte_size : null));
+        const entry = {
+            file_hash_sha256: result.content_hash_sha256,
+            file_mtime_ms: result.session_file_mtime_ms,
+            byte_size: result.byte_size,
+            // Durable byte offset reflects how many bytes are durable remotely (the
+            // last uploaded size), not the current file size.
+            byte_offset: uploadedByteSize ?? 0,
+            state: result.state,
+            reason: result.reason,
+            worktree_fingerprint: result.worktree?.worktree_fingerprint ?? null,
+            uploaded_object_key: uploadedObjectKey,
+            uploaded_at: uploadedAt,
+            uploaded_byte_size: uploadedByteSize,
+            last_seen_at: options.now.toISOString(),
+        };
+        recordSessionObservation(options.cursor, sessionId, entry);
+    }
+    return stale;
+}
+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 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 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 +
+        result.sidecar_files.filter((sidecar) => sidecar.skipped_reason).length, 0);
+    const codex = {
+        scanned: options.codexAttribution.scanned_file_count,
+        attributed: options.codexAttribution.counts.attributed,
+        ambiguous: options.codexAttribution.counts.ambiguous,
+        unattributed: options.codexAttribution.counts.unattributed,
+        skipped: options.codexAttribution.counts.skipped,
+        stale: options.codexStaleCount,
+    };
+    const claude = {
+        scanned: options.claudeAttribution.scanned_session_count,
+        attributed: options.claudeAttribution.counts.attributed,
+        ambiguous: options.claudeAttribution.counts.ambiguous,
+        unattributed: options.claudeAttribution.counts.unattributed,
+        skipped: options.claudeAttribution.counts.skipped,
+        stale: options.claudeStaleCount,
+        sidecars_collected: sidecarsCollected,
+        sidecars_uploaded: sidecarOutcomes.filter((upload) => upload.upload_state === "uploaded" ||
+            upload.upload_state === "reused_existing").length,
+        sidecars_skipped: sidecarsSkipped,
+        sidecars_capped: options.claudeAttribution.counts.sidecars_capped,
+        sidecars_failed: sidecarOutcomes.filter((upload) => upload.upload_state === "upload_failed").length,
+        mains_oversized: options.claudeAttribution.counts.mains_oversized,
+        oversized_lines_skipped: options.claudeAttribution.counts.oversized_lines_skipped,
+        project_dirs_skipped: options.claudeAttribution.project_dirs_skipped,
+        sessions_schema_drift: options.claudeAttribution.counts.sessions_schema_drift,
+        growth_damped: options.growthDamped,
+        first_run_backfill: options.firstRunBackfill,
+    };
+    return {
+        scanned: codex.scanned,
+        attributed: codex.attributed,
+        ambiguous: codex.ambiguous,
+        unattributed: codex.unattributed,
+        skipped: codex.skipped,
+        stale: codex.stale,
+        report_posted: options.report.posted,
+        report_reason: options.report.reason,
+        codex,
+        claude,
+        files_deferred_byte_budget: options.outcomes.reduce((total, outcome) => total + outcome.sync.raw_evidence_deferred_byte_budget, 0),
+        files_deferred_object_budget: options.outcomes.reduce((total, outcome) => total + outcome.sync.raw_evidence_deferred_object_budget, 0),
+    };
+}
+function emptyClaudeScan() {
+    return {
+        results: [],
+        scanned_session_count: 0,
+        project_dirs_skipped: 0,
+        counts: {
+            attributed: 0,
+            ambiguous: 0,
+            unattributed: 0,
+            skipped: 0,
+            mains_oversized: 0,
+            oversized_lines_skipped: 0,
+            sessions_schema_drift: 0,
+            sidecars_capped: 0,
+        },
+    };
+}
+async function isClaudeCollectionEnabled(paths) {
+    const config = await readLocalCollectorConfig(paths).catch(() => null);
+    return config?.collect_claude_jsonl !== false;
+}
+async function fileExists(filePath) {
+    const { stat } = await import("node:fs/promises");
+    return stat(filePath).then(() => true, () => false);
+}

package/dist/evidence-upload-client.js

@@ -117,6 +117,7 @@ function duplicateOutcome(primary, duplicate) {
         pointer: duplicate.pointer,
         codex_session_id: duplicate.codex_session_id ?? null,
         kind: duplicate.kind ?? "unknown",
+        artifact_metadata: duplicate.artifact_metadata,
         upload_state: primary.upload_state === "uploaded"
             ? "reused_existing"
             : primary.upload_state,
@@ -132,6 +133,7 @@ async function uploadOneObject(options, entry, disposition, chunkSizeBytes) {
             object_key: objectKey,
             codex_session_id: entry.file.codex_session_id ?? null,
             kind: entry.file.kind ?? "unknown",
+            artifact_metadata: entry.file.artifact_metadata,
             upload_state: "reused_existing",
             reason: "already_committed",
             uploaded_chunk_count: 0,
@@ -185,6 +187,7 @@ async function uploadOneObject(options, entry, disposition, chunkSizeBytes) {
             object_key: objectKey,
             codex_session_id: entry.file.codex_session_id ?? null,
             kind: entry.file.kind ?? "unknown",
+            artifact_metadata: entry.file.artifact_metadata,
             upload_state: "reused_existing",
             reason: "already_committed",
             uploaded_chunk_count: uploadedChunks,
@@ -195,6 +198,7 @@ async function uploadOneObject(options, entry, disposition, chunkSizeBytes) {
         object_key: objectKey,
         codex_session_id: entry.file.codex_session_id ?? null,
         kind: entry.file.kind ?? "unknown",
+        artifact_metadata: entry.file.artifact_metadata,
         upload_state: "uploaded",
         reason: null,
         uploaded_chunk_count: uploadedChunks,
@@ -228,6 +232,7 @@ async function uploadWithLegacyFallback(options, loaded, outcomes) {
                 object_key: entry.file.pointer.object_key ?? "",
                 codex_session_id: entry.file.codex_session_id ?? null,
                 kind: entry.file.kind ?? "unknown",
+                artifact_metadata: entry.file.artifact_metadata,
                 upload_state: "uploaded",
                 reason: "legacy_single_shot_upload",
                 uploaded_chunk_count: 1,
@@ -241,6 +246,7 @@ async function uploadWithLegacyFallback(options, loaded, outcomes) {
                 object_key: entry.file.pointer.object_key ?? "",
                 codex_session_id: entry.file.codex_session_id ?? null,
                 kind: entry.file.kind ?? "unknown",
+                artifact_metadata: entry.file.artifact_metadata,
                 upload_state: "reused_existing",
                 reason: "legacy_already_exists",
                 uploaded_chunk_count: 0,
@@ -319,6 +325,7 @@ function failedOutcome(file, reason, uploadedChunks = 0) {
         object_key: file.pointer.object_key ?? "",
         codex_session_id: file.codex_session_id ?? null,
         kind: file.kind ?? "unknown",
+        artifact_metadata: file.artifact_metadata,
         upload_state: "upload_failed",
         reason,
         uploaded_chunk_count: uploadedChunks,

package/dist/local-state.js

@@ -5,7 +5,7 @@ import os from "node:os";
 import path from "node:path";
 import { resolveRepoWorktreeIdentity, } from "./repo-identity.js";
 import { summarizeLocalUploadSpool } from "./spool/local-spool.js";
-export const LOCAL_COLLECTOR_VERSION = "0.1.9";
+export const LOCAL_COLLECTOR_VERSION = "0.1.10";
 export const DEFAULT_DASHBOARD_URL = "https://bli-cockpit-dashboard.vercel.app";
 export function getCollectorRuntimePaths(homeDir = os.homedir()) {
     const paths = getUserLocalCockpitPaths(homeDir);