@awak-app/simy-cli 0.5.83 → 0.6.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@awak-app/simy-cli",
-  "version": "0.5.83",
+  "version": "0.6.0",
   "description": "Local SIMY executor for non-coding Local Tasks and Agentic Loop runs.",
   "type": "module",
   "bin": {

package/src/cli-contract.js

@@ -13,7 +13,7 @@ import {
 } from "./durable-local-task-steps-contract.js";
 import { buildExecutionCapabilityContract } from "./execution-capability-contract.js";
 
-export const CLI_VERSION = "0.5.83";
+export const CLI_VERSION = "0.6.0";
 export const CLI_API_CONTRACT_VERSION = 10;
 
 export function withCliContract(

package/src/desktop-host.js

@@ -1,3 +1,7 @@
+import { readCodexStatistics, unavailableStatistics } from './session-supervision/statistics.js';
+import { readClaudeStatistics } from './session-supervision/claude-sessions.js';
+import { openCodexAppServer } from './session-supervision/codex-app-server.js';
+import { conversationSqmChecks } from './session-supervision/sqm-presentation.js';
 import { stopOwnedDesktopHost } from "./desktop-force-quit.js";
 import { desktopAccessReady, desktopActionAllowed, requireDesktopAccess, validDesktopAccessPath } from './desktop-access.js';
 import { createActionDeadlineService } from './session-supervision/action-deadline.js';
@@ -89,12 +93,14 @@ export async function startDesktopHost({ input = process.stdin, output = process
   let agent, updater, analysisManager, automaticContinuation, stopWorkflows = async () => {}, timer, closed = false, relay = null, publishing = null, publishAgain = false, scheduledPublish = null;
   const makeActionAssociations = () => (dependencies.createActionAssociationHost || createActionAssociationHost)({ root: join(root, "delivery-hooks"), sessionRoot: root, webOrigin, list: () => recordReader.list(), onChange: () => { if (!closed) setImmediate(() => { void publish().catch(() => {}); }); } });
   let actionAssociations = makeActionAssociations();
+  const statisticsCache = new Map();
   let currentAccess = { state: 'checking', organizationId: null, organizationName: null };
   const accessScope = access => JSON.stringify([access?.revision ?? null, access?.organizationId ?? null]);
   const setAccessSnapshot = async access => {
     const previousScope = accessScope(currentAccess);
     currentAccess = access || { state: 'unavailable', organizationId: null, organizationName: null };
     if (previousScope !== accessScope(currentAccess)) {
+      statisticsCache.clear();
       discoveryController?.abort();
       sessionRefreshAgain = Boolean(sessionRefresh) && desktopAccessReady(currentAccess);
       for (const item of sessionStatus.sessions) automaticContinuation?.revoke(item.provider, item.session);
@@ -246,6 +252,8 @@ export async function startDesktopHost({ input = process.stdin, output = process
       await actionAssociations.decorateSessions?.(sessions, projection);
       const runsBySession = new Map((status.deliveryHooks.runs || []).map(run => [`${run.provider}:${run.session}`, run]));
       for (const session of sessions) {
+        session.statistics = statisticsCache.get(`${session.provider}:${session.session}`) || unavailableStatistics();
+        session.sqmActivity = conversationSqmChecks(session, [...(status.sqmChecks?.items || []), ...(status.sqmTasks?.items || [])]);
         const context = await actionAssociations.deadlineContext?.(session, projection);
         if (context) session.actionDeadline = await deadlines.reconcile(context, { displayOnly: true });
         else session.actionDeadline = { status: 'unavailable', online: false, reminder: null };
@@ -457,6 +465,21 @@ export async function startDesktopHost({ input = process.stdin, output = process
         if (!desktopActionAllowed(access, command)) throw Object.assign(new Error('Desktop access is required.'), { code: 'desktop_access_required' });
         if (desktopAccessReady(access) && !desktopActionAllowed({ state: 'unavailable' }, command)) await authorizeWork();
 
+        if (action === "session_statistics") {
+          const candidate = await selectedSession(command, { preferObserved: true });
+          let statistics;
+          if (dependencies.readSessionStatistics) statistics = await dependencies.readSessionStatistics(candidate);
+          else if (candidate.provider === 'claude') statistics = await readClaudeStatistics(candidate);
+          else {
+            const client = await openCodexAppServer();
+            try { statistics = await readCodexStatistics(client, candidate); } finally { await client.close(); }
+          }
+          await authorizeWork(commandScope);
+          statisticsCache.clear(); // Only the selected conversation needs chart data.
+          statisticsCache.set(`${candidate.provider}:${candidate.session}`, statistics);
+          emit({ type: "result", id: command.id, ok: true });
+          void publish(); return;
+        }
         if (action === "my_ai_session") {
           const ticket = await agent.createDesktopWebSession();
           await authorizeWork(commandScope);

package/src/desktop-sqm-settings.js

@@ -15,10 +15,15 @@ export async function readSqmSettings(root, origin, session) {
   if (!path) return { enabled: false, enable_engine_fallback: false, allowed_fallback_providers: [] };
   try {
     const settings = JSON.parse(await readFile(path, 'utf8'));
-    return { enabled: settings.enabled === true, enable_engine_fallback: settings.enable_engine_fallback === true,
-      allowed_fallback_providers: Array.isArray(settings.allowed_fallback_providers)
-        ? [...new Set(settings.allowed_fallback_providers.filter(provider => ['codex', 'claude'].includes(provider)))] : [] };
-  } catch (error) { if (error.code === 'ENOENT' || error instanceof SyntaxError) return { enabled: false, enable_engine_fallback: false, allowed_fallback_providers: [] }; throw error; }
+    // Desktop analysis is automatic. Legacy UI opt-outs no longer gate it.
+    if (settings?.policyVersion !== 2) return defaultSqmSettings();
+    const providers = Array.isArray(settings.allowed_fallback_providers) ? settings.allowed_fallback_providers : [];
+    return {
+      enabled: settings.enabled === true,
+      enable_engine_fallback: settings.enable_engine_fallback === true,
+      allowed_fallback_providers: [...new Set(providers.filter(provider => ['codex', 'claude'].includes(provider)))],
+    };
+  } catch (error) { if (error.code === 'ENOENT' || error instanceof SyntaxError) return defaultSqmSettings(); throw error; }
 }
 export async function writeSqmEnabled(root, origin, session, enabled) {
   return writeSqmSettings(root, origin, session, { enabled });
@@ -35,6 +40,10 @@ async function writeSqmSettings(root, origin, session, update) {
   const current = await readSqmSettings(root, origin, session);
   await mkdir(join(root, 'sqm-settings'), { recursive: true, mode: 0o700 });
   const temporary = `${path}.${randomUUID()}.tmp`;
-  await writeFile(temporary, JSON.stringify({ ...current, ...update }), { mode: 0o600 });
+  await writeFile(temporary, JSON.stringify({ ...current, ...update, policyVersion: 2 }), { mode: 0o600 });
   await rename(temporary, path);
 }
+
+function defaultSqmSettings() {
+  return { enabled: true, enable_engine_fallback: true, allowed_fallback_providers: ['codex', 'claude'] };
+}

package/src/session-supervision/claude-sessions.js

@@ -1,3 +1,4 @@
+import { statisticsFromHandle, unavailableStatistics } from './statistics.js';
 import { constants } from 'node:fs';
 import { lstat, open, readdir, realpath } from 'node:fs/promises';
 import { homedir } from 'node:os';
@@ -97,7 +98,7 @@ async function latestCustomTitle(handle, size, id) {
   return title;
 }
 
-async function inspectTranscript(root, projectName, fileName, observedAt, includeContext = false, cacheMetadata = false) {
+async function inspectTranscript(root, projectName, fileName, observedAt, includeContext = false, cacheMetadata = false, includeStatistics = false) {
   const id = fileName.slice(0, -'.jsonl'.length);
   if (!UUID.test(id)) return null;
   const project = join(root, projectName);
@@ -139,13 +140,14 @@ async function inspectTranscript(root, projectName, fileName, observedAt, includ
     }
     if (!metadata) return null;
     const candidate = candidateMetadata(id, metadata, opened.mtimeMs, observedAt);
+    if (includeStatistics) candidate.statistics = await statisticsFromHandle(handle, opened, 'claude', id);
     if (includeContext) candidate.context = await conversationFromHandle(handle, opened, id, metadata.cwd);
     return candidate;
   } catch { metadataCache.delete(path); return null; }
   finally { await handle?.close(); }
 }
 
-async function collect({ home = homedir(), limit = 100, session = null, includeContext = false, cacheMetadata = false, signal } = {}) {
+async function collect({ home = homedir(), limit = 100, session = null, includeContext = false, cacheMetadata = false, includeStatistics = false, signal } = {}) {
   if (signal?.aborted) return [];
   const root = await projectsRoot(home);
   if (!root) return [];
@@ -167,9 +169,9 @@ async function collect({ home = homedir(), limit = 100, session = null, includeC
       const id = file.name.slice(0, -'.jsonl'.length);
       if (session && id !== session) continue;
       inspected++;
-      const candidate = await inspectTranscript(root, entry.name, file.name, observedAt, includeContext, cacheMetadata);
+      const candidate = await inspectTranscript(root, entry.name, file.name, observedAt, includeContext, cacheMetadata, includeStatistics);
       if (!candidate) continue;
-      const key = `${candidate.session}\0${candidate.cwd}${includeContext ? `\0${entry.name}\0${file.name}` : ''}`;
+      const key = `${candidate.session}\0${candidate.cwd}${includeContext || includeStatistics ? `\0${entry.name}\0${file.name}` : ''}`;
       if (!result.has(key) || candidate.lastActivityAt > result.get(key).lastActivityAt) result.set(key, candidate);
     }
     if (inspected >= MAX_TRANSCRIPTS) break;
@@ -230,3 +232,9 @@ export async function readClaudeConversation(candidate, { home, signal } = {}) {
   }
   return { ...selected[0].context, awaitingTurn: candidate.isRunning === true };
 }
+
+export async function readClaudeStatistics(candidate, { home } = {}) {
+  if (!UUID.test(candidate?.session || '')) return unavailableStatistics();
+  const matches = (await collect({ home, session: candidate.session, includeStatistics: true })).filter(item => item.cwd === candidate.cwd);
+  return matches.length === 1 ? matches[0].statistics : unavailableStatistics();
+}

package/src/session-supervision/sqm-presentation.js

@@ -0,0 +1,14 @@
+// Never associate by repository or the AI that executed an analysis. A result
+// belongs under a conversation only when the original provider/session match.
+export function conversationSqmChecks(candidate, checks) {
+  return checks.filter(check => check.conversationProvider === candidate.provider && check.providerSession === candidate.session &&
+    !['unavailable', 'interrupted'].includes(check.state) && (check.state !== 'failed' || ['failed', 'preliminary_failed'].includes(check.outcome) && (!check.errorStage || check.errorStage === 'evidence_upload'))).sort((a, b) => (b.finishedAt || b.startedAt || '').localeCompare(a.finishedAt || a.startedAt || '')).slice(0, 5).map(check => ({
+    id: check.key, state: check.state, checkedAt: check.finishedAt || check.startedAt,
+    scope: check.phase === 'min' ? 'Quick review of the changed work' : 'Review of the changed work and its checks',
+    result: check.state === 'running' ? 'Checking this work now.' : check.state === 'verification_pending'
+      ? 'Some checks still need a person to confirm the result.' : check.outcome === 'preliminary_failed'
+        ? 'The quick review found issues that need attention.' : check.outcome === 'failed' ? 'The review found issues that need attention.' : check.outcome === 'passed'
+          ? check.noApplicableChecks ? 'No applicable checks were recorded for this work.' : check.phase === 'min' ? 'The quick review found no blocking issues.' : 'The recorded checks passed.' : 'The review finished. Open the recorded result for its coverage.',
+    checked: check.checked || [], findings: check.findings ?? null,
+  }));
+}

package/src/session-supervision/statistics.js

@@ -0,0 +1,102 @@
+import { constants } from 'node:fs';
+import { lstat, open, realpath } from 'node:fs/promises';
+import { homedir } from 'node:os';
+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;
+    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;
+    }
+    if (provider === 'claude') {
+      if (row.sessionId !== session || row.isSidechain === true) continue;
+      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
+      : ['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') {
+      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) {
+      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;
+      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 (!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;
+  }
+  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 });
+  }
+  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 };
+}
+
+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);
+  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 });
+}
+
+export async function readCodexStatistics(client, candidate, { home = process.env.CODEX_HOME || join(homedir(), '.codex'), ...options } = {}) {
+  const response = await client.request('thread/read', { threadId: candidate.session, includeTurns: false });
+  const thread = response?.thread;
+  if (thread?.id !== candidate.session || thread.cwd !== candidate.cwd || typeof thread.path !== 'string') return unavailableStatistics();
+  let handle;
+  try {
+    const root = await realpath(home), path = await realpath(thread.path), rel = relative(root, path);
+    if (isAbsolute(rel) || rel.startsWith(`..${sep}`) || !['sessions', 'archived_sessions'].includes(rel.split(sep)[0])) return unavailableStatistics();
+    const before = await lstat(thread.path);
+    if (!before.isFile() || before.isSymbolicLink()) return unavailableStatistics();
+    handle = await open(thread.path, constants.O_RDONLY | (constants.O_NOFOLLOW || 0));
+    const info = await handle.stat();
+    if (info.ino !== before.ino || info.dev !== before.dev || await realpath(thread.path) !== path) return unavailableStatistics();
+    return await statisticsFromHandle(handle, info, 'codex', candidate.session, options);
+  } catch { return unavailableStatistics(); }
+  finally { await handle?.close(); }
+}

package/src/sqm/command.js

@@ -1,3 +1,4 @@
+import { sqmConversationIdentity } from './conversation-identity.js';
 import { safeSqmDiagnostic } from "./diagnostics.js";
 import { createSqmCheckRecorder } from "./history-store.js";
 import { mkdir, readFile, rename, writeFile } from "node:fs/promises";
@@ -40,7 +41,10 @@ export async function runSqmCommand(argv, { cliVersion }) {
   const deviceId = process.env.SIMY_SQM_DEVICE_ID || validSession?.device_id;
   if (!organizationId) throw new Error(`SQM needs an organization-bound SIMY session. Run \`simy --host ${webOrigin}\` once, then retry.`);
   const endpoint = process.env.SIMY_SQM_BUNDLE_URL || (validSession?.api_base_url ? new URL("sqm/knowledge-bundle", validSession.api_base_url).href : undefined);
+  const { providerSession, conversationProvider } = await sqmConversationIdentity({ session: option(argv, "--session"), provider: option(argv, "--provider") });
+  let checkedDescriptions = [];
   const common = {
+    onCheckedDescriptions: descriptions => { checkedDescriptions = descriptions; },
     cwd: process.cwd(),
     baseBranch: option(argv, "--base") || "dev",
     cliVersion,
@@ -53,10 +57,11 @@ export async function runSqmCommand(argv, { cliVersion }) {
     deviceId,
   };
 
-  const save = createSqmCheckRecorder({ scope: { webOrigin, accountId, organizationId },
-    phase: argv[0] === "min-check" ? "min" : "full", cwd: common.cwd, baseBranch: common.baseBranch });
+  const recorder = createSqmCheckRecorder({ scope: { webOrigin, accountId, organizationId },
+    providerSession, conversationProvider, phase: argv[0] === "min-check" ? "min" : "full", cwd: common.cwd, baseBranch: common.baseBranch });
+  const save = result => recorder(result, { checked: checkedDescriptions });
   const onRecoveryEvent = async diagnostic => createSqmCheckRecorder({ scope: { webOrigin, accountId, organizationId },
-    phase: argv[0] === "min-check" ? "min" : "full", cwd: common.cwd, baseBranch: common.baseBranch })({ status: "failed", diagnostic });
+    providerSession, conversationProvider, phase: argv[0] === "min-check" ? "min" : "full", cwd: common.cwd, baseBranch: common.baseBranch })({ status: "failed", diagnostic });
   common.bundleDependencies = { onRecoveryEvent };
   common.onRecoveryEvent = onRecoveryEvent;
   let authenticationAttempted = false;

package/src/sqm/conversation-identity.js

@@ -0,0 +1,35 @@
+import { execFile } from 'node:child_process';
+import { promisify } from 'node:util';
+import { defaultSessionRoot } from '../session-store.js';
+import { join } from 'node:path';
+import { listRecords, processIdentity } from '../codex-plugins/simy/hooks/delivery-loop.mjs';
+
+const exec = promisify(execFile);
+const UUID = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
+export async function sqmConversationIdentity({ session, provider, env = process.env, cwd = process.cwd(), root = defaultSessionRoot(),
+  records, ancestorPids, inspectProcess = processIdentity } = {}) {
+  if (!session && UUID.test(env.CODEX_THREAD_ID || '')) { session = env.CODEX_THREAD_ID; provider = 'codex'; }
+  if (UUID.test(session || '') && ['codex', 'claude'].includes(provider)) return { providerSession: session, conversationProvider: provider };
+  if (process.platform === 'win32' && !ancestorPids) return {};
+  // Claude does not export a session ID. Resolve only a live provider process
+  // in this command's ancestor chain, never a similar title or repository.
+  try {
+    const ancestors = ancestorPids || [];
+    if (!ancestorPids) {
+      let pid = process.ppid;
+      for (let depth = 0; pid > 1 && depth < 16; depth++) {
+        ancestors.push(pid);
+        const { stdout } = await exec('ps', ['-o', 'ppid=', '-p', String(pid)], { timeout: 1000 });
+        const parent = Number(stdout.trim());
+        if (!Number.isSafeInteger(parent) || parent === pid) break;
+        pid = parent;
+      }
+    }
+    const candidates = (records || await listRecords(join(root, 'delivery-hooks'))).filter(record =>
+      record.cwd === cwd && UUID.test(record.session || '') && ['codex', 'claude'].includes(record.provider) && ancestors.includes(record.process?.pid));
+    const verified = [];
+    for (const candidate of candidates) if (candidate.process?.identity && await inspectProcess(candidate.process.pid) === candidate.process.identity) verified.push(candidate);
+    if (verified.length === 1) return { providerSession: verified[0].session, conversationProvider: verified[0].provider };
+  } catch { /* Standalone or ambiguous commands have no conversation tag. */ }
+  return {};
+}

package/src/sqm/history-store.js

@@ -76,11 +76,14 @@ function metadata(entry) {
   if (!entry || !["analysis", "check"].includes(entry.kind) || typeof entry.key !== "string" || !entry.key.startsWith(entry.kind === "analysis" ? "sqm:" : "sqm-check:")) return null;
   if (!["running", "completed", "failed", "unavailable", "interrupted", "verification_pending"].includes(entry.state) || !Number.isFinite(Date.parse(entry.startedAt))) return null;
   const item = {};
-  for (const name of ["key", "id", "kind", "label", "state", "provider", "phase", "repository", "startedAt", "finishedAt", "instruction", "result", "error", "errorCode", "errorStage", "requestId", "webUrl"]) {
+  for (const name of ["key", "id", "kind", "label", "state", "provider", "phase", "repository", "startedAt", "finishedAt", "instruction", "result", "error", "errorCode", "errorStage", "requestId", "webUrl", "providerSession", "conversationProvider", "outcome"]) {
     if (typeof entry[name] === "string") item[name] = entry[name].slice(0, ["instruction", "result", "error"].includes(name) ? 4096 : 512);
   }
   if (Number.isInteger(entry.errorStatus) && entry.errorStatus >= 400 && entry.errorStatus <= 599) item.errorStatus = entry.errorStatus;
   if (Number.isInteger(entry.httpStatus) && entry.httpStatus >= 400 && entry.httpStatus <= 599) item.httpStatus = entry.httpStatus;
+  if (typeof entry.noApplicableChecks === 'boolean') item.noApplicableChecks = entry.noApplicableChecks;
+  if (Array.isArray(entry.checked)) item.checked = entry.checked.filter(value => typeof value === 'string').slice(0, 10).map(value => value.slice(0, 160));
+  if (Number.isSafeInteger(entry.findings) && entry.findings >= 0) item.findings = entry.findings;
   const providerDiagnostic = safeProviderDiagnostic(entry.providerDiagnostic);
   if (Object.keys(providerDiagnostic).length) item.providerDiagnostic = providerDiagnostic;
   return item;
@@ -95,12 +98,12 @@ export function projectSqmHistory(items, live = { activeCount: 0, items: [] }) {
     sqmChecks: { activeCount: 0, items: rows(items.filter(item => item.kind === "check")) } };
 }
 
-export function createSqmCheckRecorder({ root, scope, phase, cwd, baseBranch, onError = () => console.warn("Could not save the local SQM check history.") }) {
+export function createSqmCheckRecorder({ root, scope, phase, cwd, baseBranch, providerSession, conversationProvider, onError = () => console.warn("Could not save the local SQM check history.") }) {
   if (!scope?.webOrigin || !scope?.accountId || !scope?.organizationId) return async () => {};
   const history = createSqmHistoryStore({ root });
   const key = `sqm-check:${randomUUID()}`;
   const startedAt = new Date().toISOString();
-  return async result => {
+  return async (result, presentation = {}) => {
     const proof = result.proof, identity = proof?.repository_identity || result.repository_identity || result.min_check?.repository_identity;
     const repository = identity?.repository || result.repository;
     const outcome = proof?.outcome.status || result.min_check?.status || result.status;
@@ -119,7 +122,10 @@ export function createSqmCheckRecorder({ root, scope, phase, cwd, baseBranch, on
       : state === "failed" && !identity ? "The command did not finish. See the recorded diagnostics below."
       : `Min-check: ${result.min_check?.status || result.status} · ${(result.preliminary_findings || result.min_check?.preliminary_findings)?.length || 0} preliminary finding(s) · ${(result.matched_modules || result.min_check?.matched_modules)?.length || 0} matched module(s).\nThis is a preflight; run the full check for signed verification.`;
     try {
-      await history.record(scope, { key, id: key, kind: "check", phase, state, startedAt, finishedAt: new Date().toISOString(), repository,
+      await history.record(scope, { key, id: key, kind: "check", phase, state, startedAt, providerSession, conversationProvider, outcome,
+        checked: result.checked_descriptions || presentation.checked || [],
+        noApplicableChecks: (proof?.outcome.reasons || minCheck.coverage_reasons || []).includes('no_applicable_rules'),
+        findings: (proof?.findings || result.preliminary_findings || minCheck.preliminary_findings || []).length, finishedAt: new Date().toISOString(), repository,
         label: `${phase === "min" ? "Min-check" : "Check"} · ${repository || basename(cwd)}`,
         instruction: [repository || basename(cwd), `Base: ${identity?.base_ref || baseBranch}`, identity?.head_commit ? `Head: ${identity.head_commit}` : ""].filter(Boolean).join("\n"),
         result: [summary, ...minWarnings].join("\n"),

package/src/sqm/index.js

@@ -1,3 +1,4 @@
+import { sqmConversationIdentity } from './conversation-identity.js';
 import { sqmCoverageWarnings } from "./report.js";
 import { safeSqmDiagnostic } from "./diagnostics.js";
 import { createSqmCheckRecorder } from "./history-store.js";
@@ -31,12 +32,14 @@ export function createSqmChecker({
   executeKnowledgeBundleImpl,
   ...dependencies
 }) {
+  let conversationIdentity;
+  const getConversationIdentity = () => conversationIdentity ||= sqmConversationIdentity({ cwd, root: historyRoot });
   let pinnedLoad = null;
   let pinnedRepository = null;
   let latestMinCheck = null;
   let pinnedSystemScope;
   const onRecoveryEvent = async (diagnostic) => {
-    await createSqmCheckRecorder({ root: historyRoot,
+    await createSqmCheckRecorder({ ...await getConversationIdentity(), root: historyRoot,
       scope: historyRoot ? { webOrigin, accountId, organizationId } : null,
       phase: diagnostic.stage === "evidence_upload" ? "full" : "min", cwd, baseBranch })({ status: "failed", diagnostic });
     await dependencies.onRecoveryEvent?.(diagnostic);
@@ -98,7 +101,7 @@ export function createSqmChecker({
     }
   };
   const checker = async (attempt, options = {}) => {
-    const save = createSqmCheckRecorder({ root: historyRoot, scope: historyRoot ? { webOrigin, accountId, organizationId } : null, phase: options.phase || "min", cwd, baseBranch });
+    const save = createSqmCheckRecorder({ ...await getConversationIdentity(), root: historyRoot, scope: historyRoot ? { webOrigin, accountId, organizationId } : null, phase: options.phase || "min", cwd, baseBranch });
     try {
       const result = await checkCurrentRepository(attempt, options);
       await save(result); return result;
@@ -126,6 +129,7 @@ export async function runSqmMinCheck(options) {
   const context = await loadContext(options);
   if (!context.loaded.bundle) return { ...unavailable(context.loaded.warnings[0], context.repository.repository), warnings: context.loaded.warnings, diagnostic: context.loaded.diagnostic };
   const evaluation = await (options.evaluateKnowledgeBundleImpl || evaluateKnowledgeBundle)(context.loaded.bundle, context.repository);
+  await options.onCheckedDescriptions?.(checkedDescriptions(evaluation.modules, context.loaded.bundle));
   return buildMinCheck({ repository: context.repository, bundle: context.loaded.bundle, evaluation, organizationId: options.organizationId, cliVersion: options.cliVersion });
 }
 
@@ -219,6 +223,7 @@ async function buildFullCheck({ repository, bundle, minCheck, evaluation, organi
     min_check: minCheck,
     findings: evaluation.findings,
     executions: evaluation.modules,
+    checked_descriptions: checkedDescriptions(evaluation.modules, bundle),
     matcher_diagnostics: evaluation.matcherDiagnostics || [],
     proof,
     signed_evidence: signedEvidence,
@@ -228,7 +233,15 @@ async function buildFullCheck({ repository, bundle, minCheck, evaluation, organi
 }
 
 function toLegacyCheck(minCheck, loaded) {
-  return { status: "checked", mode: "min", repository: minCheck.repository_identity.repository, base_ref: minCheck.repository_identity.base_ref, source: loaded.source, warnings: [...loaded.warnings, ...(minCheck.warnings || [])], bundle: minCheck.knowledge_bundle, findings: minCheck.preliminary_findings, min_check: minCheck };
+  return { status: "checked", mode: "min", repository: minCheck.repository_identity.repository, base_ref: minCheck.repository_identity.base_ref, source: loaded.source, checked_descriptions: checkedDescriptions(minCheck.matched_modules, loaded.bundle), warnings: [...loaded.warnings, ...(minCheck.warnings || [])], bundle: minCheck.knowledge_bundle, findings: minCheck.preliminary_findings, min_check: minCheck };
+}
+
+// Display descriptions come from the verified knowledge bundle. They are
+// separate from the signed proof/min-check contract and never certify coverage.
+function checkedDescriptions(executions, bundle) {
+  const matched = new Set(executions.map(module => module.module_id));
+  return (bundle.modules || []).filter(module => matched.has(module.module_id || module.id))
+    .map(module => module.invariant?.statement).filter(value => typeof value === 'string');
 }
 
 function bundleIdentity(bundle) {