@awak-app/simy-cli 0.6.10 → 0.6.11

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/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";
@@ -109,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;
@@ -187,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 = () => {
@@ -203,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),
@@ -250,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 })) }; },
@@ -258,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);
@@ -279,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,
@@ -293,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;