@bli-cockpit/cli 0.2.243 → 0.2.245

package/dist/commands/project.js

@@ -12,6 +12,22 @@ import { pageFieldsOf, pageFooter } from "./issue-list-page.js";
 import { readBody } from "./issue-contracts.js";
 const TAG = "[project cli]";
 const READ_DEADLINE_MS = 30_000;
+const PRIORITY_WORDS = ["none", "urgent", "high", "medium", "low"];
+const person = (p) => p.name && p.email ? `${p.name} <${p.email}>` : (p.email ?? p.name ?? p.user_id);
+/** "2026-06-01 (month)" for a period, the bare day for an exact date. */
+const dated = (day, resolution) => day ? `${day}${resolution ? ` (${resolution})` : ""}` : "none";
+/** The planning block `project show` prints (BLI-22360). */
+export function planningLines(body) {
+    const project = body.project;
+    if (!project)
+        return [];
+    return [
+        `status ${project.status ?? "none"}  priority ${PRIORITY_WORDS[project.priority ?? 0] ?? project.priority}  start ${dated(project.start_date, project.start_date_resolution)}  target ${dated(project.target_date, project.target_date_resolution)}`,
+        `lead ${body.lead ? person(body.lead) : "none"}`,
+        `members ${(body.members ?? []).length === 0 ? "none" : (body.members ?? []).map(person).join(", ")}`,
+        ...(body.milestones ?? []).map((m) => `milestone ${m.name}${m.archived_at ? " (archived)" : ""}  target ${m.target_date ?? "none"}  ${m.progress?.summary ?? ""}  ${m.id}`),
+    ];
+}
 export async function runProject(command, io) {
     const door = await openAgentDoor("project", command, io);
     if (command.action !== "list")
@@ -65,6 +81,10 @@ async function runProjectVerb(command, door) {
         writeLine(out, `id ${project?.id ?? ""}  updated ${project?.updated_at ?? ""}`);
         if (project?.description)
             writeLine(out, project.description);
+        for (const line of planningLines(body))
+            writeLine(out, line);
+        if (project?.content)
+            writeLine(out, `\n${project.content}\n`);
         for (const issue of body.issues ?? [])
             writeLine(out, `${issue.identifier ?? ""}  ${issue.state ?? ""}  ${issue.title ?? ""}`);
         const footer = pageFooter(body, "tickets");
@@ -92,6 +112,38 @@ async function runProjectVerb(command, door) {
         else if (command.description !== undefined) {
             payload["description"] = command.description;
         }
+        const planning = command.planning;
+        if (planning) {
+            if (planning.lead !== undefined)
+                payload["lead"] = planning.lead;
+            if (planning.members !== undefined)
+                payload["members"] = planning.members;
+            if (planning.addMembers !== undefined)
+                payload["add_members"] = planning.addMembers;
+            if (planning.removeMembers !== undefined)
+                payload["remove_members"] = planning.removeMembers;
+            if (planning.status !== undefined)
+                payload["status"] = planning.status;
+            if (planning.priority !== undefined)
+                payload["priority"] = planning.priority;
+            if (planning.startDate !== undefined)
+                payload["start_date"] = planning.startDate;
+            if (planning.targetDate !== undefined)
+                payload["target_date"] = planning.targetDate;
+            if (planning.startDateResolution !== undefined)
+                payload["start_date_resolution"] = planning.startDateResolution;
+            if (planning.targetDateResolution !== undefined)
+                payload["target_date_resolution"] = planning.targetDateResolution;
+            if (planning.contentFilePath) {
+                const read = await readBody({ filePath: planning.contentFilePath }, door.io);
+                if (!read.ok)
+                    return failAgentDoor(door, TAG, read.reason, read.detail);
+                payload["content"] = read.text;
+            }
+            else if (planning.content !== undefined) {
+                payload["content"] = planning.content;
+            }
+        }
     }
     const path = command.action === "create" ? base : command.action === "update" ? ref : `${ref}/${command.action}`;
     const answer = await askAgentDoor(door, {

package/dist/commands/public-root.js

@@ -21,7 +21,7 @@ export async function runCockpitCli(argv, io) {
   }
 
   if (command === "--version" || command === "-V" || command === "version") {
-    writeLine(io?.stdout ?? process.stdout, "0.2.243");
+    writeLine(io?.stdout ?? process.stdout, "0.2.245");
     return 0;
   }
 

package/dist/commands/session-sync-outside-roots.js

@@ -22,7 +22,7 @@
  *
  *   - A session already durable with unchanged content rides for free. It
  *     uploads nothing (the object cursor reuses it) and keeps its row stable.
- *   - A session that is new, changed or not yet uploaded is "owed". The newest
+ *   - A session that is new, changed or not yet uploaded is "owed". The longest-waiting
  *     ones ride this tick up to a per-tick session cap. The rest wait, and their
  *     row says `deferred_object_budget`, the existing "next tick has room"
  *     label, instead of the old "not uploadable" one.
@@ -34,9 +34,9 @@
  *
  * The cap, the byte allowance and the object allowance are per tick, so a
  * 1,800-session backlog drains across many ticks and never blows one tick's
- * time or the machine's memory. Newest first: the sessions a person is most
- * likely to be waiting on summarise first, and a backlog of old ones never
- * starves today's.
+ * time or the machine's memory. A persisted retry order rotates offered
+ * sessions behind waiting ones,
+ * including when their source keeps growing.
  *
  * A new sibling must also join `scripts/build-public-cli.mjs` `runtimeFiles`.
  */
@@ -45,12 +45,13 @@ import path from "node:path";
 import { RAW_EVIDENCE_UPLOAD_MAX_FILE_BYTES } from "@bli-cockpit/telemetry-core";
 import { isRedactionStubObjectKey } from "../cursors/raw-evidence-stub-entry.js";
 import { describeError } from "../health-detail.js";
-import { writeJsonFile } from "../local-state-files.js";
+import { getCollectorRuntimePaths } from "../local-state.js";
+import { isMissingFileError, writeJsonFileAtomic, writeJsonFile } from "../local-state-files.js";
 import { rootScopeForReason } from "./agent-session-root-scope.js";
 import { ensureOutsideRootsWorkspace, isOutsideRootsWorkspace, outsideRootsWorkspace, } from "./backfill-outside-roots.js";
 /** Most outside-root sessions that upload bytes in one tick. 4 ticks an hour, so up to 3,840 a day. */
 export const OUTSIDE_ROOT_SESSIONS_PER_TICK = 40;
-/** Redacted bytes an outside-root pass may stage in one tick, kept apart from the in-root allowance. */
+/** Normal outside-root byte allowance; a fresh allowance can admit one wire-bounded file. */
 export const OUTSIDE_ROOT_BYTES_PER_TICK = 256 * 1024 * 1024;
 /** Files (a Claude main plus its sidecars count one each) an outside-root pass may collect in one tick. */
 export const OUTSIDE_ROOT_OBJECTS_PER_TICK = 120;
@@ -165,7 +166,27 @@ export async function admitOutsideRootSessions(options) {
     if (sightings.length === 0) {
         return { ...scan, outsideRoots: null };
     }
-    const { admitted, holds, counts, budget } = selectOutsideRootSessions(sightings, plan);
+    const queuePath = path.join(getCollectorRuntimePaths(options.homeDir).cursors_dir, "outside-root-admission.json");
+    const turns = await readAdmissionTurns(queuePath);
+    const { admitted, holds, counts, budget } = selectOutsideRootSessions(sightings, plan, turns);
+    // Offered work rotates even on a later disk/delivery refusal. New arrivals
+    // join behind existing waiters; growth never resets a session's place.
+    const offered = new Set(admitted.map((sighting) => outsideRootKey(sighting.source, sighting.sessionId)));
+    const next = Object.values(turns).reduce((max, turn) => Math.max(max, turn), 0) + 1;
+    const pending = {};
+    for (const sighting of sightings) {
+        const key = outsideRootKey(sighting.source, sighting.sessionId);
+        if (isDurableAndUnchanged(sighting.result, (sighting.source === "codex" ? plan.codexCursorBefore : plan.claudeCursorBefore).sessions[sighting.sessionId]) ||
+            sighting.result.byte_size > RAW_EVIDENCE_UPLOAD_MAX_FILE_BYTES)
+            continue;
+        pending[key] = offered.has(key) ? next + 1 : turns[key] ?? next;
+    }
+    try {
+        await writeJsonFileAtomic(queuePath, pending);
+    }
+    catch (error) {
+        console.error("[session-sync] outside-root admission order not saved", JSON.stringify({ reason: "admission_order_write_failed", ...describeError(error) }));
+    }
     if (admitted.length === 0) {
         console.error("[session-sync] outside-root raw upload", JSON.stringify({ reason: "nothing_to_upload_outside_roots", ...counts, ...budget }));
         return { ...scan, outsideRoots: { workspace: null, holds, counts } };
@@ -203,7 +224,24 @@ export async function admitOutsideRootSessions(options) {
     console.error("[session-sync] outside-root raw upload", JSON.stringify({ reason: "outside_root_sessions_admitted", ...counts, ...budget }));
     return labelled;
 }
-function selectOutsideRootSessions(sightings, plan) {
+/** Session ids and queue turns only; no source paths or transcript content. */
+async function readAdmissionTurns(filePath) {
+    try {
+        const value = JSON.parse(await fs.readFile(filePath, "utf8"));
+        if (!value || typeof value !== "object" || Array.isArray(value) ||
+            Object.entries(value).some(([key, turn]) => !/^(codex|claude_code):/.test(key) || !Number.isSafeInteger(turn) || Number(turn) < 0)) {
+            throw new Error("invalid admission order");
+        }
+        return value;
+    }
+    catch (error) {
+        if (!isMissingFileError(error)) {
+            console.error("[session-sync] outside-root admission order unavailable", JSON.stringify({ reason: "admission_order_read_failed", ...describeError(error) }));
+        }
+        return {};
+    }
+}
+function selectOutsideRootSessions(sightings, plan, turns) {
     const cursorFor = (source) => source === "codex" ? plan.codexCursorBefore : plan.claudeCursorBefore;
     const free = [];
     const owed = [];
@@ -222,12 +260,28 @@ function selectOutsideRootSessions(sightings, plan) {
             owed.push(sighting);
         }
     }
-    // Newest first, with the session id as a tie-break so two ticks over the same
-    // files pick the same sessions.
-    owed.sort((left, right) => right.result.session_file_mtime_ms - left.result.session_file_mtime_ms ||
-        left.sessionId.localeCompare(right.sessionId));
-    const riding = owed.slice(0, OUTSIDE_ROOT_SESSIONS_PER_TICK);
-    const waiting = owed.slice(OUTSIDE_ROOT_SESSIONS_PER_TICK);
+    const newTurn = Object.values(turns).reduce((max, turn) => Math.max(max, turn), 0) + 1;
+    owed.sort((left, right) => (turns[outsideRootKey(left.source, left.sessionId)] ?? newTurn) -
+        (turns[outsideRootKey(right.source, right.sessionId)] ?? newTurn) ||
+        left.result.session_file_mtime_ms - right.result.session_file_mtime_ms ||
+        outsideRootKey(left.source, left.sessionId).localeCompare(outsideRootKey(right.source, right.sessionId)));
+    // A main larger than the normal allowance gets a turn without other owed sessions. Otherwise a
+    // smaller main (or the other provider's reader, which runs first) could fill
+    // staging before the existing empty-staging exception ever sees it.
+    const riding = [];
+    let bytes = 0;
+    for (const sighting of owed) {
+        if (riding.length >= OUTSIDE_ROOT_SESSIONS_PER_TICK)
+            break;
+        if (bytes + sighting.result.byte_size > OUTSIDE_ROOT_BYTES_PER_TICK) {
+            if (riding.length === 0)
+                riding.push(sighting);
+            break;
+        }
+        riding.push(sighting);
+        bytes += sighting.result.byte_size;
+    }
+    const waiting = owed.slice(riding.length);
     for (const sighting of waiting) {
         holds.set(outsideRootKey(sighting.source, sighting.sessionId), OUTSIDE_ROOT_WAITING_REASON);
     }
@@ -273,6 +327,10 @@ export function applyOutsideRootHolds(rows, holds) {
  * description session stay shared (they live on the same budget object).
  */
 export function giveOutsideRootsTheirOwnAllowance(budget) {
+    budget.singleFileByteAllowance = {
+        normalBytes: OUTSIDE_ROOT_BYTES_PER_TICK,
+        maxFileBytes: RAW_EVIDENCE_UPLOAD_MAX_FILE_BYTES,
+    };
     budget.remainingBytes = OUTSIDE_ROOT_BYTES_PER_TICK;
     budget.remainingObjects = OUTSIDE_ROOT_OBJECTS_PER_TICK;
 }

package/dist/commands/sources-check.js

@@ -1,3 +1,25 @@
+/**
+ * `cockpit sources check [--older-than <days>] [--json]` — does Tower hold
+ * each agent transcript on this machine? (BLI-11122)
+ *
+ * On 2026-09-30 an agent freeing disk ran `find ~/.codex/... -mtime +60
+ * -delete` on the premise that the files were already in Tower; 349 of 1,491
+ * had no copy. This door is the machine answer that was missing: for every
+ * local Codex and Claude transcript it asks Tower which current objects it
+ * holds and answers `stored_full`, `stored_slim` (BLI-17273: Tower holds only the
+ * slim form, keep the file), `stored_partial` or `not_stored`, with the reason
+ * (`sources-verdict.ts`), judged against THIS machine's image mode.
+ *
+ * READ-ONLY, and nothing else: Tower never deletes a person's raw transcripts.
+ * Deleting one is the person's own act, outside Tower. This command reads the
+ * files and the server's list; it never writes, moves or deletes a file under
+ * `~/.codex` or `~/.claude`. `docs/runbooks/freeing-disk-on-a-collector-machine.md`.
+ *
+ * A server that cannot be asked is a failure with its reason (exit 1), never
+ * "not stored". A list cut short (`capped`, `failed_partial`) still answers,
+ * marked incomplete: a missing page can only understate what Tower holds.
+ */
+import { fetchSourceInventory, reconcileSource } from "./sources-reconciliation.js";
 import { writeLine } from "./cli-io.js";
 import { readDescribedImageKeys } from "../image-description-state.js";
 import { resolveImageHandlingMode } from "../image-mode-state.js";
@@ -12,6 +34,10 @@ export async function runSourcesCheck(command, io, now = new Date()) {
     const startedAt = Date.now();
     const paths = getCollectorRuntimePaths(command.homeDir);
     const config = await readLocalCollectorConfig(paths).catch(() => null);
+    if (command.reconcile && !config) {
+        console.error("[collector sources] reconciliation not run", JSON.stringify({ reason: "local_config_unavailable_opt_out_unknown" }));
+        return fail(io, command, "local_config_unavailable_opt_out_unknown", "Local collection preferences could not be read; no transcript store was scanned.");
+    }
     const dashboardUrl = command.dashboardUrl ?? config?.dashboard_url ?? DEFAULT_DASHBOARD_URL;
     const session = await readLocalCollectorSessionFile(paths).catch(() => null);
     if (!session || session.session_state !== "valid" || typeof session.device_token !== "string" || !session.device_token) {
@@ -25,7 +51,9 @@ export async function runSourcesCheck(command, io, now = new Date()) {
     }
     const homeDir = command.homeDir ?? paths.home_dir;
     const olderThanMs = command.olderThanDays === null ? null : now.getTime() - command.olderThanDays * DAY_MS;
-    const local = await discoverLocalTranscripts({ homeDir, olderThanMs });
+    const optOutAll = command.reconcile === true && config?.raw_evidence_upload === "disabled";
+    const optOutClaude = command.reconcile === true && config?.collect_claude_jsonl === false;
+    const local = await discoverLocalTranscripts({ homeDir, olderThanMs, skipAll: optOutAll, skipClaude: optOutClaude });
     const cursors = {
         codex: await readRawEvidenceCursor(paths),
         claude_code: await readRawEvidenceCursor(paths, { filename: CLAUDE_CURSOR_FILENAME, sessionsOnly: true }),
@@ -38,6 +66,36 @@ export async function runSourcesCheck(command, io, now = new Date()) {
     console.error("[collector sources] judging against this machine's image mode", JSON.stringify({ reason: `image_mode_from_${imageMode.source}`, mode: imageMode.mode, slim_aware: imageMode.slimAware }));
     const report = emptyReport(command, remote, local.newer_count, local.file_read_failed + local.directory_read_failed);
     await judgeLocalTranscripts(local.files, remote, cursors, imageMode, describedKeys, report);
+    if (command.reconcile) {
+        const inventory = await fetchSourceInventory({ dashboardUrl, deviceToken: session.device_token, fetchImpl: io.fetch });
+        const { rows: _rows, ...inventoryCounts } = inventory;
+        const counts = { missing_row: 0, missing_pointer: 0, stale_revision: 0, unavailable_evidence: 0, explicit_opt_out: 0, unverifiable: 0, revision_verified: 0 };
+        const optOutSources = optOutAll ? ["codex", "claude_code"] : optOutClaude ? ["claude_code"] : [];
+        counts.explicit_opt_out = optOutSources.length;
+        for (const file of local.files) {
+            const finding = await reconcileSource({ file, inventory, remote,
+                cursor: file.kind === "claude_subagent" ? null : cursors[file.source].sessions[file.session_id] ?? null,
+                facts: fileFacts(file, undefined, { mode: imageMode.mode, describedKeys, slimAware: imageMode.slimAware }),
+            }).catch(() => ({ state: "unavailable_evidence", reason: "local_revision_unreadable" }));
+            counts[finding.state]++;
+            const entry = report.files.find(entry => entry.path === file.file_path);
+            if (entry)
+                entry.reconciliation = finding;
+        }
+        report.reconciliation = { counts, inventory: inventoryCounts,
+            scan: { started_at: new Date(startedAt).toISOString(), finished_at: new Date().toISOString(),
+                roots: ["codex/sessions", "codex/archived_sessions", "claude/projects"], older_than_days: command.olderThanDays, opt_out_sources: optOutSources },
+            limitations: ["Snapshot scan, not a live completeness guarantee; absent local sources cannot be discovered.", "Missing historical source identifiers remain unverifiable.", "Pointer metadata does not prove bucket bytes are readable; no storage bodies fetched.", "explicit_opt_out counts sources, not undiscovered files; opted-out stores are not scanned."],
+        };
+        if (inventory.status !== "exhausted" || report.local.unreadable > 0 || counts.unavailable_evidence > 0) {
+            report.status = "incomplete";
+            report.reason = "reconciliation_partial";
+        }
+    }
+    if (report.local.unreadable > 0) {
+        report.status = "incomplete";
+        report.reason = "local_scan_incomplete";
+    }
     reportSourcesCheck(report, remote, startedAt);
     if (command.json)
         writeLine(io.stdout, JSON.stringify(report, null, 2));
@@ -93,6 +151,7 @@ function reportSourcesCheck(report, remote, startedAt) {
         stored_partial: report.counts.stored_partial,
         not_stored: report.counts.not_stored,
         reasons: report.reasons,
+        ...(report.reconciliation ? { reconciliation: report.reconciliation.counts } : {}),
         elapsed_ms: Date.now() - startedAt,
     }));
 }
@@ -135,6 +194,8 @@ export function sourcesCheckLines(report) {
         `  stored in part  ${report.counts.stored_partial.files} file(s), ${mb(report.counts.stored_partial.bytes)} MB`,
         `  not stored       ${report.counts.not_stored.files} file(s), ${mb(report.counts.not_stored.bytes)} MB`,
     ];
+    if (report.reconciliation)
+        lines.push(`  reconciliation   ${Object.entries(report.reconciliation.counts).map(([state, count]) => `${state} ${count}`).join(", ")}`, `  row inventory    ${report.reconciliation.inventory.status}; ${report.reconciliation.inventory.unique} unique of ${report.reconciliation.inventory.returned} returned (${report.reconciliation.inventory.requested} requested)`, `  scan             ${report.reconciliation.scan.started_at} to ${report.reconciliation.scan.finished_at}; roots ${report.reconciliation.scan.roots.join(", ")}; opted out ${report.reconciliation.scan.opt_out_sources.join(", ") || "none"}`, ...report.reconciliation.limitations.map(reason => `  limitation       ${reason}`));
     const reasons = Object.entries(report.reasons).sort((a, b) => b[1] - a[1]);
     if (reasons.length > 0)
         lines.push(`  why              ${reasons.map(([reason, count]) => `${reason} ${count}`).join(", ")}`);
@@ -144,7 +205,7 @@ export function sourcesCheckLines(report) {
         lines.push(`  unreadable       ${report.local.unreadable} file(s) could not be read and are not answered`);
     lines.push(`  Tower's list     ${report.remote.status}: ${report.remote.unique} current transcript object(s) over ${report.remote.pages} page(s)`);
     if (report.status === "incomplete") {
-        lines.push(`  INCOMPLETE       Tower's list was cut short (${report.reason}); "not stored" and "stored in part" may be understated. Run it again.`);
+        lines.push(`  INCOMPLETE       The scan or evidence list is incomplete (${report.reason}); missing evidence is inconclusive. Run it again.`);
     }
     lines.push("Tower never deletes these files. `--json` lists every file with its path and verdict. Only a \"stored in full\" file is safe to delete by your own hand (never \"stored slim\"); see docs/runbooks/freeing-disk-on-a-collector-machine.md.");
     return lines;

package/dist/commands/sources-discovery.js

@@ -153,7 +153,7 @@ function shapeOrder(shape) {
 }
 async function findTranscriptFiles(options, roots, result, recordFailure) {
     const found = [];
-    const stack = [...roots.codex, roots.claudeProjects];
+    const stack = options.skipAll ? [] : [...roots.codex, ...(options.skipClaude ? [] : [roots.claudeProjects])];
     const seen = new Set();
     while (stack.length > 0) {
         const dir = stack.pop();

package/dist/commands/sources-reconciliation.js

@@ -0,0 +1,87 @@
+/** Metadata reconciliation only. Never writes cursors, starts collection or fetches bodies. */
+import fs from "node:fs/promises";
+const uuid = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/iu;
+export async function fetchSourceInventory(options) {
+    const rows = new Map();
+    const result = { status: "capped", reason: "page_limit", requested: 0, returned: 0, unique: 0, pages: 0, rows: [] };
+    let after = null;
+    try {
+        for (let page = 0; page < (options.maxPages ?? 400); page++) {
+            result.requested += 500;
+            const response = await options.fetchImpl(`${options.dashboardUrl}/api/ambient/evidence/transcripts?inventory=1`, {
+                method: "POST", headers: { "Content-Type": "application/json", Authorization: `Bearer ${options.deviceToken}` },
+                body: JSON.stringify({ schema_version: "evidence-transcripts.v1", after, limit: 500 }),
+                signal: AbortSignal.timeout(30_000),
+            });
+            if (!response.ok)
+                throw new Error(`http_${response.status}`);
+            const body = await response.json();
+            if (body.schema_version !== "source-reconciliation.v1" || !Array.isArray(body.rows) || body.rows.length > 500 ||
+                !(body.next_after === null || (typeof body.next_after === "string" && uuid.test(body.next_after))))
+                throw new Error("invalid_response");
+            const valid = body.rows.every((row) => row && typeof row.id === "string" && uuid.test(row.id) &&
+                typeof row.source === "string" && (row.codex_session_id === null || typeof row.codex_session_id === "string") &&
+                (row.raw_evidence_pointer_id === null || (typeof row.raw_evidence_pointer_id === "string" && uuid.test(row.raw_evidence_pointer_id))));
+            if (!valid)
+                throw new Error("invalid_response");
+            const next = body.next_after;
+            if (next && (next <= (after ?? "") || body.rows.length === 0 || next !== body.rows.at(-1).id))
+                throw new Error("cursor_not_advancing");
+            result.pages++;
+            result.returned += body.rows.length;
+            for (const row of body.rows)
+                rows.set(row.id, row);
+            if (!next) {
+                result.status = "exhausted";
+                result.reason = "ok";
+                break;
+            }
+            after = next;
+        }
+    }
+    catch (error) {
+        result.status = result.pages ? "failed_partial" : "unavailable";
+        result.reason = error instanceof Error && /^(http_\d+|invalid_response|cursor_not_advancing)$/.test(error.message) ? error.message : "request_failed";
+    }
+    result.rows = [...rows.values()];
+    result.unique = rows.size;
+    console.error("[collector sources] row inventory", JSON.stringify({ reason: result.reason, status: result.status, requested: result.requested, returned: result.returned, unique: result.unique, pages: result.pages }));
+    return result;
+}
+export async function reconcileSource(input) {
+    const answer = (state, reason) => ({ state, reason });
+    const { file, inventory, remote, cursor, facts } = input;
+    if (file.session_id_source === "path_hash")
+        return answer("unverifiable", "source_identifier_missing");
+    const rows = inventory.rows.filter(row => row.source === file.source && row.codex_session_id === file.session_id);
+    if (!rows.length && inventory.rows.some(row => (!row.source || row.source === file.source) && !row.codex_session_id?.trim())) {
+        return answer("unverifiable", "historical_source_identifier_missing");
+    }
+    if (!rows.length)
+        return inventory.status === "exhausted"
+            ? answer("missing_row", "source_row_absent") : answer("unavailable_evidence", `row_inventory_${inventory.status}`);
+    // Duplicate device rows are expected; any usable pointer can answer this file.
+    const pointers = new Set(rows.map(row => row.raw_evidence_pointer_id).filter(Boolean));
+    if (!pointers.size)
+        return inventory.status === "exhausted"
+            ? answer("missing_pointer", "source_rows_without_pointer") : answer("unavailable_evidence", `row_inventory_${inventory.status}`);
+    const objects = (remote.files.get(file.key) ?? []).filter(object => !object.stub &&
+        (file.kind === "claude_subagent" || (object.ref_id && pointers.has(object.ref_id))));
+    if (!objects.length)
+        return answer("unavailable_evidence", remote.status === "exhausted" ? "pointer_not_in_current_transcripts_or_stub" : `transcripts_${remote.status}`);
+    const split = facts.slimSplit ? await facts.slimSplit() : null;
+    const form = split?.slim ?? (facts.slimAware && facts.wholeForm ? await facts.wholeForm() : await facts.sanitized());
+    const stat = await fs.stat(file.file_path);
+    if (stat.size !== file.byte_size || stat.mtimeMs !== file.mtime_ms)
+        return answer("unavailable_evidence", "local_file_changed_during_check");
+    if (form && objects.some(object => object.content_hash_sha256 === form.sha256 || object.content_hash_sha256 === split?.full.sha256))
+        return answer("revision_verified", "current_redacted_hash_matches_pointer");
+    // Sync refreshes the observed file hash even when growth damping retains an older
+    // durable upload. uploaded_byte_size is the raw source size at that upload.
+    if (form && objects.every(object => object.content_hash_sha256 !== null) && cursor?.uploaded_object_key &&
+        objects.some(object => object.object_key === cursor.uploaded_object_key || object.ref_id === cursor.uploaded_object_key) &&
+        cursor.uploaded_byte_size !== null && cursor.uploaded_byte_size < file.byte_size) {
+        return answer("stale_revision", "local_tail_newer_than_cursor_upload");
+    }
+    return answer("unverifiable", form ? "revision_hash_mismatch_or_legacy_hash_missing" : "redacted_revision_unavailable");
+}

package/dist/evidence-transcripts-client.js

@@ -78,6 +78,7 @@ function addTranscriptObject(object, files, state) {
     const key = transcriptFileKey(identity);
     const list = files.get(key) ?? [];
     list.push({
+        ref_id: object.ref_id,
         object_key: object.object_key,
         byte_size: object.byte_size,
         content_hash_sha256: object.content_hash_sha256,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bli-cockpit/cli",
-  "version": "0.2.243",
+  "version": "0.2.245",
   "private": false,
   "type": "module",
   "bin": {
@@ -27,9 +27,9 @@
     "test": "node dist/cli.js --help && node ../../scripts/assert-public-cli-routing.mjs && node ../../scripts/assert-public-cli-verb-help.mjs && node ../../scripts/assert-public-cli-surface-doors.mjs && node ../../scripts/assert-public-cli-runtime-files.mjs && node ../../scripts/assert-public-cli-exit-contract.mjs && node ../../scripts/assert-public-cli-no-fleet-posts.mjs && node ../../scripts/assert-public-cli-doctor-json.mjs && node ../../scripts/assert-public-package-pack.mjs --workspace=@bli-cockpit/cli"
   },
   "dependencies": {
-    "@bli-cockpit/memory-mcp": "0.1.71",
-    "@bli-cockpit/mcp": "0.1.148",
-    "@bli-cockpit/telemetry-core": "0.1.78"
+    "@bli-cockpit/memory-mcp": "0.1.72",
+    "@bli-cockpit/mcp": "0.1.150",
+    "@bli-cockpit/telemetry-core": "0.1.79"
   },
   "repository": {
     "type": "git",