@awak-app/simy-cli 0.7.37 → 0.7.39

package/src/session-supervision/acceptance-reads.js

@@ -6,7 +6,8 @@ import { evidenceExcerpt } from '../codex-plugins/simy/hooks/purpose-evidence.mj
 
 // Read only original file predicates in the authorized task directory. These
 // are current independent controller reads, not worker claims or authored proof.
-export async function captureAcceptanceReads(cwd, criteria, { signal } = {}) {
+export async function captureAcceptanceReads(cwd, criteria, { signal, excerptLimit = 4000, publicTaskSourcePaths = [] } = {}) {
+  if (!Number.isSafeInteger(excerptLimit) || excerptLimit < 1 || excerptLimit > 32768) throw new Error('Acceptance excerpt bound is invalid.');
   const root = await realpath(cwd), rows = [], seen = new Set(); let retained = 0;
   for (const criterion of criteria) {
     signal?.throwIfAborted();
@@ -22,8 +23,16 @@ export async function captureAcceptanceReads(cwd, criteria, { signal } = {}) {
       if (bytesRead > 32768) continue;
       const body = data.subarray(0, bytesRead); retained += bytesRead;
       const digest = createHash('sha256').update(body).digest('hex');
+      // Host-only, explicit source-read permission for a native task reviewer.
+      // The same original Claude already has Read access to these public-task
+      // source paths. Business identifiers such as Token are source, not a
+      // credential claim. Generic artifact reads retain their redaction policy.
+      const sourceRead = publicTaskSourcePaths.some(file => resolve(root, file) === path);
+      const sourceText = bytesRead ? body.toString('utf8') : JSON.stringify({ byteLength: 0, content: '' });
+      const observation = sourceRead ? { text: sourceText.slice(0, excerptLimit), truncated: sourceText.length > excerptLimit,
+        redacted: false, policy: 'host_authorized_public_task_source' } : evidenceExcerpt(sourceText, excerptLimit);
       rows.push({ id: `file:${target}`, source: 'controller_file_read', status: 'observed', at: Date.now(), digest,
-        recipe: { type: 'file_read', path: target }, observation: evidenceExcerpt(bytesRead ? body.toString('utf8') : JSON.stringify({ byteLength: 0, content: '' }), 4000) });
+        recipe: { type: 'file_read', path: target }, observation });
     } catch { signal?.throwIfAborted(); /* Missing/large/unreadable files stay unverified; tool investigation remains available. */ }
     finally { await handle?.close(); }
   }

package/src/session-supervision/analysis-manager.js

@@ -4,6 +4,7 @@ import { lstat, mkdir, readFile, rename, rm, writeFile } from 'node:fs/promises'
 import { join } from 'node:path';
 import { analyzeContinuation, CONTINUATION_ANALYSIS_VERSION } from './continuation-analysis.js';
 import { providerGoalEvidence } from './conversation-context.js';
+import { liveSessionWindow, supervisedSession } from './discovery-window.js';
 
 const BACKFILL_LIMIT = 10;
 const MAX_CACHE_ENTRIES = 2000;
@@ -276,11 +277,17 @@ export async function createContinuationAnalysisManager({ root, analyze = analyz
       });
       startDrain();
     },
-    async update(sessions) {
+    async update(sessions, { priorityKeys = new Set() } = {}) {
       await exclusive(async () => {
         if (closed || suspended) return;
+        // The complete catalog remains navigable. Historical metadata outside
+        // this window must not churn the bounded cache or schedule paid work.
+        // Preserve queued/manual jobs and explicitly supervised conversations;
+        // removal, changed authority and OFF still use the incoming snapshot.
+        const window = liveSessionWindow(sessions, { priority: candidate => priorityKeys.has(keyOf(candidate)) || supervisedSession(candidate) ||
+          jobs.has(keyOf(candidate)) || ['queued', 'analyzing'].includes(entries.get(keyOf(candidate))?.result?.state) });
         candidates.clear();
-        for (const candidate of sessions) candidates.set(keyOf(candidate), observedCandidate(candidate));
+        for (const candidate of window) candidates.set(keyOf(candidate), observedCandidate(candidate));
         const sorted = [...candidates.values()].sort((a, b) => activityOf(b) - activityOf(a) || keyOf(a).localeCompare(keyOf(b)));
         const backfill = document.initialized ? new Set() : new Set(sorted.slice(0, BACKFILL_LIMIT).map(keyOf));
         let dirty = !document.initialized;

package/src/session-supervision/catalog-refresh.js

@@ -0,0 +1,16 @@
+// History is a navigation index, not a real-time subscription. Keep ordinary
+// status/preference refreshes cheap; an explicit Refresh still reloads history.
+export function createCatalogRefreshPolicy({ now = Date.now, intervalMs = 300_000 } = {}) {
+  let completed = null, scope = null, revision = 0;
+  return {
+    invalidate() { completed = null; revision++; },
+    begin(nextScope) {
+      if (scope !== nextScope) { scope = nextScope; completed = null; revision++; }
+      const generation = revision;
+      const recentOnly = completed !== null && now() - completed < intervalMs;
+      return { recentOnly, complete(success) {
+        if (!recentOnly && success && generation === revision) completed = now();
+      } };
+    },
+  };
+}

package/src/session-supervision/claude-native-agent-contract.js

@@ -0,0 +1,62 @@
+import { isDeepStrictEqual } from 'node:util';
+
+// Observed foreground-only Agent contract. Omission is never evidence of
+// foreground execution when the provider exposes background or unknown options.
+const FOREGROUND_SCHEMA = {
+  $schema: 'https://json-schema.org/draft/2020-12/schema', type: 'object',
+  properties: { description: { type: 'string' }, prompt: { type: 'string' },
+    subagent_type: { type: 'string' }, isolation: { type: 'string', enum: ['worktree', 'remote'] } },
+  required: ['description', 'prompt'], additionalProperties: false,
+};
+const withoutDescriptions = value => Array.isArray(value) ? value.map(withoutDescriptions) :
+  value && typeof value === 'object' ? Object.fromEntries(Object.entries(value)
+    .filter(([key, item]) => key !== 'description' || typeof item !== 'string')
+    .map(([key, item]) => [key, withoutDescriptions(item)])) : value;
+
+export function isForegroundOnlyAgentSchema(schema) {
+  return isDeepStrictEqual(withoutDescriptions(schema), FOREGROUND_SCHEMA);
+}
+
+export function isForegroundNativeReviewInput(toolName, args, observedSchema = null) {
+  if (!['Agent', 'Task'].includes(toolName) || !args || typeof args !== 'object' || Array.isArray(args) ||
+      typeof args.prompt !== 'string' || typeof args.subagent_type !== 'string' ||
+      Object.keys(args).some(key => !['description', 'prompt', 'subagent_type', 'run_in_background'].includes(key)) ||
+      Object.hasOwn(args, 'description') && typeof args.description !== 'string') return false;
+  if (Object.hasOwn(args, 'run_in_background')) return args.run_in_background === false;
+  // The observed Agent schema cannot establish an omitted flag for legacy Task.
+  return toolName === 'Agent' && typeof args.description === 'string' && isForegroundOnlyAgentSchema(observedSchema);
+}
+
+// Callers supply rows read from the exact owned, stable parent transcript,
+// never a worker-provided schema. A schema first seen after the call proves nothing.
+export function foregroundAgentContract(rows, candidate, beforeIndex = rows.length) {
+  const collector = createForegroundAgentContractCollector(candidate);
+  for (const row of rows.slice(0, beforeIndex)) collector.add(row);
+  return collector.finish();
+}
+
+// Keep the prior schema and version agreement without retaining transcript
+// bodies. A snapshot taken before a call cannot be authorized by a later shape.
+export function createForegroundAgentContractCollector(candidate) {
+  let shape = null, shapes = 0, version, mixedVersions = false;
+  return {
+    add(row) {
+      if (row.type === 'api-request-shape') { shapes++; if (shapes === 1) shape = row; }
+      if (row.version !== undefined) {
+        mixedVersions ||= version !== undefined && version !== row.version;
+        version = row.version;
+      }
+    },
+    finish() {
+      const row = shape;
+      if (shapes !== 1 || mixedVersions || version !== row.version || row.sessionId !== candidate.session || row.isSidechain === true ||
+          row.cwd !== undefined && row.cwd !== candidate.cwd ||
+          !/^[a-f0-9]{64}$/.test(row.shapeHash || '') || !/^\d+\.\d+\.\d+$/.test(row.version || '') ||
+          !Array.isArray(row.shape?.tools)) return null;
+      const agents = row.shape.tools.filter(tool => tool.name === 'Agent');
+      if (agents.length !== 1 || !isForegroundOnlyAgentSchema(agents[0].input_schema)) return null;
+      return { schema: agents[0].input_schema, shapeHash: row.shapeHash,
+        session: candidate.session, cwd: candidate.cwd, version: row.version ?? null };
+    },
+  };
+}

package/src/session-supervision/claude-outcome-review.js

@@ -7,7 +7,7 @@ import { basename, relative, resolve } from 'node:path';
 import { runStructuredProviderReview } from '../sqm/review-worker.js';
 import { captureAcceptanceReads } from './acceptance-reads.js';
 import { readClaudeConversation, readClaudeNativeReview } from './claude-sessions.js';
-import { independentRequestContext, workspaceIdentity } from './purpose-verification.js';
+import { independentReviewRequestContext, workspaceIdentity } from './purpose-verification.js';
 import { effectiveAcceptanceCriteria } from '../codex-plugins/simy/hooks/acceptance-policy.mjs';
 import { liveOutcomeReviewEligible, settleLiveOutcomeReview, readRecord, taskDirectory, hasPendingUserStop, providerLinkState, processIdentity } from '../codex-plugins/simy/hooks/delivery-loop.mjs';
 
@@ -52,7 +52,7 @@ export async function claudeReviewBudgetBoundary(record, { platform = process.pl
 // original Claude process waits for its CLI child and retains its writer lease.
 // No second controller/session resumes or writes the task workspace.
 export async function reviewClaudeCheckpoint(record, { root, review = runStructuredProviderReview,
-  readContext = readClaudeConversation, readNativeReview = readClaudeNativeReview, onFailure = () => {}, captureReads = captureAcceptanceReads, inspectBudget = claudeReviewBudgetBoundary, signal, executionTimeoutMs = 120000 } = {}) {
+  readContext = readClaudeConversation, readNativeReview = readClaudeNativeReview, onFailure = () => {}, captureReads = captureAcceptanceReads, fingerprintWorkspace = workspaceIdentity, inspectBudget = claudeReviewBudgetBoundary, signal, executionTimeoutMs = 120000 } = {}) {
   if (!liveOutcomeReviewEligible(record)) return record;
   const snapshot = structuredClone(record), cwd = taskDirectory(record), criteria = effectiveAcceptanceCriteria(record.run.managed);
   const abort = new AbortController();
@@ -77,17 +77,18 @@ export async function reviewClaudeCheckpoint(record, { root, review = runStructu
         summary: 'Independent review was not dispatched: the original Claude process budget arguments could not be verified. Acceptance remains unverified; inspect the original launch configuration without changing its budget.',
         findings: [], source: 'controller_review_unavailable', checkedAt: Date.now() } });
     const inventory = [];
-    const before = await workspaceIdentity(cwd, undefined, inventory, { signal: combined, inventoryLimit: 1000 });
+    const before = await fingerprintWorkspace(cwd, undefined, inventory, { signal: combined, inventoryLimit: 1000 });
     const reads = await captureReads(cwd, criteria, { signal: combined });
     // This executor cannot independently inspect unnamed artifacts or services.
     // Never turn absent/truncated input into a successful semantic judgment.
     if (!reads.length || reads.some(row => row.observation.truncated || row.observation.redacted)) return await unavailable('Current outcome observations are absent or incomplete.');
     if (reads.some(row => !inventory.some(file => file.type === 'file' && file.path === relative(cwd, resolve(cwd, row.recipe.path)) && file.digest === row.digest)))
       return await unavailable('Controller observations do not match the reviewed workspace revision; reread the actual outcome.');
-    const context = await readContext(record, { signal: combined, userOnly: true });
+    const context = await readContext(record, { signal: combined, userOnly: true, reviewUserContext: true });
     if (!context?.messages?.some(row => row.role === 'user') || context.incomplete || context.truncated) return await unavailable('Original user context could not be read completely; inspect the original request before retrying review.');
     if (!await current()) return await readRecord(root, record.provider, record.session);
-    const requests = independentRequestContext(context);
+    const requests = independentReviewRequestContext(context);
+    if (requests.incomplete || requests.truncated || requests.redacted) return await unavailable('Original user requests exceed complete review coverage or contain redacted context; acceptance remains unverified.');
     if (budget === 'worker_cap' || budget === 'native_only') {
       const contextDigest = createHash('sha256').update(JSON.stringify(requests.messages.filter(row => row.text?.trim()))).digest('hex');
       const pending = record.run.managed.nativeOutcomeReview;
@@ -111,7 +112,7 @@ export async function reviewClaudeCheckpoint(record, { root, review = runStructu
     }
     const result = await review('claude', {
       system: CLAUDE_REVIEW_SYSTEM,
-      prompt: JSON.stringify({ objective: record.run.objective, requests: independentRequestContext(context), criteria, workspaceInventory: { paths: inventory.map(row => row.path), truncated: inventory.truncated === true }, observations: reads }),
+      prompt: JSON.stringify({ objective: record.run.objective, requests, criteria, workspaceInventory: { paths: inventory.map(row => row.path), truncated: inventory.truncated === true }, observations: reads }),
       output_schema: CLAUDE_REVIEW_SCHEMA
     }, { signal: combined, executionTimeoutMs, subscriptionOnly: true, beforeDispatch: async () => {
       if (!await current()) throw new Error('Review target changed');

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

@@ -5,7 +5,8 @@ import { lstat, open, readdir, realpath } from 'node:fs/promises';
 import { homedir } from 'node:os';
 import { createHash } from 'node:crypto';
 import { isAbsolute, join, relative, resolve, sep } from 'node:path';
-import { boundConversation, CONVERSATION_LIMITS, textContent } from './conversation-context.js';
+import { boundConversation, CONVERSATION_LIMITS, createConversationCollector, textContent } from './conversation-context.js';
+import { createForegroundAgentContractCollector, isForegroundNativeReviewInput } from './claude-native-agent-contract.js';
 import { sessionTitle } from './session-titles.js';
 import { RECENT_SESSION_LIMIT, recentSessionWindow } from './discovery-window.js';
 import { observeClaudeDesktopLineage, readClaudeDesktopLineage } from './claude-desktop-lineage.js';
@@ -152,7 +153,8 @@ async function inspectTranscript(root, projectName, fileName, observedAt, includ
     const candidate = candidateMetadata(id, metadata, opened.mtimeMs, observedAt);
     signal?.throwIfAborted();
     if (includeStatistics) candidate.statistics = await statisticsFromHandle(handle, opened, 'claude', id, { signal });
-    if (includeContext) candidate.context = await conversationFromHandle(handle, opened, id, metadata.cwd, includeContext === 'user');
+    if (includeContext) candidate.context = await conversationFromHandle(handle, opened, id, metadata.cwd, {
+      userOnly: ['user', 'review_user'].includes(includeContext), reviewUserContext: includeContext === 'review_user', signal });
     if (humanRequest) candidate.humanBoundary = await humanBoundaryFromHandle(handle, opened, path, id, metadata.cwd, humanRequest, signal);
     if (includeBoundary) {
       candidate.transcriptPath = path;
@@ -309,29 +311,47 @@ const humanFileFingerprint = info => humanFileIdentity(info) === null ? null : c
 // cooperative cancellation, exact byte offsets and a digest of every read byte.
 // Whole-history and human-cursor readers retain their separate semantics.
 async function scanTranscriptLines(handle, opened, { maxBytes, maxLineBytes = 4 * 1024 * 1024,
-  maxRows = 250000, signal, onLine, onChunk = () => {} }) {
-  if (!opened.size || opened.size > maxBytes) return null;
+  maxRows = 250000, start = 0, allowIncomplete = false, signal, onLine, onChunk = () => {} }) {
+  if (!opened.size || opened.size - start > maxBytes) return null;
   const hash = createHash('sha256'), buffer = Buffer.alloc(64 * 1024);
-  let offset = 0, pending = Buffer.alloc(0), rows = 0, lineOffset = 0;
+  let offset = start, fragments = [], pendingBytes = 0, rows = 0, lineOffset = start, discard = start > 0, incomplete = false;
   while (offset < opened.size) {
     signal?.throwIfAborted();
     const { bytesRead } = await handle.read(buffer, 0, Math.min(buffer.length, opened.size - offset), offset);
     if (!bytesRead) return null;
-    const chunk = buffer.subarray(0, bytesRead);
+    let chunk = buffer.subarray(0, bytesRead);
     hash.update(chunk); onChunk(chunk, offset); offset += bytesRead;
-    pending = Buffer.concat([pending, chunk]);
-    let newline;
-    while ((newline = pending.indexOf(10)) !== -1) {
+    if (discard) {
+      const end = chunk.indexOf(10);
+      if (end === -1) continue;
+      chunk = chunk.subarray(end + 1); lineOffset = offset - chunk.length; discard = false;
+    }
+    let position = 0;
+    while (position < chunk.length) {
       signal?.throwIfAborted();
-      if (newline > maxLineBytes || ++rows > maxRows) return null;
-      const line = pending.subarray(0, newline), start = lineOffset;
-      pending = pending.subarray(newline + 1); lineOffset += newline + 1;
-      if (line.length && onLine(line, start) === false) return null;
+      const newline = chunk.indexOf(10, position);
+      const part = chunk.subarray(position, newline === -1 ? chunk.length : newline);
+      const length = pendingBytes + part.length;
+      if (length > maxLineBytes) {
+        if (!allowIncomplete) return null;
+        incomplete = true; fragments = []; pendingBytes = 0;
+        if (newline === -1) { discard = true; break; }
+      } else if (newline === -1) {
+        // Copy only fragments crossing reads; concatenate once at the newline.
+        // Repeatedly concatenating a multi-MiB line made scanning quadratic.
+        fragments.push(Buffer.from(part)); pendingBytes = length;
+        break;
+      } else {
+        if (++rows > maxRows) return null;
+        const line = fragments.length ? Buffer.concat([...fragments, part], length) : part;
+        fragments = []; pendingBytes = 0;
+        if (line.length && onLine(line, lineOffset, rows - 1) === false) return null;
+      }
+      position = newline + 1; lineOffset = offset - chunk.length + position;
     }
-    if (pending.length > maxLineBytes) return null;
   }
-  if (pending.length) return null;
-  return { digest: hash.digest('hex'), byteLength: offset, rows };
+  if (pendingBytes) { if (!allowIncomplete) return null; incomplete = true; }
+  return { digest: hash.digest('hex'), byteLength: offset, rows, incomplete };
 }
 
 async function humanBoundaryFromHandle(handle, opened, path, session, cwd, request, signal) {
@@ -410,42 +430,42 @@ export function unchangedClaudeHumanBoundary(proof) {
   } catch { return false; }
 }
 
-async function conversationFromHandle(handle, opened, session, cwd, userOnly = false) {
+async function conversationFromHandle(handle, opened, session, cwd, { userOnly = false, reviewUserContext = false, signal } = {}) {
   // Native review receipts can make a short user conversation exceed the usual
   // display tail. Bound the file separately and filter before bounding prose.
   const bytes = userOnly ? 64 * 1024 * 1024 : CONVERSATION_LIMITS.bytes;
   const offset = Math.max(0, opened.size - bytes);
-  const buffer = Buffer.alloc(Math.min(opened.size, bytes));
-  const { bytesRead } = await handle.read(buffer, 0, buffer.length, offset);
-  let text = buffer.subarray(0, bytesRead).toString('utf8');
-  if (offset) text = text.slice(text.indexOf('\n') + 1);
-  const messages = [];
-  let incomplete = !text.endsWith('\n');
-  const lines = text.split('\n');
-  for (const [index, line] of lines.entries()) {
-    if (!line.trim()) continue;
-    let item;
-    try { item = JSON.parse(line); } catch { incomplete = true; continue; }
-    if (unscopedFileHistory(item)) continue;
-    if (item.sessionId !== session || item.isSidechain === true) { incomplete = true; continue; }
-    if (!['user', 'assistant'].includes(item.type) || item.isMeta === true) continue;
-    if (typeof item.cwd !== 'string' || !isAbsolute(item.cwd) || !within(cwd, resolve(item.cwd))) { incomplete = true; continue; }
-    const text = textContent(item.message?.content);
-    // User tool_result envelopes are not a new human request. A missing
-    // human message/attachment-only request cannot silently reuse an old goal.
-    if (item.type === 'user' && !text.trim() && !item.message?.content?.every?.(part => part?.type === 'tool_result')) incomplete = true;
-    if (userOnly && item.type !== 'user') continue;
-    messages.push({ role: item.type, turnRef: typeof item.uuid === 'string' ? item.uuid : `line:${offset}:${index}`, text });
-  }
+  const collector = createConversationCollector({ reviewUserContext });
+  let incomplete = false;
+  const scanned = await scanTranscriptLines(handle, opened, { start: offset, maxBytes: bytes, maxLineBytes: bytes, maxRows: Infinity, allowIncomplete: true, signal,
+    onLine(line, start, index) {
+      const encoded = line.toString('utf8');
+      if (!encoded.trim()) return;
+      let item;
+      try { item = JSON.parse(encoded); } catch { incomplete = true; return; }
+      if (unscopedFileHistory(item)) return;
+      if (item.sessionId !== session || item.isSidechain === true) { incomplete = true; return; }
+      if (!['user', 'assistant'].includes(item.type) || item.isMeta === true) return;
+      if (typeof item.cwd !== 'string' || !isAbsolute(item.cwd) || !within(cwd, resolve(item.cwd))) { incomplete = true; return; }
+      const text = textContent(item.message?.content);
+      // User tool_result envelopes are not a new human request. A missing
+      // human message/attachment-only request cannot silently reuse an old goal.
+      if (item.type === 'user' && !text.trim() && !item.message?.content?.every?.(part => part?.type === 'tool_result')) incomplete = true;
+      if (reviewUserContext && item.type === 'user' && Array.isArray(item.message?.content) &&
+          item.message.content.some(part => !['text', 'input_text', 'output_text', 'tool_result'].includes(part?.type))) incomplete = true;
+      if (userOnly && item.type !== 'user') return;
+      collector.add({ role: item.type, turnRef: typeof item.uuid === 'string' ? item.uuid : `line:${offset}:${index}`, text });
+  } });
   const after = await handle.stat();
-  if (after.size !== opened.size || after.mtimeMs !== opened.mtimeMs) incomplete = true;
-  return boundConversation(messages, { truncated: offset > 0, incomplete });
+  if (!scanned || scanned.incomplete || after.size !== opened.size || after.mtimeMs !== opened.mtimeMs || after.ctimeMs !== opened.ctimeMs) incomplete = true;
+  return collector.finish({ truncated: offset > 0, incomplete });
 }
 
-export async function readClaudeConversation(candidate, { home, signal, userOnly = false } = {}) {
+export async function readClaudeConversation(candidate, { home, signal, userOnly = false, reviewUserContext = false } = {}) {
+  if (reviewUserContext && !userOnly) throw new Error('Review context must contain only original user requests.');
   if (signal?.aborted) return boundConversation(null);
   if (!UUID.test(candidate?.session || '') || typeof candidate?.cwd !== 'string') return boundConversation(null);
-  const matches = await collect({ home, session: candidate.session, includeContext: userOnly ? 'user' : true, signal });
+  const matches = await collect({ home, session: candidate.session, includeContext: reviewUserContext ? 'review_user' : userOnly ? 'user' : true, signal });
   const selected = matches.filter(item => item.cwd === candidate.cwd);
   if (signal?.aborted || selected.length !== 1) return boundConversation(null);
   if (Number.isFinite(candidate.lastActivityAt) && selected[0].lastActivityAt !== candidate.lastActivityAt) {
@@ -497,49 +517,90 @@ export async function readClaudeStatistics(candidate, { home, signal } = {}) {
 // Consume only an exact native Agent invocation in the original session. A
 // worker checkpoint, forwarded quote, resumed child or tool-using child is not
 // an independent verdict. Native Claude accounts this child in its own budget.
-export async function readClaudeNativeReview(candidate, request, { home, signal } = {}) {
+async function scanNativeRows(path, visit, { signal, expectedDigest } = {}) {
+  signal?.throwIfAborted();
+  if (await realpath(path) !== path) throw new Error('Native transcript link changed');
+  const handle = await open(path, constants.O_RDONLY | (constants.O_NOFOLLOW || 0));
+  try {
+    const before = await handle.stat();
+    if (!before.isFile()) throw new Error('Native transcript unavailable');
+    const decoder = new TextDecoder('utf-8', { fatal: true });
+    const scanned = await scanTranscriptLines(handle, before, { maxBytes: MAX_COMPLETE_TRANSCRIPT_BYTES, signal,
+      onLine: line => visit(JSON.parse(decoder.decode(line))) });
+    const after = await handle.stat();
+    const pathAfter = await lstat(path);
+    if (await realpath(path) !== path || pathAfter.isSymbolicLink() || pathAfter.ino !== before.ino || pathAfter.dev !== before.dev ||
+        before.size !== after.size || before.mtimeMs !== after.mtimeMs || before.ctimeMs !== after.ctimeMs ||
+        pathAfter.size !== before.size || pathAfter.mtimeMs !== before.mtimeMs || pathAfter.ctimeMs !== before.ctimeMs || !scanned ||
+        expectedDigest && scanned.digest !== expectedDigest) throw new Error('Native transcript changed');
+    return { snapshot: [before.dev, before.ino, before.size, before.mtimeMs, before.ctimeMs].join(':'), digest: scanned.digest };
+  } finally { await handle.close(); }
+}
+
+async function nativeParentTranscript(candidate, { home, signal }, visit) {
   const matches = (await collect({ home, session: candidate.session, includeBoundary: true, signal }))
     .filter(row => row.cwd === candidate.cwd && row.boundary?.complete);
   if (matches.length !== 1) return null;
   const parentPath = matches[0].transcriptPath;
-  const readRows = async path => {
-    signal?.throwIfAborted();
-    if (await realpath(path) !== path) throw new Error('Native transcript link changed');
-    const handle = await open(path, constants.O_RDONLY | (constants.O_NOFOLLOW || 0));
-    try {
-      const before = await handle.stat();
-      if (!before.isFile() || before.size > 64 * 1024 * 1024) throw new Error('Native transcript unavailable');
-      const bytes = await handle.readFile('utf8'), after = await handle.stat();
-      const pathAfter = await lstat(path);
-      if (await realpath(path) !== path || pathAfter.isSymbolicLink() || pathAfter.ino !== before.ino || pathAfter.dev !== before.dev ||
-          before.size !== after.size || before.mtimeMs !== after.mtimeMs || before.ctimeMs !== after.ctimeMs || !bytes.endsWith('\n')) throw new Error('Native transcript changed');
-      return bytes.trim().split('\n').map(line => JSON.parse(line));
-    } finally { await handle.close(); }
-  };
+  const scanned = await scanNativeRows(parentPath, row => {
+    if (row.sessionId !== undefined && row.sessionId !== candidate.session ||
+        ['user', 'assistant'].includes(row.type) && (row.isSidechain === true || row.cwd !== candidate.cwd)) return false;
+    return visit(row);
+  }, { signal, expectedDigest: matches[0].boundary.digest });
+  return { parentPath, ...scanned };
+}
+
+export async function readClaudeNativeAgentContract(candidate, { home, signal } = {}) {
+  try {
+    const collector = createForegroundAgentContractCollector(candidate);
+    const parent = await nativeParentTranscript(candidate, { home, signal }, row => collector.add(row));
+    return parent ? collector.finish() : null;
+  } catch (error) { if (signal?.aborted) throw error; return null; }
+}
+
+export async function readClaudeNativeReview(candidate, request, { home, signal } = {}) {
   try {
-    const rows = await readRows(parentPath);
-    const calls = rows.filter(row => row.sessionId === candidate.session && !row.isSidechain && row.type === 'assistant' && Date.parse(row.timestamp) >= request.requestedAt)
-      .flatMap(row => (row.message?.content || []).filter(part => part.type === 'tool_use' && ['Agent', 'Task'].includes(part.name) && part.input?.prompt === request.prompt));
-    if (calls.length !== 1) return null;
-    const call = calls[0];
-    if (call.input.subagent_type !== request.agentType || call.input.run_in_background !== false ||
-        Object.keys(call.input).some(key => !['description', 'prompt', 'subagent_type', 'run_in_background'].includes(key))) return null;
-    const receipts = rows.filter(row => row.sessionId === candidate.session && !row.isSidechain && row.type === 'user' &&
-      row.message?.content?.some?.(part => part.type === 'tool_result' && part.tool_use_id === call.id) && row.toolUseResult);
+    const calls = [], contracts = createForegroundAgentContractCollector(candidate);
+    const parent = await nativeParentTranscript(candidate, { home, signal }, row => {
+      if (row.sessionId === candidate.session && !row.isSidechain && row.type === 'assistant' && Date.parse(row.timestamp) >= request.requestedAt) {
+        for (const part of row.message?.content || []) {
+          if (part.type === 'tool_use' && ['Agent', 'Task'].includes(part.name) && part.input?.prompt === request.prompt)
+            calls.push({ call: part, contract: contracts.finish() });
+          if (calls.length > 1) return false;
+        }
+      }
+      contracts.add(row);
+    });
+    if (!parent || calls.length !== 1) return null;
+    const { parentPath } = parent, { call, contract } = calls[0];
+    if (call.input.subagent_type !== request.agentType || !isForegroundNativeReviewInput(call.name, call.input, contract?.schema)) return null;
+    const receipts = [];
+    const receiptScan = await scanNativeRows(parentPath, row => {
+      if (row.sessionId === candidate.session && !row.isSidechain && row.type === 'user' &&
+          row.message?.content?.some?.(part => part.type === 'tool_result' && part.tool_use_id === call.id) && row.toolUseResult) receipts.push(row);
+      if (receipts.length > 1) return false;
+    }, { signal, expectedDigest: parent.digest });
+    if (receiptScan.snapshot !== parent.snapshot) return null;
     if (receipts.length !== 1) return null;
     const result = receipts[0].toolUseResult;
     if (result.status !== 'completed' || result.prompt !== request.prompt || result.agentType !== request.agentType ||
         result.totalToolUseCount !== 0 || !/^a[a-f0-9]{8,40}$/.test(result.agentId || '')) return null;
     const childPath = join(parentPath.slice(0, -6), 'subagents', `agent-${result.agentId}.jsonl`);
-    const child = await readRows(childPath);
-    if (child.some(row => row.sessionId !== candidate.session || row.agentId !== result.agentId || ['user', 'assistant', 'attachment'].includes(row.type) && row.isSidechain !== true)) return null;
-    const users = child.filter(row => row.type === 'user');
-    const snapshots = child.filter(row => row.attachment?.type === 'prompt_snapshot').map(row => row.attachment);
-    if (users.length !== 1 || textContent(users[0].message?.content) !== request.prompt ||
-        !snapshots.some(row => Array.isArray(row.tools) && row.tools.length === 0) || snapshots.some(row => row.tools && row.tools.length !== 0 || !row.systemPrompt?.some(text => text.trim() === CLAUDE_NATIVE_REVIEW_PROMPT))) return null;
-    const answers = child.filter(row => row.type === 'assistant');
-    if (!answers.length || answers.some(row => row.message?.content?.some(part => part.type === 'tool_use'))) return null;
-    const answer = textContent(answers.at(-1).message?.content);
+    let users = 0, answer = null, emptyTools = false;
+    await scanNativeRows(childPath, row => {
+      if (row.sessionId !== candidate.session || row.agentId !== result.agentId || ['user', 'assistant', 'attachment'].includes(row.type) && row.isSidechain !== true) return false;
+      if (row.type === 'user' && (++users !== 1 || textContent(row.message?.content) !== request.prompt)) return false;
+      if (row.attachment?.type === 'prompt_snapshot') {
+        const snapshot = row.attachment;
+        if (snapshot.tools && snapshot.tools.length !== 0 || !snapshot.systemPrompt?.some(text => text.trim() === CLAUDE_NATIVE_REVIEW_PROMPT)) return false;
+        emptyTools ||= Array.isArray(snapshot.tools) && snapshot.tools.length === 0;
+      }
+      if (row.type === 'assistant') {
+        if (row.message?.content?.some?.(part => part.type === 'tool_use')) return false;
+        answer = textContent(row.message?.content);
+      }
+    }, { signal });
+    if (users !== 1 || !emptyTools || answer === null) return null;
     if (answer !== textContent(result.content)) return null;
     const output = JSON.parse(answer.trim().replace(/^```(?:json)?\s*\n([\s\S]*?)\n```$/, '$1'));
     if (typeof output.passed !== 'boolean' || typeof output.inspectionAvailable !== 'boolean' || typeof output.summary !== 'string' || output.summary.length > 4000 ||

package/src/session-supervision/codex-app-server.js

@@ -28,7 +28,7 @@ import { CODEX_WRITER_LOCK_MINIMUM_VERSION, compareVersions, inspectBackendExecu
 import { hasPendingUserStop, readRecord, recordPath, rootDirectory, canExecuteAutonomousExternal, assessedCheckpointContract, deliveryProgressContext, manualAcceptanceFeedback, manualAcceptanceFeedbackInstruction, taskDirectory, understandingCheckpointContract } from '../codex-plugins/simy/hooks/delivery-loop.mjs';
 import { boundConversation, boundProviderGoal, textContent } from './conversation-context.js';
 import { JsonDataUrlFilter } from './json-data-url-filter.js';
-import { RECENT_SESSION_LIMIT } from './discovery-window.js';
+import { RECENT_SESSION_LIMIT, liveSessionWindow } from './discovery-window.js';
 
 const REQUEST_TIMEOUT = 15_000;
 const MAX_LINE = 256 * 1024;
@@ -307,7 +307,7 @@ export async function listCodexSessions({ client, all = false, signal, onPage, m
     // reports notLoaded rather than the original writer's actual turn state.
     // Bound this metadata fan-out independently of the analysis worker pool.
     const priorities = new Set(prioritySessions);
-    const ordered = [...sessions].sort((a, b) => Number(priorities.has(b.session)) - Number(priorities.has(a.session)) || (b.lastActivityAt || 0) - (a.lastActivityAt || 0));
+    const ordered = liveSessionWindow(sessions, { priority: item => priorities.has(item.session) });
     let next = 0, unavailable = false;
     for (const metadata of sessions) metadata.goalReadState = 'unavailable';
     await Promise.all(Array.from({ length: Math.min(3, sessions.length) }, async () => {
@@ -355,7 +355,7 @@ export async function readCodexArchiveStates(client, candidates, { budgetMs = 30
   const offset = (archiveProbeOffsets.get(codexHome) || 0) % Math.max(1, missing.length);
   let next = 0;
   await Promise.all(Array.from({ length: Math.min(3, missing.length) }, async () => {
-    while (next < missing.length && Date.now() < deadline) {
+    while (next < Math.min(missing.length, RECENT_SESSION_LIMIT) && Date.now() < deadline) {
       const candidate = missing[(offset + next++) % missing.length];
       try {
         const response = await boundedClient.request('thread/read', { threadId: candidate.session, includeTurns: false });

package/src/session-supervision/codex-children.js

@@ -23,14 +23,14 @@ export async function readCodexChildSessions({ parents = [], includeArchived = f
     db = new DatabaseSync(path, { readOnly: true });
     db.exec('PRAGMA query_only = ON; PRAGMA busy_timeout = 50');
     const rows = db.prepare(`WITH RECURSIVE family(id, depth) AS (
-      SELECT id, 0 FROM threads WHERE id IN (${roots.map(() => '?').join(',')})
+      SELECT id, 0 FROM threads WHERE id IN (SELECT value FROM json_each(?))
       UNION SELECT e.child_thread_id, f.depth + 1 FROM thread_spawn_edges e
         JOIN family f ON f.id = e.parent_thread_id WHERE f.depth < 32
     ) SELECT t.id, t.cwd, t.name, t.source, t.model, t.updated_at, t.archived,
         e.parent_thread_id, MIN(f.depth) AS depth
       FROM family f JOIN threads t ON t.id = f.id
       JOIN thread_spawn_edges e ON e.child_thread_id = t.id
-      WHERE f.depth > 0 GROUP BY t.id ORDER BY depth, t.updated_at DESC LIMIT 2000`).all(...roots);
+      WHERE f.depth > 0 GROUP BY t.id ORDER BY depth, t.updated_at DESC LIMIT 2000`).all(JSON.stringify(roots));
     const candidates = [];
     for (const row of rows) {
       let source;