@awak-app/simy-cli 0.7.37 → 0.7.38

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;

package/src/session-supervision/conversation-context.js

@@ -1,6 +1,8 @@
 // Only human/assistant prose crosses the analysis boundary. Tool payloads,
 // attachments, paths and provider envelopes are deliberately excluded.
 export const CONVERSATION_LIMITS = Object.freeze({ messages: 32, text: 4_000, total: 24_000, bytes: 512 * 1024 });
+// Independent review preserves complete original requests within its own budget.
+export const REVIEW_USER_CONTEXT_LIMITS = Object.freeze({ messages: 32, text: 64 * 1024, total: 128 * 1024 });
 const CREDENTIAL_KEY = 'api[_ -]?key|access[_ -]?token|password|authorization';
 const QUOTED_CREDENTIAL = new RegExp(String.raw`(["'])(${CREDENTIAL_KEY})\1(\s*:\s*)(["'])(?:\\.|(?!\4)[^\\])*\4`, 'gi');
 const PLAIN_CREDENTIAL = new RegExp(String.raw`\b(${CREDENTIAL_KEY})\s*[:=]\s*(?:Bearer\s+)?[^\s,;]+`, 'gi');
@@ -41,32 +43,62 @@ export function boundProviderGoal(goal) {
     ...(goal.textTruncated === true || objective.length > 4000 ? { textTruncated: true } : {}) };
 }
 
+// Streaming readers and array callers share one prose-selection policy. Keep
+// the first goal, latest messages and latest-user identity without retaining
+// an entire transcript or sanitizing/trimming an already clipped message twice.
+export function createConversationCollector({ reviewUserContext = false } = {}) {
+  const limits = reviewUserContext ? REVIEW_USER_CONTEXT_LIMITS : CONVERSATION_LIMITS;
+  const prose = [];
+  let count = 0, clipped = false, latestUser = null, foundRedacted = false;
+  return {
+    add(message) {
+      if (!['user', 'assistant'].includes(message?.role) || reviewUserContext && message.role !== 'user') return;
+      const text = sanitizedText(message.text);
+      if (reviewUserContext) {
+        foundRedacted ||= text.includes('[REDACTED]');
+        clipped ||= message.textTruncated === true;
+      }
+      if (!text) return;
+      if (text.length > limits.text) clipped = true;
+      const normalized = { role: message.role, turnRef: sanitizedText(message.turnRef).slice(0, 160) || `message:${count}`,
+        textTruncated: message.textTruncated === true || text.length > limits.text,
+        text: text.slice(0, limits.text) };
+      count++; prose.push(normalized);
+      if (normalized.role === 'user') latestUser = normalized;
+      if (prose.length > limits.messages + 1) prose.splice(1, 1);
+    },
+    finish({ truncated = false, incomplete = false, redacted = false } = {}) {
+      redacted ||= foundRedacted;
+      incomplete ||= reviewUserContext && redacted;
+      truncated ||= clipped || prose.length > limits.messages;
+      // Preserve goal provenance as well as the latest user/assistant exchange.
+      const selected = prose.length > limits.messages ? [prose[0], ...prose.slice(-(limits.messages - 1))] : prose;
+      let total = 0;
+      const result = [];
+      // Spend the bounded budget from newest to oldest; never trim a latest
+      // request to make room for early goal provenance.
+      for (const message of selected.toReversed()) {
+        if (total + message.text.length > limits.total) { truncated = true; continue; }
+        result.unshift(message);
+        total += message.text.length;
+      }
+      const finalMessage = prose.at(-1);
+      if (!latestUser || !result.includes(latestUser) || latestUser.textTruncated || finalMessage?.textTruncated) incomplete = true;
+      return { messages: result.map(({ textTruncated, ...message }) => ({ ...message, ...(textTruncated ? { textTruncated: true } : {}) })), truncated, incomplete, ...(reviewUserContext ? { redacted } : {}) };
+    },
+  };
+}
+
 export function boundConversation(messages, { truncated = false, incomplete = false } = {}) {
   if (!Array.isArray(messages)) return { messages: [], truncated: false, incomplete: true };
-  const prose = [];
-  for (const message of messages) {
-    if (!['user', 'assistant'].includes(message?.role)) continue;
-    const text = sanitizedText(message.text);
-    if (!text) continue;
-    if (text.length > CONVERSATION_LIMITS.text) truncated = true;
-    prose.push({ role: message.role, turnRef: sanitizedText(message.turnRef).slice(0, 160) || `message:${prose.length}`,
-      textTruncated: message.textTruncated === true || text.length > CONVERSATION_LIMITS.text,
-      text: text.slice(0, CONVERSATION_LIMITS.text) });
-  }
-  if (prose.length > CONVERSATION_LIMITS.messages) truncated = true;
-  // Preserve goal provenance as well as the latest user/assistant exchange.
-  const selected = prose.length > CONVERSATION_LIMITS.messages ? [prose[0], ...prose.slice(-(CONVERSATION_LIMITS.messages - 1))] : prose;
-  let total = 0;
-  const result = [];
-  // Spend the bounded budget from newest to oldest; never trim a latest
-  // request to make room for early goal provenance.
-  for (const message of selected.toReversed()) {
-    if (total + message.text.length > CONVERSATION_LIMITS.total) { truncated = true; continue; }
-    result.unshift(message);
-    total += message.text.length;
-  }
-  const latestUser = prose.findLast(message => message.role === 'user');
-  const finalMessage = prose.at(-1);
-  if (!latestUser || !result.includes(latestUser) || latestUser.textTruncated || finalMessage?.textTruncated) incomplete = true;
-  return { messages: result.map(({ textTruncated, ...message }) => ({ ...message, ...(textTruncated ? { textTruncated: true } : {}) })), truncated, incomplete };
+  const collector = createConversationCollector();
+  for (const message of messages) collector.add(message);
+  return collector.finish({ truncated, incomplete });
+}
+
+export function boundReviewUserContext(messages, { truncated = false, incomplete = false, redacted = false } = {}) {
+  if (!Array.isArray(messages)) return { messages: [], truncated: false, incomplete: true, redacted };
+  const collector = createConversationCollector({ reviewUserContext: true });
+  for (const message of messages) collector.add(message);
+  return collector.finish({ truncated, incomplete, redacted });
 }

package/src/session-supervision/discovery-window.js

@@ -4,14 +4,16 @@ export const RECENT_SESSION_LIMIT = 200;
 
 // Explicit tracking and unsettled work remain visible outside recent history.
 // Completed, untracked records are history, not an unlimited extra catalog.
-export const retainedSession = record => Boolean(record?.listPinned || record?.autoContinue || record?.monitor || record?.tracked ||
+export const supervisedSession = record => Boolean(record?.autoContinue || record?.monitor || record?.tracked ||
   record?.run && !TERMINAL.has(record.run.state));
+export const retainedSession = record => Boolean(record?.listPinned || supervisedSession(record));
 
-export function recentSessionWindow(items, { limit = RECENT_SESSION_LIMIT, priority = () => false } = {}) {
+export function recentSessionWindow(items, { limit = RECENT_SESSION_LIMIT, priority = () => false, includeAncestors = true } = {}) {
   const recent = [...items].sort((a, b) => (b.lastActivityAt || 0) - (a.lastActivityAt || 0) || a.session.localeCompare(b.session));
   const retained = [], history = [];
   for (const item of recent) (priority(item) ? retained : history).push(item);
   const selected = [...retained, ...history.slice(0, Math.max(0, limit - retained.length))];
+  if (!includeAncestors) return selected;
   const byKey = new Map(items.map(item => [`${item.provider}:${item.session}`, item]));
   const included = new Set(selected.map(item => `${item.provider}:${item.session}`));
   // Keep observed ancestors so a recent child does not silently become a root.
@@ -25,3 +27,7 @@ export function recentSessionWindow(items, { limit = RECENT_SESSION_LIMIT, prior
   }
   return selected;
 }
+
+// Tree visibility and navigation pins do not subscribe all ancestors to live
+// work. Explicit supervision and owned jobs are supplied by each caller.
+export const liveSessionWindow = (items, options = {}) => recentSessionWindow(items, { ...options, includeAncestors: false });