@bli-cockpit/cli 0.2.292 → 0.2.294

package/dist/opencode-inventory.js

@@ -0,0 +1,203 @@
+/** OpenCode's one inventory for sync, history and reconciliation, exported through shared secret guards. */
+import fs from "node:fs/promises";
+import path from "node:path";
+import crypto from "node:crypto";
+import { newSessionFactsAccumulator, observeSessionFactsFile, observeSessionFactsRecord, finalizeSessionFacts, nativeObject, openCodeProviderIdentity } from "@bli-cockpit/telemetry-core";
+import { openCodeDatabasePath, openOpenCodeStore, OpenCodeReadError } from "./adapters/opencode-store.js";
+import { openStagingAllowance, roomToStageUpTo, admitToStaging } from "./staging-gate.js";
+import { sanitizeTextEvidenceForUpload } from "./adapters/raw-evidence-sanitize.js";
+import { readJsonFile, writeJsonFileAtomic } from "./local-state-files.js";
+export const OPENCODE_CURSOR_FILENAME = "opencode-raw-evidence.json";
+/** Policy is decided from native directory metadata before exporting any conversation body. */
+export async function readOpenCodeInventory(options) {
+    const result = { discovered: 0, sessions: [], eligible: 0, withheld: 0, files: [], shelved: [], failures: [], absent: false };
+    let store = null;
+    try {
+        const databasePath = options.databasePath ?? process.env.OPENCODE_DB ?? openCodeDatabasePath(options.homeDir, process.env.XDG_DATA_HOME);
+        store = await openOpenCodeStore(databasePath);
+        if (!store) {
+            result.absent = true;
+            console.error("[opencode inventory] source path absent", JSON.stringify({ source: "opencode", reason: "opencode_source_path_absent" }));
+            return result;
+        }
+        const sessions = [];
+        let afterId = "";
+        while (true) {
+            const page = store.list(afterId);
+            if (!page.length)
+                break;
+            sessions.push(...page.filter(session => options.sinceMs === undefined || session.updated_at_ms >= options.sinceMs));
+            afterId = page.at(-1).id;
+        }
+        result.discovered = sessions.length;
+        result.sessions = sessions;
+        if (options.metadataOnly) {
+            for (const session of sessions) {
+                if (!options.include || options.include(session))
+                    result.eligible += 1;
+                else
+                    result.withheld += 1;
+            }
+            console.error("[opencode inventory] metadata-only scan complete", JSON.stringify({ discovered: result.discovered, eligible: result.eligible, withheld: result.withheld }));
+            return result;
+        }
+        const owners = { ...await readUsageOwners(options.stateDir, "opencode-usage-tentative.json"), ...await readUsageOwners(options.stateDir, "opencode-usage-owners.json") };
+        const allowance = await openStagingAllowance(options.stateDir, process.env);
+        for (const session of sessions.sort((a, b) => Number(options.deliveredSessionIds?.has(a.id) ?? false) - Number(options.deliveredSessionIds?.has(b.id) ?? false) || a.created_at_ms - b.created_at_ms || a.id.localeCompare(b.id))) {
+            if (options.include && !options.include(session)) {
+                result.withheld += 1;
+                if (options.countOnly?.(session)) {
+                    try {
+                        result.shelved.push(await exportNativeSession(store, session, options.stateDir, owners, false));
+                    }
+                    catch (error) {
+                        result.failures.push({ session_id: session.id, reason: readReason(error) });
+                    }
+                }
+                continue;
+            }
+            result.eligible += 1;
+            try {
+                result.files.push(await exportNativeSession(store, session, options.stateDir, owners, true, allowance, options.exportDirectory));
+            }
+            catch (error) {
+                result.failures.push({ session_id: session.id, reason: readReason(error) });
+            }
+        }
+        if (!options.readOnlyAccounting)
+            await writeJsonFileAtomic(path.join(options.stateDir, "opencode-usage-tentative.json"), owners);
+    }
+    catch (error) {
+        result.failures.push({ session_id: null, reason: readReason(error) });
+    }
+    finally {
+        store?.close();
+    }
+    console.error("[opencode inventory] scan finished", JSON.stringify({ source: "opencode", discovered: result.discovered, exported: result.files.length, withheld: result.withheld, failed: result.failures.length, reason: result.absent ? "opencode_source_path_absent" : result.failures.length ? "opencode_inventory_partial" : "opencode_inventory_complete" }));
+    return result;
+}
+async function exportNativeSession(store, session, stateDir, owners, retainContent = true, allowance, exportDirectory) {
+    const directory = exportDirectory ?? path.join(stateDir, "opencode-transcripts");
+    if (retainContent)
+        await fs.mkdir(directory, { recursive: true, mode: 0o700 });
+    const temporary = path.join(directory, `.export-${crypto.randomUUID()}`);
+    const output = retainContent ? await fs.open(temporary, "wx", 0o600) : null;
+    const hash = crypto.createHash("sha256");
+    const factsAccumulator = newSessionFactsAccumulator("opencode");
+    let lines = 0;
+    let bytes = 0;
+    let message = null;
+    let identities = [];
+    let redactedRecords = 0;
+    const redactionRules = new Map();
+    let secretMatches = 0;
+    const write = async (record) => {
+        const part = record.type === "opencode_part" ? nativeObject(record.part) : {};
+        if (part.type === "file" && typeof part.url === "string")
+            record = { ...record, attachment_source: {
+                    representation: part.url.startsWith("data:") ? "inline_data_url" : "reference_only",
+                    referenced_bytes_read: false,
+                    reason: part.url.startsWith("data:") ? "native_inline_payload_available" : "external_attachment_bytes_not_read",
+                } };
+        const masked = sanitizeTextEvidenceForUpload({ text: JSON.stringify(record) + "\n", redactedFields: ["opencode_native_record"] });
+        if (masked.status === "redacted" && masked.completenessLabel === "redaction_crashed_stubbed")
+            throw new OpenCodeReadError("opencode_redaction_failed");
+        if (masked.status === "redacted") {
+            redactedRecords += 1;
+            secretMatches += masked.redaction.secret_like_match_count;
+            for (const rule of masked.redaction.rule_counts) {
+                const prior = redactionRules.get(rule.rule_id) ?? { rule_id: rule.rule_id, match_count: 0, redacted_char_count: 0 };
+                prior.match_count += rule.match_count;
+                prior.redacted_char_count += rule.redacted_char_count;
+                redactionRules.set(rule.rule_id, prior);
+            }
+        }
+        hash.update(masked.bytes);
+        bytes += masked.bytes.length;
+        lines += 1;
+        try {
+            observeSessionFactsRecord(factsAccumulator, JSON.parse(masked.bytes.toString("utf8")));
+        }
+        catch { /* Masked crash marker remains evidence, not an invented native record. */ }
+        if (output) {
+            const deferred = roomToStageUpTo(allowance, bytes);
+            if (deferred)
+                throw new OpenCodeReadError(`opencode_staging_deferred_${deferred}`);
+            await output.write(masked.bytes);
+        }
+    };
+    const settleUsage = async () => {
+        if (!message || message.role !== "assistant")
+            return;
+        const nativeIdentity = openCodeProviderIdentity(message, identities);
+        const identity = nativeIdentity ? crypto.createHash("sha256").update(nativeIdentity).digest("hex") : null;
+        const nativeTokens = nativeObject(message.tokens);
+        const hasUsage = !message.error && Number.isFinite(nativeObject(message.time).completed) && ["input", "output", "reasoning"].every((key) => typeof nativeTokens[key] === "number" && Number.isFinite(nativeTokens[key]) && Number(nativeTokens[key]) >= 0) && typeof message.modelID === "string";
+        const owner = identity ? owners[identity] : null;
+        const status = !identity || !hasUsage ? "unknown" : owner && owner !== session.id ? "copied" : "known";
+        if (identity && hasUsage && !owner)
+            owners[identity] = session.id;
+        await write({ type: "opencode_usage", status, identity, owner_session_id: identity ? owners[identity] : null, model: message.modelID ?? null, provider: message.providerID ?? null, tokens: message.tokens ?? null });
+    };
+    try {
+        for (const record of store.records(session.id)) {
+            if (record.type === "opencode_message") {
+                await settleUsage();
+                message = nativeObject(record.info);
+                identities = [];
+            }
+            if (record.type === "opencode_part") {
+                const part = nativeObject(record.part);
+                if (part.metadata)
+                    identities.push({ metadata: Object.fromEntries(Object.entries(nativeObject(part.metadata)).map(([name, value]) => [name, { itemId: nativeObject(value).itemId }])) });
+            }
+            await write(record);
+        }
+        await settleUsage();
+        await write({ type: "opencode_capture", redacted_records: redactedRecords, accounting_scope: "persistent_native_provider_item_ownership_on_this_machine" });
+        await output?.close();
+        const revision = hash.digest("hex");
+        const localPath = retainContent ? path.join(directory, `${session.id}-${revision}.jsonl`) : "";
+        if (retainContent) {
+            if (allowance) {
+                const deferred = admitToStaging(allowance, bytes, { kind: "opencode_jsonl" });
+                if (deferred)
+                    throw new OpenCodeReadError(`opencode_staging_deferred_${deferred}`);
+            }
+            await fs.rename(temporary, localPath);
+        }
+        observeSessionFactsFile(factsAccumulator, { bytes, lines });
+        const facts = finalizeSessionFacts(factsAccumulator);
+        return { session, local_path: localPath, byte_size: bytes, revision, facts,
+            ...(secretMatches ? { redaction: { schema_version: "raw-evidence-redaction.v1", status: "sanitized", mode: "deterministic_text_replacement",
+                    applied_by: ["local_collector"], rule_counts: [...redactionRules.values()], secret_like_match_count: secretMatches,
+                    redacted_fields: ["opencode_native_record"], redacted_ranges: [], sanitized_content_hash_sha256: revision, sanitized_byte_size: bytes } } : {}) };
+    }
+    catch (error) {
+        await output?.close().catch(() => undefined);
+        if (retainContent)
+            await fs.unlink(temporary).catch(() => undefined);
+        throw error;
+    }
+}
+function readReason(error) { return error instanceof OpenCodeReadError ? error.reason : "opencode_export_failed"; }
+async function readUsageOwners(stateDir, filename) {
+    const saved = await readJsonFile(path.join(stateDir, filename)).catch((error) => {
+        if (error.code === "ENOENT")
+            return {};
+        throw new OpenCodeReadError("opencode_accounting_cursor_unreadable");
+    });
+    if (!saved || typeof saved !== "object" || Array.isArray(saved) || Object.entries(saved).some(([key, owner]) => !/^[a-f0-9]{64}$/.test(key) || typeof owner !== "string" || !/^ses_[A-Za-z0-9]+$/.test(owner)))
+        throw new OpenCodeReadError("opencode_accounting_cursor_invalid");
+    return saved;
+}
+/** A local usage owner becomes durable only after both evidence and metadata were acknowledged. */
+export async function acknowledgeOpenCodeUsage(stateDir, sessions) {
+    const committed = await readUsageOwners(stateDir, "opencode-usage-owners.json");
+    const tentative = await readUsageOwners(stateDir, "opencode-usage-tentative.json");
+    for (const [identity, owner] of Object.entries(tentative))
+        if (sessions.has(owner))
+            committed[identity] ??= owner;
+    await writeJsonFileAtomic(path.join(stateDir, "opencode-usage-owners.json"), committed);
+    console.error("[opencode accounting] acknowledged native identity owners", JSON.stringify({ reason: "durable_native_usage_acknowledged", identities: Object.keys(committed).length, sessions: sessions.size }));
+}

package/dist/opencode-policy.js

@@ -0,0 +1,29 @@
+/** Apply existing collection choices to native directory metadata before exporting OpenCode evidence. */
+import { getCollectorRuntimePaths, readLocalCollectorConfig } from "./local-state.js";
+import { readSourceSwitches } from "./source-opt-out.js";
+import { settleCollectionScope, sessionInsideRoots } from "./collection-scope.js";
+import { decideShelfMode, sessionShelf } from "./commands/session-sync-shelf.js";
+import { scoreSignalsAgainstWorktrees } from "./adapters/attribution-core.js";
+export async function openCodeCollectionPolicy(options) {
+    const paths = getCollectorRuntimePaths(options.homeDir);
+    const config = await readLocalCollectorConfig(paths).catch((error) => { if (error.code === "ENOENT")
+        return null; throw error; });
+    const switches = await readSourceSwitches(config, paths, "opencode_inventory", { fetch: options.fetchImpl, dashboardUrl: options.dashboardUrl });
+    const shelf = await decideShelfMode({ homeDir: options.homeDir, dashboardUrl: options.dashboardUrl ?? null, fetchImpl: options.fetchImpl ?? globalThis.fetch });
+    const scope = await settleCollectionScope(paths.state_dir, config?.collection_scope);
+    const roots = options.collectionRoots ?? config?.default_repo_paths ?? [];
+    const enabled = switches.opencode && !switches.held && shelf.mode !== "hold";
+    const reason = switches.held || shelf.mode === "hold" ? "owner_check_unavailable" : !switches.opencode ? "raw_evidence_upload_disabled" : "opencode_existing_collection_policy";
+    const drawer = (session) => {
+        const attribution = scoreSignalsAgainstWorktrees({ cwds: [session.directory], workspaceRoots: [], originUrls: [], branches: [], headShas: [] }, options.worktrees ?? [], { collectionRoots: roots });
+        return shelf.mode === "founder" && sessionShelf({ ...attribution, local_cwd: session.directory, session_facts: null }, shelf.rules).shelf === "drawer";
+    };
+    return { enabled, reason, drawer, include: (session) => {
+            if (!enabled)
+                return false;
+            const attribution = scoreSignalsAgainstWorktrees({ cwds: [session.directory], workspaceRoots: [], originUrls: [], branches: [], headShas: [] }, options.worktrees ?? [], { collectionRoots: roots });
+            if (scope.scope === "roots_only" && !sessionInsideRoots({ ...attribution, local_cwd: session.directory }, roots))
+                return false;
+            return !drawer(session);
+        } };
+}

package/dist/slim/slim-transcript.js

@@ -36,7 +36,7 @@ import { LineEdits, SeenBlocks, isJsonObject } from "./slim-support.js";
  * once, which is intended: the stored bytes are no longer what the new rules would produce.
  * `slim-rules-version.test.ts` fails when a rule changes without this moving.
  */
-export const SLIM_RULES_VERSION = "slim-rules.v2";
+export const SLIM_RULES_VERSION = "slim-rules.v3";
 /** The text an image marker starts with; a line carrying one is a modified line (an image became a marker). */
 const IMAGE_MARKER_START = "[image sha256:";
 export function createSlimmer(kind, rulesForTests) {
@@ -49,8 +49,9 @@ export function createSlimmer(kind, rulesForTests) {
     const applyRules = rulesForTests ?? ((record, edits) => {
         if (kind === "claude_code")
             slimClaudeRecord(record, claude, seen, edits);
-        else
+        else if (kind === "codex")
             slimCodexRecord(record, codex, seen, edits);
+        // OpenCode keeps every native field; only the shared acknowledged-image swap changes its payload.
     });
     return {
         slimLine(line) {

package/dist/source-opt-out.js

@@ -46,7 +46,7 @@ export function resolveSourceSwitches(config, standing) {
     const labels = configOptOutLabels(config);
     const verdict = labels.length > 0 ? optOutVerdict(standing) : null;
     if (verdict && !verdict.obeyed) {
-        return { codex: true, claude: true, codexReason: null, claudeReason: null, ignored: labels, verdict: verdict.reason, held: false };
+        return { opencode: true, codex: true, claude: true, codexReason: null, claudeReason: null, ignored: labels, verdict: verdict.reason, held: false };
     }
     const all = config?.raw_evidence_upload === "disabled";
     const codexReason = config?.collect_codex_jsonl === false
@@ -56,6 +56,7 @@ export function resolveSourceSwitches(config, standing) {
         ? CLAUDE_OPT_OUT_REASON
         : all ? ALL_SOURCES_OPT_OUT_REASON : null;
     return {
+        opencode: !all,
         codex: codexReason === null,
         claude: claudeReason === null,
         codexReason,

package/dist/spool/local-spool-parse.js

@@ -100,7 +100,7 @@ export function parseMetadataOnlySessionReportRows(value, fieldPath) {
     return sessions;
 }
 function parseRetrySource(value, fieldPath) {
-    if (value === "codex" || value === "claude_code")
+    if (value === "codex" || value === "claude_code" || value === "opencode")
         return value;
     return invalidUploadSpoolState(fieldPath, '"codex" or "claude_code"');
 }

package/dist/state-dir-audit.js

@@ -37,6 +37,8 @@ export const STUDIES_DIR_SUFFIX = "-studies";
  * collector name; none does today, and the test pins that.
  */
 export const STATE_DIR_RULES = [
+    { name: "opencode-transcripts", match: "exact", class: "state", bound: "redacted native reader derivatives; existing staging allowance and state ceiling govern every write; current derivatives removed after durable evidence and metadata acknowledgments" },
+    { name: "opencode-", match: "prefix", class: "state", bound: "native identity cursors and metadata-only coverage receipt; overwritten by collection" },
     { name: "raw-evidence", match: "exact", class: "staging", bound: "staged copies go the tick the server commits them; 256 MiB cap; the staging gate stops new copies at the cap, on a low disk or over the 512 MiB ceiling; uncommitted evidence is never deleted, only counted" },
     { name: "sync.log", match: "prefix", class: "logs", bound: "rotated every tick at 10 MiB, at most 2 archives (20 MB) per stream" },
     { name: "sync.err.log", match: "prefix", class: "logs", bound: "rotated every tick at 10 MiB, at most 2 archives (20 MB) per stream" },

package/dist/sync-health-class.js

@@ -68,6 +68,7 @@ export const SYNC_FAILURE_LABELS = [
     /** The session store itself could not be read during the scan. */
     "codex_scan_read_failed",
     "claude_scan_read_failed",
+    "opencode_scan_read_failed",
     /** Sessions were observed and their metadata report did not reach the door. */
     "session_report_unposted",
     /** The gate is real and this file forgot to say why — a bug, made visible. */
@@ -104,6 +105,7 @@ export const SYNC_FAILURE_LABEL_CLASSES = {
     claude_session_read_failed: "sync_failed",
     codex_scan_read_failed: "sync_failed",
     claude_scan_read_failed: "sync_failed",
+    opencode_scan_read_failed: "sync_failed",
     session_report_unposted: "sync_failed",
     sync_failed_reason_not_recorded: "sync_failed",
 };

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/dist/upload-envelope-build.js

@@ -164,6 +164,7 @@ async function collectEnvelopeSources(options, config, paths, repoRoot, uploadCo
         rawEvidenceIncludeClaudeJsonl: switches.claude ? options.rawEvidenceIncludeClaudeJsonl : false,
         rawEvidenceCodexSessionFiles: options.codexSessionFiles,
         rawEvidenceCodexAttributionScan: options.codexAttributionScan,
+        rawEvidenceNativeSessionFiles: options.nativeSessionFiles,
         rawEvidenceClaudeSessionFiles: options.claudeSessionFiles,
         rawEvidenceClaudeAttributionScan: options.claudeAttributionScan,
         rawEvidenceSkipContentHashes: reusableContentHashes(options, {

package/dist/upload-evidence-delivery-summary.js

@@ -9,9 +9,12 @@ import { DELIVERY_BACKOFF_HOLDING_REASON, summarizeStuckEvidence, terminalDelive
  */
 export function retrySourcesForFailedSync(options, facts) {
     const sources = new Set();
+    if (options.nativeSessionFiles?.length)
+        sources.add("opencode");
     if ((options.codexSessionFiles?.length ?? 0) > 0 ||
         (options.codexAttributionScan?.directory_read_failed_count ?? 0) > 0 ||
         (options.codexAttributionScan?.stat_failed_count ?? 0) > 0 ||
+        Boolean(options.codexAttributionScan?.projection_failure_reason) ||
         facts?.evidence_completeness.source_counts.some((count) => count.source.startsWith("codex_") &&
             count.scanned_count + count.included_count + count.reused_count > 0)) {
         sources.add("codex");
@@ -99,9 +102,16 @@ export function hasRetryableEvidenceGap(facts, outcomes) {
  * Retryable and failed are separate questions: a hold remains missing evidence
  * without making the scheduled tick itself a failed attempt.
  */
+const retryableT3ProjectionFailures = new Set([
+    "t3_projection_unreadable", "t3_projection_inventory_capped", "t3_projection_messages_capped",
+    "t3_projection_bytes_capped", "t3_projection_mapping_invalid",
+    "t3_native_identity_index_capped",
+]);
 function isRetryableEvidenceSkipReason(reason) {
     if (reason === DELIVERY_BACKOFF_HOLDING_REASON)
         return true;
+    if (retryableT3ProjectionFailures.has(reason))
+        return true;
     return /(?:read|stat|directory)_failed|session_limit_overflow/iu.test(reason);
 }
 /** Every distinct reason behind the gap, sorted, as one spool-ready label. */

package/dist/upload-session-reports-wire.js

@@ -81,7 +81,21 @@ export async function reportCodexSessionAttributions(options) {
         return emptyCodexSessionReportResult("no_sessions_observed");
     }
     const chunks = [];
-    const sessionChunks = chunkArray(options.sessions, CODEX_SESSION_REPORT_MAX_SESSIONS);
+    const sessionChunks = [];
+    let current = [];
+    let currentBytes = 0;
+    for (const session of options.sessions) {
+        const bytes = Buffer.byteLength(JSON.stringify(session));
+        if (current.length && (current.length >= CODEX_SESSION_REPORT_MAX_SESSIONS || currentBytes + bytes > 3 * 1024 * 1024)) {
+            sessionChunks.push(current);
+            current = [];
+            currentBytes = 0;
+        }
+        current.push(session);
+        currentBytes += bytes;
+    }
+    if (current.length)
+        sessionChunks.push(current);
     for (const [index, sessions] of sessionChunks.entries()) {
         const chunk = await postCodexSessionAttributionChunk({
             ...options,
@@ -253,13 +267,6 @@ export function emptyCodexSessionReportResult(reason) {
         chunks: [],
     };
 }
-function chunkArray(items, size) {
-    const chunks = [];
-    for (let offset = 0; offset < items.length; offset += size) {
-        chunks.push(items.slice(offset, offset + size));
-    }
-    return chunks;
-}
 /**
  * How many rows the server must acknowledge, counted per distinct session
  * rather than per row — the same session observed twice in one chunk is still

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bli-cockpit/cli",
-  "version": "0.2.292",
+  "version": "0.2.294",
   "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.90",
-    "@bli-cockpit/mcp": "0.1.177",
-    "@bli-cockpit/telemetry-core": "0.1.96",
+    "@bli-cockpit/memory-mcp": "0.1.92",
+    "@bli-cockpit/mcp": "0.1.179",
+    "@bli-cockpit/telemetry-core": "0.1.98",
     "unpdf": "1.8.1"
   },
   "repository": {