@bli-cockpit/cli 0.2.291 → 0.2.293

package/dist/commands/setup-receipt-lines.js

@@ -9,7 +9,7 @@
  * refusal that does not say what to do next is half a message. Every gap here
  * gets ONE command or ONE click, never a paragraph and never "see the docs".
  */
-import { CODEX_HOOKS_TRUST_GUIDE_URL, setupPieceMark, setupReceiptLine, setupReceiptPieces, } from "@bli-cockpit/telemetry-core";
+import { codexHooksTrustAction, setupPieceMark, setupReceiptLine, setupReceiptPieces, } from "@bli-cockpit/telemetry-core";
 /** Cached host facts are old after the same seven-day window as their readers. */
 const OLD_READING_MS = 7 * 24 * 60 * 60 * 1000;
 /** The one fix for each piece, by key. Present for every key the block prints. */
@@ -40,12 +40,6 @@ const REASON_FIXES = {
 };
 /** Codex hooks a person switched OFF is a decision, not a fault. */
 const UNSUPPORTED_FIX = "Switched off in your own config; nothing to do.";
-/**
- * The one exception to "a gap gets a command": Codex hooks that are installed
- * and waiting to be trusted are finished by a PERSON, in the Codex UI, and no
- * command we could print would do it.
- */
-const NEEDS_TRUST_FIX = `Open Codex and press \`/hooks\` to trust them (once, ~15s). Step by step: ${CODEX_HOOKS_TRUST_GUIDE_URL}`;
 /**
  * The block a terminal prints: the one line, then one fix per gap, then
  * nothing. A fully connected machine gets one line and no advice — a receipt
@@ -81,7 +75,7 @@ export function setupReceiptText(reading, options = {}) {
 }
 function fixFor(key, piece) {
     if (piece.status === "needs_trust")
-        return NEEDS_TRUST_FIX;
+        return codexHooksTrustAction(piece.reason);
     if (piece.status === "unsupported")
         return UNSUPPORTED_FIX;
     if (piece.status === "unknown") {

package/dist/commands/sources-discovery.js

@@ -1,3 +1,5 @@
+import { openCodexSessionRevision } from "../adapters/codex-session-revision.js";
+import { nativeSessionRoots } from "../native-session-roots.js";
 /**
  * Every agent transcript on this machine, named the way the collector names
  * its upload (BLI-11122).
@@ -29,13 +31,7 @@ import { SESSION_FILE_UUID_PATTERN, sanitizeSessionId, sessionIdFromFileName, sh
 import { isSecretLikePath, safeKeySegment } from "../adapters/raw-evidence-keys.js";
 import { describeError } from "../health-detail.js";
 export function sourcesRoots(homeDir, pathApi = path) {
-    return {
-        codex: [
-            pathApi.join(homeDir, ".codex", "sessions"),
-            pathApi.join(homeDir, ".codex", "archived_sessions"),
-        ],
-        claudeProjects: pathApi.join(homeDir, ".claude", "projects"),
-    };
+    return nativeSessionRoots(homeDir, pathApi);
 }
 /** Which kind of transcript a path is, or null for anything the collector does not upload as one. */
 export function classifyTranscriptPath(filePath, roots, pathApi = path) {
@@ -46,7 +42,13 @@ export function classifyTranscriptPath(filePath, roots, pathApi = path) {
         if (rel && !rel.startsWith("..") && !pathApi.isAbsolute(rel))
             return { kind: "codex_rollout" };
     }
-    const rel = pathApi.relative(roots.claudeProjects, filePath);
+    const claudeRoot = (roots.claudeProjectDirs ?? [roots.claudeProjects]).find((root) => {
+        const relative = pathApi.relative(root, filePath);
+        return relative && !relative.startsWith("..") && !pathApi.isAbsolute(relative);
+    });
+    if (!claudeRoot)
+        return null;
+    const rel = pathApi.relative(claudeRoot, filePath);
     if (!rel || rel.startsWith("..") || pathApi.isAbsolute(rel))
         return null;
     const parts = rel.split(pathApi.sep);
@@ -128,15 +130,18 @@ function trimmed(value) {
 }
 /**
  * Walk every root, name every transcript. `olderThanMs` keeps only files whose
- * mtime is before it; the rest are counted, never read.
+ * revision mtime is before it. Native identities are read before that filter
+ * so an older segment cannot be misreported as the whole retained session.
  */
 export async function discoverLocalTranscripts(options) {
     const roots = sourcesRoots(options.homeDir);
-    const result = { files: [], newer_count: 0, directory_read_failed: 0, file_read_failed: 0 };
+    const result = { files: [], newer_count: 0, directory_read_failed: roots.discoveryFailed ? 1 : 0, file_read_failed: 0 };
     let firstFailure = null;
     const recordFailure = (error) => { firstFailure ??= describeError(error); };
     const found = await findTranscriptFiles(options, roots, result, recordFailure);
     await nameTranscriptFiles(found, result, recordFailure);
+    await groupCodexRevisions(result);
+    result.files = result.files.filter(f => options.olderThanMs === null || f.mtime_ms < options.olderThanMs);
     if (result.directory_read_failed > 0 || result.file_read_failed > 0) {
         console.error("[collector sources] some transcripts could not be read; they are left out of the answer", JSON.stringify({
             reason: "sources_discovery_incomplete",
@@ -153,12 +158,17 @@ function shapeOrder(shape) {
 }
 async function findTranscriptFiles(options, roots, result, recordFailure) {
     const found = [];
-    const stack = options.skipAll ? [] : [...(options.skipCodex ? [] : roots.codex), ...(options.skipClaude ? [] : [roots.claudeProjects])];
+    const stack = options.skipAll ? [] : [...(options.skipCodex ? [] : roots.codex), ...(options.skipClaude ? [] : (roots.claudeProjectDirs ?? [roots.claudeProjects]))];
     const seen = new Set();
+    const visitedDirectories = new Set();
     while (stack.length > 0) {
         const dir = stack.pop();
         let entries;
         try {
+            const directoryIdentity = await fs.realpath(dir);
+            if (visitedDirectories.has(directoryIdentity))
+                continue;
+            visitedDirectories.add(directoryIdentity);
             entries = await fs.readdir(dir, { withFileTypes: true });
         }
         catch (error) {
@@ -187,10 +197,8 @@ async function findTranscriptFiles(options, roots, result, recordFailure) {
             });
             if (!stat)
                 continue;
-            if (options.olderThanMs !== null && stat.mtimeMs >= options.olderThanMs) {
+            if (options.olderThanMs !== null && stat.mtimeMs >= options.olderThanMs)
                 result.newer_count += 1;
-                continue;
-            }
             found.push({ file: full, size: stat.size, mtimeMs: stat.mtimeMs, shape });
         }
     }
@@ -237,4 +245,45 @@ async function nameTranscriptFiles(found, result, recordFailure) {
             key: transcriptKeyFor(source, named.session_id, item.shape.kind === "claude_subagent" ? item.shape.sidecar_stem : null),
         });
     }
+}
+/** One source row/pointer names the complete native session revision, never an arbitrary segment. */
+async function groupCodexRevisions(result) {
+    const groups = new Map();
+    for (const file of result.files)
+        if (file.source === "codex") {
+            const group = groups.get(file.session_id) ?? [];
+            group.push(file);
+            groups.set(file.session_id, group);
+        }
+    const replacements = new Map();
+    for (const [id, files] of groups) {
+        if (files.length < 2)
+            continue;
+        const representative = [...files].sort((a, b) => a.file_path.localeCompare(b.file_path))[0];
+        const combined = { ...representative, segment_paths: files.map(f => f.file_path).sort(),
+            segment_stamps: files.map(f => ({ path: f.file_path, size: f.byte_size, mtime: f.mtime_ms })),
+            byte_size: files.reduce((n, f) => n + f.byte_size, 0), mtime_ms: Math.max(...files.map(f => f.mtime_ms)) };
+        try {
+            const source = await openCodexSessionRevision(combined.segment_paths);
+            try {
+                combined.byte_size = source.length;
+            }
+            finally {
+                await source.close();
+            }
+        }
+        catch {
+            result.file_read_failed++;
+        }
+        replacements.set(id, combined);
+    }
+    const emitted = new Set();
+    result.files = result.files.flatMap(file => {
+        if (file.source !== "codex" || !replacements.has(file.session_id))
+            return [file];
+        if (emitted.has(file.session_id))
+            return [];
+        emitted.add(file.session_id);
+        return [replacements.get(file.session_id)];
+    });
 }

package/dist/commands/sources-reconciliation.js

@@ -22,7 +22,7 @@ export async function fetchSourceInventory(options) {
                 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))));
+                (row.raw_evidence_pointer_id === null || (typeof row.raw_evidence_pointer_id === "string" && row.raw_evidence_pointer_id.trim().length > 0)));
             if (!valid)
                 throw new Error("invalid_response");
             const next = body.next_after;
@@ -67,14 +67,16 @@ export async function reconcileSource(input) {
         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))));
+        (file.kind === "claude_subagent" || ((object.ref_id && pointers.has(object.ref_id)) || pointers.has(object.object_key))));
     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");
+    for (const observed of file.segment_stamps ?? [{ path: file.file_path, size: file.byte_size, mtime: file.mtime_ms }]) {
+        const stat = await fs.stat(observed.path);
+        if (stat.size !== observed.size || stat.mtimeMs !== observed.mtime)
+            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

package/dist/commands/sources-verdict.js

@@ -32,6 +32,7 @@
  *
  * Read-only: this module reads the file and never writes, moves or deletes it.
  */
+import { codexRevisionFacts } from "./codex-revision-facts.js";
 import crypto from "node:crypto";
 import fs from "node:fs/promises";
 import path from "node:path";
@@ -162,6 +163,8 @@ upload = {}) {
     const mode = upload.mode ?? IMAGE_HANDLING_MODE;
     const describedKeys = upload.describedKeys ?? new Set();
     const slimAware = upload.slimAware ?? modeDropsImages(mode);
+    if (file.segment_paths)
+        return codexRevisionFacts(file.segment_paths, mode, describedKeys, slimAware);
     const redactForUpload = (text, original) => redactTranscriptForm(file, text, original);
     let split = null;
     let whole = null;

package/dist/cursors/raw-evidence-cursor.js

@@ -204,6 +204,7 @@ function parseSessionEntry(value) {
         return null;
     return {
         file_hash_sha256: optionalString(record["file_hash_sha256"]),
+        ...(typeof record["uploaded_source_revision"] === "string" ? { uploaded_source_revision: record["uploaded_source_revision"] } : {}),
         file_mtime_ms: optionalNumber(record["file_mtime_ms"]),
         byte_size: optionalNumber(record["byte_size"]),
         byte_offset: optionalNumber(record["byte_offset"]),

package/dist/image-description-session.js

@@ -16,7 +16,7 @@ import { sha256OfBase64Run } from "./image-byte-scan.js";
 import { addPdfsToFinds, mergeOccurrences, pdfsOfText } from "./pdf-transcript-step.js";
 import { openPinnedTranscript } from "./adapters/pinned-transcript.js";
 import { openStagedOutput, readStagedText } from "./adapters/staged-output.js";
-import { TranscriptNotStreamable } from "./adapters/transcript-text-stream.js";
+import { TranscriptNotStreamable, TranscriptTooLargeError } from "./adapters/transcript-text-stream.js";
 import { copyLinesStream } from "./slim/keep-line-copy.js";
 import { LineBytesSink, slimLineStream } from "./slim/slim-stream.js";
 import { logSlimmed, slimOrKeep, slimPassOrNull, slimTranscript } from "./slim/slim-transcript.js";
@@ -133,9 +133,11 @@ async function prepareFileInTwoPasses(run, input) {
     const startedAt = Date.now();
     // The file is opened once and its length pinned: the census offsets, the describe payload reads and the swap
     // pass all read these bytes, and a source that stopped being them is set aside (`verifyUnchanged`).
-    const source = await openPinnedTranscript(input.filePath, { maxFileBytes: input.maxFileBytes });
+    const source = input.openSource ? await input.openSource() : await openPinnedTranscript(input.filePath, { maxFileBytes: input.maxFileBytes });
     let writer;
     try {
+        if (input.maxFileBytes && source.length > input.maxFileBytes)
+            throw new TranscriptTooLargeError(input.maxFileBytes);
         // Pass one: discover. Nothing of the text is kept; only where each image is and what it is.
         const census = await censusOfLines(source.lines());
         // Describe attempts finish and the swap decisions are settled before a single line is swapped, as with the whole text.

package/dist/native-session-roots.js

@@ -0,0 +1,31 @@
+/** Shared native homes keep sync, backfill and reconciliation on the same inventory. */
+import path from "node:path";
+import { t3ImportedNativeHomes } from "./t3-native-homes.js";
+export function nativeSessionRoots(homeDir, pathApi = path, environment = process.env) {
+    let importedHomes = [];
+    let discoveryFailed = false;
+    try {
+        importedHomes = t3ImportedNativeHomes(homeDir);
+    }
+    catch {
+        discoveryFailed = true;
+    } // The reader logged its reason; existing native homes remain available.
+    const expandHome = (value) => value === "~"
+        ? homeDir
+        : /^~[/\\]/u.test(value) ? pathApi.join(homeDir, value.slice(2)) : value;
+    const homes = (source, defaultHome, configured) => {
+        const extra = configured?.trim();
+        // Relative environment values depend on the launching app's cwd. Never guess it.
+        return [...new Set([defaultHome, ...importedHomes.filter((entry) => entry.source === source).map((entry) => entry.home), ...(extra && pathApi.isAbsolute(expandHome(extra)) ? [expandHome(extra)] : [])]
+                .map((home) => pathApi.normalize(home)))];
+    };
+    const claudeProjectDirs = homes("claude_code", pathApi.join(homeDir, ".claude"), environment.CLAUDE_CONFIG_DIR)
+        .map((home) => pathApi.join(home, "projects"));
+    return {
+        discoveryFailed,
+        codex: homes("codex", pathApi.join(homeDir, ".codex"), environment.CODEX_HOME)
+            .flatMap((home) => [pathApi.join(home, "sessions"), pathApi.join(home, "archived_sessions")]),
+        claudeProjects: claudeProjectDirs[0],
+        claudeProjectDirs,
+    };
+}

package/dist/t3-native-homes.js

@@ -0,0 +1,64 @@
+/** Imported native references reveal homes without opening T3 settings or credentials. */
+import { existsSync } from "node:fs";
+import { createRequire } from "node:module";
+import path from "node:path";
+const MAX_IMPORTED_REFERENCES = 10_000;
+/** Read only the installed 0.1.7 import-path projection, including live WAL state. */
+export function t3ImportedNativeHomes(homeDir) {
+    const databasePath = path.join(homeDir, ".t3", "userdata", "statev2.sqlite");
+    if (!existsSync(databasePath))
+        return [];
+    let database;
+    try {
+        // Optional runtime door: the public CLI still supports Node 20. A T3 store on
+        // that runtime must name the missing reader rather than report complete coverage.
+        const { DatabaseSync } = createRequire(import.meta.url)("node:sqlite");
+        database = new DatabaseSync(databasePath, { readOnly: true });
+        // Read explicit session columns only. No messages, settings, auth tables,
+        // attached databases or application write pragmas. One statement is a WAL snapshot.
+        const references = database.prepare(`
+      SELECT DISTINCT json_extract(reference.value, '$.provider') AS provider,
+        json_extract(reference.value, '$.filePath') AS file_path
+      FROM provider_session_runtime AS session,
+        json_each(session.runtime_payload_json, '$.importedTranscripts') AS reference
+      LIMIT ${MAX_IMPORTED_REFERENCES + 1}
+    `).all();
+        if (references.length > MAX_IMPORTED_REFERENCES)
+            throw new Error("t3_import_inventory_capped");
+        const homes = new Map();
+        for (const reference of references) {
+            const home = nativeHomeFromImport(reference.provider, reference.file_path);
+            if (home)
+                homes.set(`${home.source}:${home.home}`, home);
+        }
+        console.error("[native-session-roots] T3 import homes discovered", JSON.stringify({
+            reason: "t3_import_homes_read", references: references.length, unique_homes: homes.size,
+        }));
+        return [...homes.values()];
+    }
+    catch (error) {
+        // Never turn an unreadable/capped inventory into a green empty scan.
+        const reason = error instanceof Error && error.message === "t3_import_inventory_capped"
+            ? "t3_import_inventory_capped" : "t3_import_inventory_unreadable";
+        console.error("[native-session-roots] T3 discovery failed", JSON.stringify({ reason,
+            error_code: error?.code ?? "unknown" }));
+        throw new Error(reason);
+    }
+    finally {
+        database?.close();
+    }
+}
+function nativeHomeFromImport(provider, filePath) {
+    if (typeof filePath !== "string" || !path.isAbsolute(filePath) || !filePath.endsWith(".jsonl"))
+        return null;
+    const parts = path.normalize(filePath).split(path.sep);
+    const source = provider === "codex" ? "codex" : provider === "claudeAgent" ? "claude_code" : null;
+    if (!source)
+        return null;
+    const marker = source === "codex"
+        ? Math.max(parts.lastIndexOf("sessions"), parts.lastIndexOf("archived_sessions"))
+        : parts.lastIndexOf("projects");
+    if (marker < 1)
+        return null;
+    return { source, home: parts.slice(0, marker).join(path.sep) || path.parse(filePath).root };
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bli-cockpit/cli",
-  "version": "0.2.291",
+  "version": "0.2.293",
   "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.89",
-    "@bli-cockpit/mcp": "0.1.176",
-    "@bli-cockpit/telemetry-core": "0.1.95",
+    "@bli-cockpit/memory-mcp": "0.1.91",
+    "@bli-cockpit/mcp": "0.1.178",
+    "@bli-cockpit/telemetry-core": "0.1.97",
     "unpdf": "1.8.1"
   },
   "repository": {