@awak-app/simy-cli 0.6.9 → 0.6.11

package/src/session-supervision/index.js

@@ -1,7 +1,7 @@
 import { realpath } from 'node:fs/promises';
 import { randomUUID } from 'node:crypto';
-import { TERMINAL as TERMINAL_RUNS, claudeHookChannel, controlDelivery, listRecords, readRecord, processIdentity, startDelivery, updateRecord } from '../codex-plugins/simy/hooks/delivery-loop.mjs';
-import { listCodexSessions, openCodexAppServer, readCodexSession, CodexAppServerError } from './codex-app-server.js';
+import { TERMINAL as TERMINAL_RUNS, canUpgradeDelivery, claudeHookChannel, controlDelivery, listRecords, readRecord, processIdentity, startDelivery, updateRecord } from '../codex-plugins/simy/hooks/delivery-loop.mjs';
+import { listCodexSessions, openCodexAppServer, readCodexSession, readCodexArchiveStates, CodexAppServerError } from './codex-app-server.js';
 import { listClaudeSessions, readClaudeSession } from './claude-sessions.js';
 import { originalSessionTarget } from './original-session-target.js';
 import { readCodexTitles, sessionTitle } from './session-titles.js';
@@ -55,25 +55,56 @@ async function requireClaudeChannel(record, metadata, inspectProcess) {
 }
 
 export async function discoverSessions({ root, openClient = openCodexAppServer, listClaude = listClaudeSessions,
-  inspectProcess = processIdentity, now = Date.now(), signal, listCodexTitles = readCodexTitles } = {}) {
+  inspectProcess = processIdentity, now = Date.now(), signal, listCodexTitles = readCodexTitles, codexHome } = {}) {
   const assertActive = () => { if (signal?.aborted) throw new CodexAppServerError('cancelled', 'Conversation discovery was cancelled.'); };
   assertActive();
   const records = await listRecords(root);
   const priorities = records.filter(retainedSession);
   let discovered = [], codexError = null, claude = [], claudeError = null;
-  try { discovered = await withClient(openClient, client => listCodexSessions({ client, inspectState: true,
-    maxSessions: RECENT_SESSION_LIMIT,
-    prioritySessions: priorities.filter(record => record.provider === 'codex').map(record => record.session) }), signal); }
+  let archiveStates = new Map();
+  try { discovered = await withClient(openClient, async client => {
+    const active = await listCodexSessions({ client, inspectState: true, maxSessions: RECENT_SESSION_LIMIT,
+      prioritySessions: priorities.filter(record => record.provider === 'codex').map(record => record.session) });
+    const ids = new Set(active.map(item => item.session));
+    archiveStates = await readCodexArchiveStates(client, records.filter(record => record.provider === 'codex' && !ids.has(record.session)), { codexHome });
+    return active;
+  }, signal); }
   catch (error) { codexError = error?.code === 'unavailable' ? 'Codex executable unavailable.' : error?.code === 'unsupported' ? 'This Codex version lacks a verified app-server writer lock; update before enrollment.' : 'Codex conversation discovery unavailable.'; }
   assertActive();
   try { claude = await listClaude({ signal, limit: RECENT_SESSION_LIMIT,
     prioritySessions: priorities.filter(record => record.provider === 'claude').map(record => record.session) }); }
   catch { claudeError = 'Claude conversation discovery unavailable.'; }
   assertActive();
+  const activeCodex = new Set(discovered.map(item => item.session));
+  for (let index = 0; index < records.length; index++) {
+    assertActive();
+    const record = records[index];
+    if (record.provider !== 'codex') continue;
+    const isArchived = archiveStates.get(record.session) === true;
+    if (isArchived && record.providerArchived === true) continue;
+    if (!isArchived && !(record.providerArchived === true && (activeCodex.has(record.session) || archiveStates.get(record.session) === false))) continue;
+    records[index] = await updateRecord(root, record.provider, record.session, current => {
+      if (!current) return current;
+      current.providerArchived = isArchived;
+      if (isArchived) {
+        current.tracked = false; current.monitor = false; current.autoContinue = false;
+        current.autoContinueEpoch = randomUUID();
+        if (current.run && !TERMINAL_RUNS.has(current.run.state)) {
+          current.run.state = 'paused'; current.run.reason = 'The original provider conversation was archived.';
+          current.run.updatedAt = now;
+        }
+      }
+      return current;
+    });
+  }
+  assertActive();
   const byKey = new Map();
   const recordsByKey = new Map(records.map(record => [`${record.provider}:${record.session}`, record]));
-  for (const item of [...discovered, ...claude]) byKey.set(`${item.provider}:${item.session}`, item);
+  for (const item of [...discovered, ...claude]) {
+    if (recordsByKey.get(`${item.provider}:${item.session}`)?.providerArchived !== true) byKey.set(`${item.provider}:${item.session}`, item);
+  }
   for (const record of records) {
+    if (record.providerArchived === true) continue;
     const key = `${record.provider}:${record.session}`;
     if (!byKey.has(key) && (record.observedAt || record.admission || retainedSession(record))) byKey.set(key, {
       provider: record.provider, session: record.session, cwd: record.cwd, title: '', source: record.admission?.source || 'hook',
@@ -99,14 +130,17 @@ export async function discoverSessions({ root, openClient = openCodexAppServer,
       ? { ready: false, code: 'session_metadata_unavailable', reason: claudeError }
       : await liveClaudeChannel(record, item, inspectProcess) : null;
     const liveHook = claudeChannel?.ready === true;
-    const continuationIssue = liveHook && run ? !run.managed
+    const upgradeable = canUpgradeDelivery(run);
+    const continuationIssue = liveHook && run ? !run.managed && !upgradeable
       ? { code: 'existing_loop', reason: 'This conversation already has a Delivery Loop. Use its existing controls.' }
       : TERMINAL_RUNS.has(run.state) ? { code: 'task_settled', reason: 'This supervised task has settled. Review its existing status before continuing.' } : null : null;
     let isRunning = item.isRunning;
-    if (record?.runtime?.process?.identity && record.cwd === item.cwd) {
+    const hookIsNewer = Number.isFinite(record?.runtime?.observedAt) && Number.isFinite(item.lastActivityAt) && record.runtime.observedAt > item.lastActivityAt;
+    if ((isRunning === undefined || isRunning === false && hookIsNewer) && record?.runtime?.process?.identity && record.cwd === item.cwd) {
       try {
-        // Running observations need the same live process, not just a stale
-        // hook timestamp. Terminal observations do not override active RPCs.
+        // A hook newer than the persisted provider activity may describe a
+        // new turn. Require its same live process; older hooks cannot override
+        // a more recent completed provider turn.
         if (record.runtime.isRunning && await inspectProcess(record.runtime.process.pid) === record.runtime.process.identity) isRunning = true;
         else if (isRunning === undefined && !record.runtime.isRunning) isRunning = false;
       } catch { /* Unverified process leaves runtime status unknown. */ }
@@ -114,6 +148,7 @@ export async function discoverSessions({ root, openClient = openCodexAppServer,
     return { provider: item.provider, session: item.session, cwd: item.cwd,
       title: sessionTitle(item.title) || (item.provider === 'codex' ? codexTitles.get(item.session) || '' : ''), source: item.source,
       ...(typeof isRunning === 'boolean' ? { isRunning } : {}),
+      ...(item.latestTurnId ? { latestTurnId: item.latestTurnId } : {}),
       ...(item.providerGoal !== undefined ? { providerGoal: item.providerGoal } : {}),
       ...(item.goalReadState ? { goalReadState: item.goalReadState } : {}),
       tracked: typeof record?.tracked === 'boolean' ? record.tracked : record?.monitor === true,
@@ -129,7 +164,7 @@ export async function discoverSessions({ root, openClient = openCodexAppServer,
       capabilities: { canMonitor: item.capabilities?.canMonitor ?? true,
         canAnalyze: !run && (item.provider === 'codex' ? item.observation.source === 'codex_app_server' && !codexError : item.observation.source === 'claude_local_index' && !claudeError),
         canEnroll: (supported || liveHook) && !run, canContinue: (supported || liveHook) && !run,
-        canAutoContinue: (supported || liveHook) && (!run || Boolean(run.managed) && !TERMINAL_RUNS.has(run.state)) },
+        canAutoContinue: (supported || liveHook) && (!run || upgradeable || Boolean(run.managed) && !TERMINAL_RUNS.has(run.state)) },
       reason: item.provider === 'claude' ? continuationIssue?.reason || claudeChannel.reason :
         codexError || (!supported ? 'Exact model or provider metadata is unavailable.' : null),
     };
@@ -150,9 +185,10 @@ export async function discoverSessions({ root, openClient = openCodexAppServer,
 export async function setSessionAutoContinue({ root, provider, session, enabled, continuationPolicy, ...options }) {
   if (!['codex', 'claude'].includes(provider) || typeof enabled !== 'boolean') throw new Error('Unsupported automatic continuation request.');
   if (enabled) await trackSession({ root, provider, session, tracked: true, ...options });
-  return updateRecord(root, provider, session, async previous => {
+  const updated = await updateRecord(root, provider, session, async previous => {
     if (!previous) throw new Error('Refresh this conversation before changing automatic continuation.');
-    if (enabled && previous.run && !previous.run.managed) throw new Error('Automatic continuation is unavailable for this conversation.');
+    if (enabled && previous.providerArchived === true) throw new Error('Restore the original provider conversation before enabling automatic continuation.');
+    if (enabled && previous.run && !previous.run.managed && !canUpgradeDelivery(previous.run)) throw new Error('Resolve the existing loop blocker before enabling automatic continuation.');
     if (enabled && TERMINAL_RUNS.has(previous.run?.state)) throw new Error('This conversation is settled. Resume an eligible existing task after refreshing its status.');
     if (enabled && provider === 'codex' && !previous.admission?.model) throw new Error('Automatic continuation is unavailable for this conversation.');
     if (enabled && provider === 'claude') await requireClaudeChannel(previous,
@@ -171,6 +207,14 @@ export async function setSessionAutoContinue({ root, provider, session, enabled,
     if (next.run?.managed) next.run.managed.autoContinueEpoch = epoch;
     return next;
   });
+  if (enabled && updated.run && !updated.run.managed) {
+    // Enrollment checks this exact opt-in epoch under its state lock, so an
+    // overlapping Off action prevents the promotion from dispatching work.
+    await continueSession({ ...options, root, provider, session,
+      ...updated.autoContinueSettings, autoContinueEpoch: updated.autoContinueEpoch });
+    return readRecord(root, provider, session);
+  }
+  return updated;
 }
 
 export async function readSessionAutoContinue({ root, provider, session }) {
@@ -194,6 +238,7 @@ export async function trackSession({ root, provider, session, tracked = true, op
   if (!metadata) throw new Error('Exact provider session metadata is unavailable.');
   const cwd = await realpath(metadata.cwd);
   await updateRecord(root, provider, session, previous => {
+    if (previous?.providerArchived === true) throw new Error('Restore the original provider conversation before enabling automatic continuation or tracking.');
     if (previous && previous.cwd !== cwd) throw new Error('Session workspace changed; refresh its metadata.');
     return { ...(previous || { schemaVersion: 1, provider, session, cwd, run: null }), tracked: true, monitor: true,
       admission: { ...(previous?.admission || {}), source: metadata.observation.source, provider, session, cwd, model: metadata.model, validatedAt: now } };
@@ -214,6 +259,7 @@ export async function monitorSession({ root, provider, session, monitor = true,
   if (!metadata) throw new Error('Exact provider session metadata is unavailable.');
   const cwd = await realpath(metadata.cwd);
   await updateRecord(root, provider, session, previous => {
+    if (previous?.providerArchived === true) throw new Error('Restore the original provider conversation before enabling supervision.');
     if (previous && previous.cwd !== cwd) throw new Error('Session workspace changed; refresh its metadata.');
     return { ...(previous || { schemaVersion: 1, provider, session, cwd, run: null }), monitor,
       admission: { source: metadata.observation.source, provider, session, cwd, model: metadata.model, validatedAt: now } };
@@ -222,7 +268,7 @@ export async function monitorSession({ root, provider, session, monitor = true,
 }
 
 export async function enrollSession({ root, provider, session, objective, acceptanceCriteria, contextBootstrap = false, autonomyPolicy = 'balanced',
-  maxFailures = 3, maxNoProgressMinutes, continuationPolicy, autoContinueEpoch, openClient = openCodexAppServer,
+  maxFailures = 3, maxNoProgressMinutes, continuationPolicy, autoContinueEpoch, executionCwd, upgradeRunId, openClient = openCodexAppServer,
   readClaude = readClaudeSession, inspectProcess = processIdentity, now = Date.now() }) {
   if (!['codex', 'claude'].includes(provider)) throw new Error('This provider does not have a verified exact-session enrollment channel.');
   if (typeof objective !== 'string' || !objective.trim() || objective.length > 4000) throw new Error('A concrete objective is required.');
@@ -232,7 +278,7 @@ export async function enrollSession({ root, provider, session, objective, accept
     metadata = await readClaude(session);
     const record = await readRecord(root, provider, session);
     await requireClaudeChannel(record, metadata, inspectProcess);
-    if (record.run) throw new Error('This session already has a Delivery Loop.');
+    if (record.run && !upgradeRunId) throw new Error('This session already has a Delivery Loop.');
     await monitorSession({ root, provider, session, monitor: true, readClaude: async () => metadata, now });
     // A second check narrows the time between metadata admission and the
     // original provider's next Stop boundary. Process exit still remains a
@@ -246,7 +292,7 @@ export async function enrollSession({ root, provider, session, objective, accept
   const initialPlan = initialDiagnosisPlan(objective.trim(), contextBootstrap);
   const admission = provider === 'codex' ? { source: 'codex_app_server', provider, session, cwd, model: metadata.model } : undefined;
   const liveRecord = provider === 'claude' ? await readRecord(root, provider, session) : null;
-  const run = await startDelivery({ root, provider, session, cwd, objective: objective.trim(), nextStep: 'Inspect current evidence and propose the next assessed action.',
+  const run = await startDelivery({ root, provider, session, cwd, executionCwd, upgradeRunId, objective: objective.trim(), nextStep: 'Inspect current evidence and propose the next assessed action.',
     maxFailures, continuationPolicy, now, admission, inspectProcess, autoContinueEpoch,
     liveHookAdmission: liveRecord ? { hookStartedAt: liveRecord.hookStartedAt, pid: liveRecord.process.pid, identity: liveRecord.process.identity } : undefined,
     managed: { acceptanceCriteria, contextBootstrap, autonomyPolicy, maxNoProgressMinutes, approvalScopes: ['task'], approvalPolicy: 'wait',
@@ -257,6 +303,14 @@ export async function enrollSession({ root, provider, session, objective, accept
 }
 
 export async function continueSession(options) {
+  const record = await readRecord(options.root, options.provider, options.session);
+  if (record?.run && !record.run.managed) {
+    // The user asked to continue this task. Adopt its goal and failure budget,
+    // rather than enrolling the generic context-bootstrap goal as a new run.
+    return enrollSession({ ...options, objective: record.run.objective, upgradeRunId: record.run.id,
+      maxFailures: record.run.maxFailures, contextBootstrap: false,
+      acceptanceCriteria: [{ id: 'original-goal', description: record.run.objective.slice(0, 500), check: { type: 'manual' } }] });
+  }
   return enrollSession({ ...options, objective: 'Understand and continue the selected conversation’s current user request.',
     acceptanceCriteria: [], contextBootstrap: true });
 }

package/src/session-supervision/statistics.js

@@ -6,81 +6,159 @@ import { join, relative, isAbsolute, sep } from 'node:path';
 const HOUR = 3_600_000;
 export const unavailableStatistics = () => ({ state: 'unavailable', hours: [], activity: [] });
 
-// Only usage envelopes and timestamps leave this reader, never message text.
-// Work time is an estimate from recorded activity, not a provider billing metric.
-export function transcriptStatistics(text, provider, session, { now = Date.now(), truncated = false } = {}) {
-  const events = [], usage = new Map();
-  let cumulative = 0, missing = truncated, matched = false;
-  for (const line of text.split('\n')) {
-    if (!line.trim()) continue;
+const READ_BYTES = 1024 * 1024;
+const MAX_LINE_BYTES = 4 * READ_BYTES;
+const WINDOW_MS = 7 * 24 * HOUR;
+// One selected transcript only; no raw messages or on-disk cache. Identity and
+// ctime prevent reuse after replacement/truncation even when size is unchanged.
+let cachedTranscript;
+const fingerprint = info => [info.dev, info.ino, info.size, info.mtimeMs, info.ctimeMs].join(':');
+
+// Only usage envelopes and timestamps survive parsing, never message text.
+// The reverse reducer attributes each cumulative difference to the newer row,
+// retaining an older baseline even when it lies outside the displayed week.
+class StatisticsAccumulator {
+  constructor(provider, session, now, reverse = false) {
+    Object.assign(this, { provider, session, scanNow: now, reverse, events: [], usage: new Map(), cumulative: 0,
+      pending: null, earliest: Infinity, missing: false, matched: false, wrongSession: false });
+  }
+  recordUsage(at, total, delta) {
+    if (at < this.scanNow - WINDOW_MS) return;
+    const key = `codex:${at}:${total}`;
+    if (delta > 0 || !this.usage.has(key)) this.usage.set(key, { at, tokens: delta });
+  }
+  add(line) {
+    if (!line.trim()) return;
     let row;
-    try { row = JSON.parse(line); } catch { missing = true; continue; }
-    if (provider === 'codex' && row.type === 'session_meta') {
-      if (row.payload?.id !== session) return unavailableStatistics();
-      matched = true;
+    try { row = JSON.parse(line); } catch { this.missing = true; return; }
+    if (!row || typeof row !== 'object' || Array.isArray(row)) { this.missing = true; return; }
+    if (this.provider === 'codex' && row.type === 'session_meta') {
+      if (row.payload?.id !== this.session) this.wrongSession = true;
+      else this.matched = true;
     }
-    if (provider === 'claude') {
-      if (row.sessionId !== session || row.isSidechain === true) continue;
-      matched = true;
+    if (this.provider === 'claude') {
+      if (row.sessionId !== this.session || row.isSidechain === true) return;
+      this.matched = true;
     }
     const at = Date.parse(row.timestamp);
-    if (!Number.isFinite(at) || at > now) continue;
-    const active = provider === 'claude' ? ['user', 'assistant'].includes(row.type) && !row.isMeta
+    if (!Number.isFinite(at)) return;
+    const inWindow = at >= this.scanNow - WINDOW_MS;
+    const active = this.provider === 'claude' ? ['user', 'assistant'].includes(row.type) && !row.isMeta
       : ['response_item', 'event_msg'].includes(row.type) && row.payload?.type !== 'token_count';
-    if (active) events.push(at);
-    if (provider === 'codex' && row.type === 'event_msg' && row.payload?.type === 'token_count') {
+    if (active) {
+      this.earliest = Math.min(this.earliest, at);
+      if (inWindow) this.events.push(at);
+    }
+    if (this.provider === 'codex' && row.type === 'event_msg' && row.payload?.type === 'token_count') {
       const total = row.payload.info?.total_token_usage?.total_tokens;
-      if (!Number.isSafeInteger(total) || total < 0) continue;
-      if (total < cumulative) { missing = true; cumulative = total; continue; }
-      const delta = total - cumulative; cumulative = total;
-      const key = `codex:${at}:${total}`;
-      if (delta > 0 || !usage.has(key)) usage.set(key, { at, tokens: delta });
-    } else if (provider === 'claude' && row.type === 'assistant' && row.message?.id) {
+      if (!Number.isSafeInteger(total) || total < 0) return;
+      this.earliest = Math.min(this.earliest, at);
+      if (this.reverse) {
+        if (this.pending) {
+          const delta = this.pending.total - total;
+          if (delta < 0) this.missing = true;
+          else this.recordUsage(this.pending.at, this.pending.total, delta);
+        }
+        this.pending = { at, total };
+      } else {
+        if (at > this.scanNow) return;
+        if (total < this.cumulative) { this.missing = true; this.cumulative = total; return; }
+        this.recordUsage(at, total, total - this.cumulative);
+        this.cumulative = total;
+      }
+    } else if (this.provider === 'claude' && row.type === 'assistant' && row.message?.id && (inWindow || !this.reverse || this.usage.has(row.message.id))) {
       const u = row.message.usage;
-      if (!u || ![u.input_tokens, u.output_tokens].every(x => Number.isSafeInteger(x) && x >= 0)) continue;
-      // Cached input is separate in Claude. Count it once with uncached input.
-      if (![u.cache_creation_input_tokens ?? 0, u.cache_read_input_tokens ?? 0].every(x => Number.isSafeInteger(x) && x >= 0)) continue;
+      if (!u || ![u.input_tokens, u.output_tokens, u.cache_creation_input_tokens ?? 0, u.cache_read_input_tokens ?? 0]
+        .every(x => Number.isSafeInteger(x) && x >= 0)) return;
       const tokens = u.input_tokens + u.output_tokens + (u.cache_creation_input_tokens || 0) + (u.cache_read_input_tokens || 0);
-      if (!Number.isSafeInteger(tokens) || tokens < 0) continue;
-      const previous = usage.get(row.message.id);
-      if (!previous || tokens > previous.tokens) usage.set(row.message.id, { at, tokens });
+      if (!Number.isSafeInteger(tokens)) return;
+      const previous = this.usage.get(row.message.id);
+      if (!previous || tokens > previous.tokens || tokens === previous.tokens && at < previous.at) this.usage.set(row.message.id, { at, tokens });
     }
   }
-  if (!matched) return unavailableStatistics();
-  const timestamps = [...events, ...[...usage.values()].map(x => x.at)].sort((a, b) => a - b);
-  if (!timestamps.length) return unavailableStatistics();
-  const start = Math.max(timestamps[0], now - 7 * 24 * HOUR);
-  const end = now;
-  const hours = new Map();
-  for (let at = Math.floor(start / HOUR) * HOUR; at <= end; at += HOUR) hours.set(at, { at, tokens: null });
-  for (const item of usage.values()) {
-    if (item.at < start || item.at > end) continue;
-    const bucket = hours.get(Math.floor(item.at / HOUR) * HOUR);
-    bucket.tokens = (bucket.tokens ?? 0) + item.tokens;
+  finish(now, incomplete = false, coverage = {}) {
+    if (!this.matched || this.wrongSession || this.earliest > now) return unavailableStatistics();
+    const missing = this.missing || incomplete;
+    const start = Math.max(this.earliest, now - WINDOW_MS), end = now;
+    const hours = new Map();
+    for (let at = Math.floor(start / HOUR) * HOUR; at <= end; at += HOUR) hours.set(at, { at, tokens: null });
+    const usage = [...this.usage.values()];
+    if (this.reverse && this.pending) usage.push({ at: this.pending.at, tokens: this.pending.total });
+    for (const item of usage) {
+      if (item.at < start || item.at > end) continue;
+      const bucket = hours.get(Math.floor(item.at / HOUR) * HOUR);
+      bucket.tokens = (bucket.tokens ?? 0) + item.tokens;
+    }
+    const activity = [];
+    for (const at of this.events.filter(x => x >= start && x <= end).sort((a, b) => a - b)) {
+      const previous = activity.at(-1);
+      if (previous && at - previous.end <= 5 * 60_000) previous.end = at;
+      else activity.push({ start: at, end: at });
+    }
+    const activeMs = activity.reduce((total, x) => total + x.end - x.start, 0);
+    const elapsedMs = end - start;
+    return { state: missing ? 'partial' : 'ready', start, end, observedAt: now, hours: [...hours.values()], activity,
+      tokens: [...hours.values()].some(h => h.tokens !== null) ? [...hours.values()].reduce((sum, h) => sum + (h.tokens || 0), 0) : null,
+      activeMs, idleMs: missing ? null : Math.max(0, elapsedMs - activeMs),
+      utilization: missing || !elapsedMs ? null : activeMs / elapsedMs,
+      coverage: { ...coverage, complete: !missing, scope: 'rolling_7_days' },
+      activityMethod: 'recorded_events_5m_gap', includesCachedInput: true };
   }
-  const activity = [];
-  for (const at of events.filter(x => x >= start && x <= end).sort((a, b) => a - b)) {
-    const previous = activity.at(-1);
-    if (previous && at - previous.end <= 5 * 60_000) previous.end = at;
-    else activity.push({ start: at, end: at });
+}
+
+export function transcriptStatistics(text, provider, session, { now = Date.now(), truncated = false } = {}) {
+  const accumulator = new StatisticsAccumulator(provider, session, now);
+  for (const line of text.split('\n')) accumulator.add(line);
+  return accumulator.finish(now, truncated);
+}
+
+async function readReverse(handle, size, accumulator) {
+  let position = size, carry = Buffer.alloc(0), skipping = false, bytesRead = 0;
+  while (position > 0) {
+    const length = Math.min(position, READ_BYTES); position -= length;
+    const buffer = Buffer.allocUnsafe(length);
+    let filled = 0;
+    while (filled < length) {
+      const read = await handle.read(buffer, filled, length - filled, position + filled);
+      if (!read.bytesRead) break;
+      filled += read.bytesRead;
+    }
+    bytesRead += filled;
+    if (filled !== length) accumulator.missing = true;
+    const data = Buffer.concat([buffer.subarray(0, filled), carry]);
+    let end = data.length;
+    for (let index = data.lastIndexOf(10); index >= 0; index = data.lastIndexOf(10, index - 1)) {
+      const line = data.subarray(index + 1, end);
+      if (!skipping && line.length <= MAX_LINE_BYTES) accumulator.add(line.toString('utf8'));
+      else accumulator.missing = true;
+      skipping = false; end = index;
+      if (index === 0) break;
+    }
+    if (end > MAX_LINE_BYTES || skipping) { carry = Buffer.alloc(0); skipping = true; accumulator.missing = true; }
+    else carry = Buffer.from(data.subarray(0, end));
   }
-  const activeMs = activity.reduce((total, x) => total + x.end - x.start, 0);
-  const elapsedMs = end - start;
-  return { state: missing ? 'partial' : 'ready', start, end, observedAt: now, hours: [...hours.values()], activity,
-    tokens: [...hours.values()].some(h => h.tokens !== null) ? [...hours.values()].reduce((sum, h) => sum + (h.tokens || 0), 0) : null,
-    activeMs, idleMs: Math.max(0, elapsedMs - activeMs), utilization: elapsedMs ? activeMs / elapsedMs : null,
-    activityMethod: 'recorded_events_5m_gap', includesCachedInput: true };
+  if (!skipping) accumulator.add(carry.toString('utf8'));
+  return bytesRead;
 }
 
-export async function statisticsFromHandle(handle, info, provider, session, options) {
-  const maximum = 32 * 1024 * 1024;
-  // Keep the prefix for identity and cumulative usage. Never invent a baseline
-  // from a truncated tail or claim the unobserved remainder as zero.
-  const buffer = Buffer.alloc(Math.min(info.size, maximum));
-  const { bytesRead } = await handle.read(buffer, 0, buffer.length, 0);
+export async function statisticsFromHandle(handle, info, provider, session, { now = Date.now(), ...options } = {}) {
+  const key = `${provider}:${session}:${fingerprint(info)}`;
+  // Rebuild time-dependent buckets from cached envelopes, never cache wall-clock
+  // idle time. A backwards clock or a new file fingerprint requires a new scan.
+  if (cachedTranscript?.key === key && now >= cachedTranscript.accumulator.scanNow) {
+    const cached = cachedTranscript;
+    const changed = fingerprint(await handle.stat()) !== fingerprint(info);
+    if (changed) cachedTranscript = undefined;
+    return cached.accumulator.finish(now, changed || options.truncated, cached.coverage);
+  }
+  const accumulator = new StatisticsAccumulator(provider, session, now, true);
+  const bytesRead = await readReverse(handle, info.size, accumulator);
   const after = await handle.stat();
-  return transcriptStatistics(buffer.subarray(0, bytesRead).toString('utf8'), provider, session,
-    { ...options, truncated: info.size > maximum || after.size !== info.size || after.mtimeMs !== info.mtimeMs });
+  const changed = fingerprint(after) !== fingerprint(info);
+  const coverage = { bytesRead, totalBytes: info.size };
+  if (!changed && !accumulator.missing && !options.truncated) cachedTranscript = { key, accumulator, coverage };
+  else cachedTranscript = undefined;
+  return accumulator.finish(now, changed || options.truncated, coverage);
 }
 
 export async function readCodexStatistics(client, candidate, { home = process.env.CODEX_HOME || join(homedir(), '.codex'), ...options } = {}) {

package/src/sqm/failure-circuit.js

@@ -0,0 +1,105 @@
+import { createHash, randomUUID } from "node:crypto";
+import { mkdir, readFile, rename, rm, writeFile } from "node:fs/promises";
+import { join } from "node:path";
+import { compareVersions } from "../backend-executable.js";
+import { CLI_VERSION } from "../cli-contract.js";
+import { defaultSessionRoot } from "../session-store.js";
+
+export const SQM_FAILURE_PAUSE_THRESHOLD = 6;
+const scopeKey = scope => JSON.stringify([scope?.webOrigin, scope?.accountId, scope?.organizationId]);
+const validVersion = value => typeof value === "string" && /^\d+\.\d+\.\d+$/.test(value);
+
+export function createSqmFailureCircuitStore({ root = defaultSessionRoot() } = {}) {
+  const directory = join(root, "sqm-failure-circuit");
+  const path = scope => {
+    if (!scope?.webOrigin || !scope?.accountId || !scope?.organizationId) throw new Error("SQM failure state requires an organization scope.");
+    return join(directory, `${createHash("sha256").update(scopeKey(scope)).digest("hex")}.json`);
+  };
+  return {
+    async read(scope) {
+      try {
+        const state = JSON.parse(await readFile(path(scope), "utf8"));
+        if (!validVersion(state.version) || !Number.isInteger(state.failures) || state.failures < 0 || state.failures > SQM_FAILURE_PAUSE_THRESHOLD || (state.inFlight !== undefined && typeof state.inFlight !== "boolean"))
+          throw new Error("Invalid saved SQM failure state.");
+        return state;
+      } catch (error) { if (error.code === "ENOENT") return null; throw error; }
+    },
+    async write(scope, state) {
+      const target = path(scope), temporary = `${target}.${randomUUID()}.tmp`;
+      await mkdir(directory, { recursive: true, mode: 0o700 });
+      try {
+        await writeFile(temporary, JSON.stringify(state), { mode: 0o600 });
+        await rename(temporary, target);
+      } finally { await rm(temporary, { force: true }); }
+    },
+  };
+}
+
+// One counter per organization on this machine, shared by both local engines.
+// Neither reconnecting nor an empty claim demonstrates successful analysis.
+export function createSqmFailureCircuit({ version = CLI_VERSION, store = null } = {}) {
+  if (!validVersion(version)) throw new Error("SQM failure circuit requires a SIMY version.");
+  const states = new Map();
+  const unreadableScopes = new Set();
+  const save = async (scope, state) => {
+    try { await store?.write(scope, { version: state.version, failures: state.failures, inFlight: state.inFlight === true }); state.storageError = false; }
+    catch (error) { state.storageError = true; throw error; }
+  };
+  const load = async scope => {
+    const key = scopeKey(scope);
+    let state = states.get(key);
+    if (!state) {
+      let saved;
+      try { saved = await store?.read(scope); unreadableScopes.delete(key); }
+      catch (error) { unreadableScopes.add(key); throw error; }
+      state = saved ? { version: saved.version, failures: saved.failures, inFlight: saved.inFlight === true } : { version, failures: 0, inFlight: false };
+      states.set(key, state);
+      // An unfinished review from this same version means the last host exited
+      // without a result or graceful cancellation. Count it once on restart.
+      if (state.inFlight && compareVersions(version, state.version) <= 0) {
+        state.failures = Math.min(SQM_FAILURE_PAUSE_THRESHOLD, state.failures + 1);
+        state.inFlight = false;
+        await save(scope, state);
+      }
+    }
+    if (compareVersions(version, state.version) > 0) {
+      state.version = version;
+      state.failures = 0;
+      state.inFlight = false;
+      await save(scope, state);
+    } else if (state.storageError) await save(scope, state);
+    return state;
+  };
+  return {
+    async canClaim(scope) { return (await load(scope)).failures < SQM_FAILURE_PAUSE_THRESHOLD; },
+    async begin(scope) {
+      const state = await load(scope);
+      state.inFlight = true;
+      await save(scope, state);
+    },
+    async cancel(scope) {
+      const state = await load(scope);
+      state.inFlight = false;
+      await save(scope, state);
+    },
+    async failure(scope) {
+      const state = await load(scope);
+      state.failures = Math.min(SQM_FAILURE_PAUSE_THRESHOLD, state.failures + 1);
+      state.inFlight = false;
+      await save(scope, state);
+    },
+    async success(scope) {
+      const state = await load(scope);
+      state.failures = 0;
+      state.inFlight = false;
+      await save(scope, state);
+    },
+    snapshot(scope) {
+      const state = states.get(scopeKey(scope));
+      return { consecutive_failures: state?.failures || 0,
+        paused_until_update: (state?.failures || 0) >= SQM_FAILURE_PAUSE_THRESHOLD,
+        paused_at_version: (state?.failures || 0) >= SQM_FAILURE_PAUSE_THRESHOLD ? state.version : null,
+        storage_unavailable: state?.storageError === true || unreadableScopes.has(scopeKey(scope)) };
+    },
+  };
+}

package/src/sqm/provider-diagnostics.js

@@ -11,7 +11,7 @@ export function safeProviderDiagnostic(value) {
   if (SIGNALS.has(value.signal)) result.signal = value.signal;
   if (Number.isInteger(value.outputBytes) && value.outputBytes >= 0 && value.outputBytes <= 2147483647) result.outputBytes = value.outputBytes;
   if (value.retryAttempt === 0 || value.retryAttempt === 1) result.retryAttempt = value.retryAttempt;
-  if (typeof value.model === "string" && /^(?:gpt-6-(?:astra)|gpt-6\.1-sol|claude-(?:sonnet|opus|haiku)-[0-9]+(?:-[0-9]+){0,3})$/.test(value.model) && value.model.length <= 64) result.model = value.model;
+  if (typeof value.model === "string" && /^(?:gpt-6-(?:astra|sol)|gpt-6\.1-sol|claude-(?:sonnet|opus|haiku)-[0-9]+(?:-[0-9]+){0,3})$/.test(value.model) && value.model.length <= 64) result.model = value.model;
   return result;
 }
 

package/src/sqm/review-worker.js

@@ -5,6 +5,7 @@ import { tmpdir } from "node:os";
 import { join } from "node:path";
 
 import { safeSqmDiagnostic, formatSqmDiagnostic } from "./diagnostics.js";
+import { createSqmFailureCircuit } from "./failure-circuit.js";
 import { inspectProviderStatus } from "../desktop-status.js";
 import { inspectDesktopExecutor } from "../desktop-executor.js";
 import { safeProviderDiagnostic, PROVIDER_FAILURE_HINTS } from "./provider-diagnostics.js";
@@ -20,7 +21,8 @@ const DEFAULT_REQUEST_TIMEOUT_MS = 75_000;
 const DEFAULT_EXECUTION_TIMEOUT_MS = 240_000;
 // Keep analysis independent of interactive config. Availability varies by
 // account and CLI; only an explicit model rejection may try the next model.
-export const SQM_CODEX_MODELS = Object.freeze(["gpt-6-astra", "gpt-6.1-sol"]);
+// Background SQM and conversation triage use Sol models to limit usage.
+export const SQM_CODEX_MODELS = Object.freeze(["gpt-6.1-sol", "gpt-6-sol"]);
 export const SQM_CODEX_MODEL = SQM_CODEX_MODELS[0];
 
 export class SqmLocalReviewError extends Error {
@@ -108,6 +110,7 @@ export function createSqmLocalReviewWorker({
   now = () => Date.now(),
   providerFailureCooldownMs = 5 * 60_000,
   getRecoveryKey = () => null,
+  failureCircuit = createSqmFailureCircuit(),
 } = {}) {
   if (!api || typeof api.request !== "function") throw new TypeError("api.request is required");
   let activeJobId = null;
@@ -186,7 +189,6 @@ export function createSqmLocalReviewWorker({
       kind: "analysis", state: "running", provider, startedAt: new Date().toISOString(), webUrl: analysisTaskUrl(workspaceUrl, claim.job_id) });
     historyScopes.set(history[0], JSON.stringify(historyScope));
     history.splice(50);
-    await persist(historyScope, history[0]);
     onChange();
     let heartbeatTimer = null;
     const heartbeat = () => {
@@ -202,6 +204,8 @@ export function createSqmLocalReviewWorker({
     const providerReport = (review, selectedProvider = provider) => claim.capabilities?.reported_executor_provider === true
       ? { reported_executor_provider: review.provider || selectedProvider } : {};
     try {
+      await failureCircuit.begin(historyScope);
+      await persist(historyScope, history[0]);
       const { review: analysis, response: advanced } = await validatedReview(claim.request, provider, "invalid_sqm_analysis_output", analysis => request({
         action: "advance",
         ...leaseBody(claim, provider),
@@ -249,7 +253,11 @@ export function createSqmLocalReviewWorker({
   return {
     snapshot() {
       const pause = currentPause();
-      return { active_job_id: activeJobId, polling: Boolean(pollPromise), closed, suspended, paused: pausedEnvironment !== null, pause_reason: pauseReason, issue: issueContext === contextKey(getProvider(), getHistoryScope()) ? issue : null,
+      const circuit = failureCircuit.snapshot(getHistoryScope());
+      return { active_job_id: activeJobId, polling: Boolean(pollPromise), closed, suspended,
+        paused: pausedEnvironment !== null || circuit.paused_until_update || circuit.storage_unavailable,
+        pause_reason: circuit.paused_until_update ? "consecutive_failures_until_update" : circuit.storage_unavailable ? "failure_state_unavailable" : pauseReason,
+        ...circuit, issue: issueContext === contextKey(getProvider(), getHistoryScope()) ? issue : null,
         ...(pause ? { provider_pause: { code: pause.code, status: pause.status, retry_at: new Date(pause.retryAt).toISOString(), message: pause.message } } : {}) };
     },
     desktopTasks() { return { activeCount: activeJobId ? 1 : 0, items: visibleHistory().map(item => ({ ...item, canStop: item.id === activeJobId })) }; },
@@ -257,7 +265,7 @@ export function createSqmLocalReviewWorker({
       const item = visibleHistory().find(item => item.key === key);
       return item ? { key, instruction: `SQM local review · ${item.provider}`, result: item.state === "completed" ? "SQM review submitted." : "", error: item.error || "", links: item.webUrl ? [{ label: "Analysis details", url: item.webUrl }] : [] } : null;
     },
-    retry() { if (closed || suspended || pollPromise) return false; pausedEnvironment = null; pauseReason = null; pauses.delete(contextKey(getProvider(), getHistoryScope())); issue = null; onChange(); return true; },
+    retry() { if (closed || suspended || pollPromise || failureCircuit.snapshot(getHistoryScope()).paused_until_update) return false; pausedEnvironment = null; pauseReason = null; pauses.delete(contextKey(getProvider(), getHistoryScope())); issue = null; onChange(); return true; },
     resetHistory() { if (!pollPromise) { history.splice(0); issue = null; pausedEnvironment = null; pauseReason = null; } },
     poll() {
       if (closed || suspended || pollPromise) return pollPromise || Promise.resolve(null);
@@ -278,6 +286,8 @@ export function createSqmLocalReviewWorker({
       const workspaceUrl = getWorkspaceUrl();
       reviewController = new AbortController();
       pollPromise = (async () => {
+        if (!await failureCircuit.canClaim(historyScope)) return null;
+        if (reviewController.signal.aborted) throw providerFailure("analysis_cancelled");
         const claim = await api.request({
           action: "claim",
           executor_provider: provider,
@@ -292,11 +302,16 @@ export function createSqmLocalReviewWorker({
           return null;
         }
         const result = await processClaim(claim, provider, historyScope, workspaceUrl);
+        try { await failureCircuit.success(historyScope); } catch (storageError) { onError(storageError); }
         pauses.delete(key);
         return result;
       })()
         .catch(async (error) => {
-          if (error.code === "analysis_cancelled") return null;
+          if (error.code === "analysis_cancelled") {
+            try { await failureCircuit.cancel(historyScope); } catch (storageError) { onError(storageError); }
+            return null;
+          }
+          try { await failureCircuit.failure(historyScope); } catch (storageError) { onError(storageError); }
           pauseForFailure(error, provider, historyScope, recoveryKey);
           if (error.jobId && /^[a-f0-9-]{36}$/i.test(error.jobId) && !history.some(item => item.id === error.jobId)) {
             const scope = historyScope;