@awak-app/simy-cli 0.7.36 → 0.7.38

package/src/desktop-host.js

@@ -1,5 +1,7 @@
 import { createDesktopFrameWriter } from './desktop-frame-writer.js';
 import { boundedDiscovery } from './session-supervision/progressive-discovery.js';
+import { createCatalogRefreshPolicy } from './session-supervision/catalog-refresh.js';
+import { supervisedSession } from './session-supervision/discovery-window.js';
 import { createClaudeDesktopArchiveController } from './session-supervision/claude-desktop-archive.js';
 import { createClaudeDesktopNativeAdapter } from './session-supervision/claude-desktop-native.js';
 import { applyControllerExecutionContext } from './session-supervision/execution-context.js';
@@ -118,9 +120,9 @@ function desktopActionError(action, error) {
     const messages = {
       session_workspace_changed: "The conversation workspace changed. Refresh and select it again.",
       session_metadata_unavailable: "Conversation details are unavailable. Refresh this provider and select the conversation again.",
-      session_model_unavailable: "This provider did not expose the conversation model; automatic continuation is unavailable.",
+      session_model_unavailable: "This provider did not expose the conversation model; Delivery Loop is unavailable.",
       existing_loop: "This conversation already has a Delivery Loop. Open its existing supervision instead.",
-      task_settled: "This task has finished. Start a new conversation before enabling automatic continuation.",
+      task_settled: "This task has finished. Start a new conversation before turning on Delivery Loop.",
     };
     if (messages[error?.code]) return messages[error.code];
   }
@@ -203,6 +205,7 @@ export async function startDesktopHost({ input = process.stdin, output = process
     status = { ...status, update: { ...status.update,
       auto_update_supported: updateSettings.auto_update_supported === true,
       auto_update_enabled: updateSettings.auto_update_enabled === true,
+      auto_update_unavailable_reason: updateSettings.auto_update_unavailable_reason || null,
       auto_update_busy: updateSettings.auto_update_busy === true } };
     if (env.SIMY_REMOTE_CHILD === "1") status = { ...status, remoteSessionProtocol: 1, remoteControl: { version: 2, actions: [...allowedActions] } };
     ownerTransport?.publish({ type: 'status', status: { ...status, remoteSessionProtocol: 1, remoteControl: { version: 2, actions: [...allowedActions] } } });
@@ -480,6 +483,13 @@ export async function startDesktopHost({ input = process.stdin, output = process
     })().finally(() => { emailSync = null; });
     await emailSync;
   };
+  const saveEmailDeliveryObservation = (controller, completion, observation) => controllerPreferences.change(controller.controllerScope, state => {
+    const identity = JSON.stringify([completion.host_id || 'local', completion.provider, completion.provider_session_id]);
+    const row = state.conversations[identity] ||= {};
+    row.emailDeliveries ||= {};
+    row.emailDeliveries[completion.task_id] = { ...observation, checkedAt: Date.now(), provider: completion.provider,
+      provider_session_id: completion.provider_session_id, host_id: completion.host_id || 'local' };
+  });
   const submitNativeDevelopmentReportCompletions = ({ completions, controller }) => {
     const { scope, deviceSession } = controller;
     if (!deviceSession?.token || !deviceSession?.api_base_url || !sameReportController(controller, nativeDevelopmentReportsController) || nativeDevelopmentReports.state !== "ready" || nativeDevelopmentReportsScope !== scope) return;
@@ -506,23 +516,31 @@ export async function startDesktopHost({ input = process.stdin, output = process
         if (receipt && nativeDevelopmentReportsGeneration === generation && accessScope(currentAccess) === scope) {
           if (receipt.status === 'pending') nativeCompletionRetryAt.set(key, Date.now() + 30_000);
           else { nativeCompletionSuccess.add(key); nativeCompletionRetryAt.delete(key); }
-          const receiptScope = controller.controllerScope;
-          await controllerPreferences.change(receiptScope, state => {
-            const identity = JSON.stringify([hostId, completion.provider, completion.provider_session_id]);
-            const row = state.conversations[identity] ||= {};
-            row.emailDeliveries ||= {};
-            row.emailDeliveries[completion.task_id] = { ...receipt, checkedAt: Date.now(), provider: completion.provider, provider_session_id: completion.provider_session_id, host_id: hostId };
-          });
+          await saveEmailDeliveryObservation(controller, completion, receipt);
           await requireReportController(controller);
           if (!closed) void publish().catch(() => {});
         }
         return receipt;
-      }).catch(error => {
+      }).catch(async error => {
         if (nativeDevelopmentReportsGeneration === generation && accessScope(currentAccess) === scope) {
           // These are immutable authorization/contract rejections. A new
           // enrollment revision or scope produces a fresh rejection identity.
-          if ([400, 403, 409].includes(error?.status)) nativeCompletionRejected.add(rejectionKey);
+          const rejected = [400, 403, 409].includes(error?.status);
+          if (rejected) nativeCompletionRejected.add(rejectionKey);
           else nativeCompletionRetryAt.set(key, Date.now() + 30_000);
+          // ON is consent, not a delivery receipt. Surface a failed submission
+          // without exposing backend errors, credentials or completion proofs.
+          // The next confirmed server receipt replaces this local observation.
+          try {
+            await requireReportController(controller);
+            if (closed || nativeDevelopmentReportsGeneration !== generation || accessScope(currentAccess) !== scope) return null;
+            await saveEmailDeliveryObservation(controller, completion, {
+              task_id: completion.task_id, enrollment_revision: completion.enrollment_revision,
+              status: rejected ? 'rejected' : 'retrying',
+            });
+            await requireReportController(controller);
+            if (!closed) void publish().catch(() => {});
+          } catch { /* A changed controller must not receive an old failure. */ }
         }
         return null;
       }).finally(() => nativeCompletionInFlight.delete(key));
@@ -568,6 +586,7 @@ export async function startDesktopHost({ input = process.stdin, output = process
   let commands;
   let sessionStatus = { sessions: [], providers: { codex: { discovery: "loading", reason: null }, claude: { discovery: "loading", reason: null } }, refreshedAt: null, initialLoading: true };
   let sessionRefresh = null, sessionRefreshedAt = 0, sessionRefreshAgain = false, discoveryController = null, discoveryStopped = false;
+  const catalogRefresh = createCatalogRefreshPolicy();
   let catalogRevision = 0;
   let enrichmentController = null, sessionEnrichment = null;
   let catalogAnalysisJob = null, catalogAnalysisAgain = false;
@@ -585,7 +604,9 @@ export async function startDesktopHost({ input = process.stdin, output = process
         const records = await recordReader.list();
         if (closed || relay || discoveryStopped || manager !== analysisManager ||
             !desktopAccessReady(currentAccess) || accessScope(currentAccess) !== scope || !coordinator.acceptsNewWork()) return;
-        await manager.update(analysisSessions(withCurrentSettings(sessionStatus.sessions, records)));
+        await manager.update(analysisSessions(withCurrentSettings(sessionStatus.sessions, records)), {
+          priorityKeys: new Set(records.filter(supervisedSession).map(record => `${record.provider}:${record.session}`)),
+        });
       }
     }).catch(() => {}).finally(() => {
       catalogAnalysisJob = null;
@@ -640,12 +661,14 @@ export async function startDesktopHost({ input = process.stdin, output = process
     unfinishedDesktopWork = false;
   })();
   const observePullRequests = dependencies.observePullRequests || createPullRequestObserver();
-  const refreshSessions = (force = false) => {
+  const refreshSessions = (force = false, { history = false } = {}) => {
+    if (history) catalogRefresh.invalidate();
     if (discoveryStopped && !closed && !relay) return sessionStatus;
     if (closed || relay || !desktopAccessReady(currentAccess)) return { sessions: [], providers: {}, refreshedAt: null };
     if (force && sessionRefresh) sessionRefreshAgain = true;
     if (!sessionRefresh && (force || Date.now() - sessionRefreshedAt >= 15_000)) {
       const requestedScope = accessScope(currentAccess);
+      const refresh = catalogRefresh.begin(JSON.stringify([requestedScope, providerLinks]));
       const controller = discoveryController = new AbortController();
       const attempt = { id: randomUUID(), requestedAt: Date.now(), state: 'pending' };
       sessionStatus = { ...sessionStatus, discoveryAttempt: attempt };
@@ -659,7 +682,7 @@ export async function startDesktopHost({ input = process.stdin, output = process
         }
         const complete = new Set(value.completeProviders || (value.historyLoading === undefined ? PROVIDER_LINKS : []));
         const merge = (previous, incoming) => {
-          const rows = new Map(previous.filter(item => !complete.has(item.provider)).map(item => [`${item.provider}:${item.session}`, item]));
+          const rows = new Map(previous.filter(item => refresh.recentOnly || !complete.has(item.provider)).map(item => [`${item.provider}:${item.session}`, item]));
           for (const item of incoming || []) rows.set(`${item.provider}:${item.session}`, item);
           return [...rows.values()];
         };
@@ -674,7 +697,7 @@ export async function startDesktopHost({ input = process.stdin, output = process
       const firstPageTimeoutMs = dependencies.discoveryTimeoutMs ?? 30_000;
       const historyTimeoutMs = dependencies.historyDiscoveryTimeoutMs ?? dependencies.discoveryTimeoutMs ?? 300_000;
       sessionRefresh = boundedDiscovery((signal, startHistory) => (dependencies.discoverSessions || discoverSessions)({
-        root: deliveryRoot, signal, onDrain: trackDiscoveryDrain, includeArchived: true, includeSelectionCandidates: true,
+        root: deliveryRoot, signal, onDrain: trackDiscoveryDrain, includeArchived: true, includeSelectionCandidates: true, recentOnly: refresh.recentOnly,
         readRecords: () => recordReader.list(),
         connectedProviders: PROVIDER_LINKS.filter(provider => providerLinks[provider].connected),
         timeoutMs: firstPageTimeoutMs, historyTimeoutMs,
@@ -685,6 +708,7 @@ export async function startDesktopHost({ input = process.stdin, output = process
           await applyCatalog(value);
           if (closed || relay || controller.signal.aborted) return;
           const failed = Object.values(value.providers || {}).some(provider => provider.discovery === 'unavailable');
+          refresh.complete(!failed);
           sessionStatus = { ...sessionStatus, historyLoading: false,
             discoveryAttempt: { ...attempt, state: failed ? 'failed' : 'succeeded', completedAt: Date.now() } };
           // Publish before PR/network observation and queue maintenance. Neither
@@ -1507,7 +1531,7 @@ export async function startDesktopHost({ input = process.stdin, output = process
         if(['detach_update','update_reconnect'].includes(action)) {
           const access=await accessSnapshot(); requireDesktopAccess(access);
           updateRuntime.validate(command,coordinator.snapshot(),updater?.snapshot?.());
-          if(action==='detach_update')await updater.maybeApply({detach:true});
+          if(action==='detach_update')await updater.maybeApply({detach:true,manual:true});
           else await reconnectWithHistoryRecovery({root,coordinator,eligible:()=>updateRuntime.historyRecoveryEligible()});
           emit({type:'result',id:command.id,ok:coordinator.snapshot().state==='connected' && (action!=='detach_update' || updater.snapshot().state==='updated')});
           await publish();return;
@@ -1578,7 +1602,11 @@ export async function startDesktopHost({ input = process.stdin, output = process
         if (['detach_update', 'update_reconnect'].includes(action)) requireDesktopAccess(access);
         else if (!recoveryControl && desktopAccessReady(access) && !desktopActionAllowed({ state: 'unavailable' }, command)) await authorizeWork();
 
-        if (!coordinator.acceptsNewWork() && !recoveryControl && !["refresh", "reconnect", "task_detail", "check_update", "quit", "delivery_stop", "delivery_pause", "delivery_reject"].includes(action)) {
+        // Signing back into the same SIMY environment is a prerequisite for
+        // recovery, not permission to resume work. Keep organization changes
+        // and execution fenced until the original checkpoint is reconciled.
+        const recoveryAuthorization = ["login", "authorization_open", "authorization_copy", "organization_cancel"].includes(action);
+        if (!coordinator.acceptsNewWork() && !recoveryControl && !recoveryAuthorization && !["refresh", "reconnect", "task_detail", "check_update", "quit", "delivery_stop", "delivery_pause", "delivery_reject"].includes(action)) {
           throw new Error("The update connection requires recovery.");
         }
         if (['team_threads_refresh','team_thread_open','team_thread_share'].includes(action)) {
@@ -1890,7 +1918,7 @@ export async function startDesktopHost({ input = process.stdin, output = process
           else if (desktopAccessReady(access)) await agent.refreshCodexStatus?.();
           await agent.refreshDesktopStatus();
           await refreshPlugins();
-          refreshSessions(true);
+          refreshSessions(true, { history: true });
           if (desktopAccessReady(currentAccess) && coordinator.acceptsNewWork()) void actionAssociations.tick().then(publish).catch(() => {});
         }
         else if (action === "organizations_refresh") await agent.refreshOrganizations();
@@ -2011,7 +2039,7 @@ export async function startDesktopHost({ input = process.stdin, output = process
           await authorizeWork(commandScope);
           await actionAssociations.correct(command, analysisManager.project(candidate));
         } else if (action === "session_set_auto_continue") {
-          if (typeof command.enabled !== 'boolean') throw new Error('Choose whether automatic continuation is enabled.');
+          if (typeof command.enabled !== 'boolean') throw new Error('Choose whether Delivery Loop is on.');
           let admission, target, providerEpoch;
           if (command.enabled) {
             const candidate = await selectedSession(command, { preferObserved: true });
@@ -2204,7 +2232,7 @@ export async function startDesktopHost({ input = process.stdin, output = process
                 if (fresh.cwd !== candidate.cwd) throw new Error('The conversation workspace changed. Refresh and retry.');
                 const record = await readRecord(deliveryRoot, 'claude', command.session);
                 if (fresh.isRunning || fresh.autoContinue || record?.autoContinue || record?.run && !TERMINAL.has(record.run.state))
-                  throw Object.assign(new Error('Stop this conversation and turn off automatic continuation before organizing it.'), { code: 'claude_desktop_running' });
+                  throw Object.assign(new Error('Stop this conversation and turn off Delivery Loop before organizing it.'), { code: 'claude_desktop_running' });
               };
               await verifySelection();
               const operation = new AbortController();
@@ -2227,7 +2255,7 @@ export async function startDesktopHost({ input = process.stdin, output = process
               } finally { clearInterval(watchdog); }
 
               await recordProviderArchive(deliveryRoot, 'claude', command.session, archived, Date.now());
-              refreshSessions(true);
+              refreshSessions(true, { history: true });
               emit({ type: 'result', id: command.id, ok: true, data });
               void publish().catch(() => {});
               return;
@@ -2245,7 +2273,9 @@ export async function startDesktopHost({ input = process.stdin, output = process
               listHidden: archived,
             }));
           }
-          refreshSessions(true);
+          // Archive/restore can move an old conversation outside both recent
+          // pages. Explicit organization must be visible immediately.
+          refreshSessions(true, { history: true });
         } else if (action === "session_track" || action === "session_untrack") {
           const candidate = await selectedSession(command);
           if (candidate.capabilities?.canMonitor !== true) throw new Error('Tracking is unavailable for this conversation.');
@@ -2380,7 +2410,7 @@ function sessionActionError(error, action) {
   if (error instanceof AutoContinueUnavailableError) return error.message.replace(/[\r\n\x00-\x1f]/g, ' ').slice(0, 600);
   const message = String(error?.message || "");
   if (/already has a Delivery Loop|budgets cannot be reset/i.test(message)) return "This conversation already has a task. Open its existing supervision instead.";
-  if (/model.*unavailable|did not expose.*model/i.test(message)) return "This provider did not expose the conversation model; automatic continuation is unavailable.";
+  if (/model.*unavailable|did not expose.*model/i.test(message)) return "This provider did not expose the conversation model; Delivery Loop is unavailable.";
   if (/workspace changed|metadata.*unavailable|session.*changed/i.test(message)) return "The conversation identity or workspace changed. Refresh and select it again.";
   if (/objective|acceptance|autonomy policy|budget/i.test(message)) return message.replace(/[\r\n\x00-\x1f]/g, " ").slice(0, 240);
   if (/question changed|answer is empty|session understanding|context/i.test(message)) return message.replace(/[\r\n\x00-\x1f]/g, " ").slice(0, 240);

package/src/index.js

@@ -161,7 +161,7 @@ async function runCommand(installMode) {
 Options:
   --version, -v       Print the installed CLI version and exit
   --daemon, --deamon  Run detached in the background
-  --no-tui            Disable the interactive Agentic Loop console
+  --no-tui            Disable the interactive Delivery Loop console
   --no-open           Do not open the browser when authorization is required
   --port <port>       Bind a specific localhost port
   --host <url>        Connect to a SIMY Web origin (default: ${DEFAULT_WEB_ORIGIN})

package/src/local-task.js

@@ -1257,7 +1257,7 @@ function localTaskProviderInstruction(task) {
     ? "The managed output directory is reserved for final user-requested deliverables. Keep helper scripts, temporary files, caches, and intermediate files outside it (use the task workspace or an OS temporary directory), and remove those helper files before completion."
     : null;
   return [
-    "You are the local executor for a SIMY Local Task, not an Agentic Loop.",
+    "You are the local executor for a SIMY Local Task, not a Delivery Loop.",
     buildWorkflowReportingInstruction(),
     "Complete this bounded task once. Do not create Git branches, commits, pull requests, audits, or automatic retries.",
     `Permission mode: ${task.permission_mode}.`,

package/src/orchestrator/presentation.js

@@ -117,7 +117,7 @@ export function summarizeCodingLoopEvent(snapshot, event) {
       };
     case "stopped":
       return {
-        summary: "The local human operator stopped this Agentic Loop run.",
+        summary: "The local human operator stopped this Delivery Loop run.",
         result: "No further executor handoff will occur for this run.",
         next: "Start a new run or explicitly continue this one when ready.",
       };

package/src/runner.js

@@ -452,7 +452,7 @@ export async function recoverLocalCodingRun(run, dependencies = {}, now = Date.n
 }
 
 function assertRunCanContinue(run) {
-  if (run.operation || run.child) throw new Error("The selected Agentic Loop run is still active.");
+  if (run.operation || run.child) throw new Error("The selected Delivery Loop run is still active.");
   if (!RESUMABLE_STATES.has(run.status)) {
     throw new Error("Human guidance is available only when the selected run is waiting.");
   }
@@ -542,7 +542,7 @@ export async function continueLocalCodingRunAfterRepositoryApproval(
   if (!approvedRepository || !approvedPath) {
     throw new Error("An approved local repository and path are required.");
   }
-  if (run.operation || run.child) throw new Error("The selected Agentic Loop run is still active.");
+  if (run.operation || run.child) throw new Error("The selected Delivery Loop run is still active.");
   if (run.status !== "waiting_human") {
     throw new Error("Repository approval is available only while the run is waiting.");
   }

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/automatic-continuation.js

@@ -6,15 +6,15 @@ function continuationFailureReason(error) {
   // Provider exceptions can contain private paths/output. Only known codes
   // select actionable UI copy; unrecognized failures retain a safe fallback.
   const reasons = {
-    desktop_access_required: 'Sign in to an organization with SQM and Developer access before auto-continue can run.',
-    provider_sign_in_required: 'Sign in to the original AI provider, then retry auto-continue.',
-    unavailable: 'The local provider is unavailable. Open or configure it, then retry auto-continue.',
-    unsupported: 'Update the original AI provider to a compatible version, then retry auto-continue.',
+    desktop_access_required: 'Sign in to an organization with SQM and Developer access before Delivery Loop can run.',
+    provider_sign_in_required: 'Sign in to the original AI provider, then retry Delivery Loop.',
+    unavailable: 'The local provider is unavailable. Open or configure it, then retry Delivery Loop.',
+    unsupported: 'Update the original AI provider to a compatible version, then retry Delivery Loop.',
     process_exited: 'The original Claude process has exited. Return to the original conversation, then refresh.',
     session_ended: 'This Claude session has ended. Return to the original conversation, then refresh.',
     hook_missing: 'Waiting for the original Claude hook. SIMY recovers automatically when the next verified prompt or response-end hook arrives. If no notifications arrive, check the SIMY plugin in the original Claude window.',
   };
-  return Object.hasOwn(reasons, error?.code) ? reasons[error.code] : 'Could not start auto-continue. Check the original conversation and retry.';
+  return Object.hasOwn(reasons, error?.code) ? reasons[error.code] : 'Could not start Delivery Loop. Check the original conversation and retry.';
 }
 
 // Shared by explicit Continue and automatic enrollment. Analysis alone never
@@ -24,7 +24,7 @@ export async function continueAnalyzedSession({ candidate, manager, root, settin
   const link = await requireProviderLink({ root, provider: candidate.provider, expectedEpoch: settings.expectedProviderEpoch });
   const recommendationOptions = { allowDiagnosis: settings.purposeDriven === true && candidate.autoContinue === true };
   const recommendation = manager.requireRecommendation(candidate, recommendationOptions);
-  if (candidate.isRunning || candidate.capabilities?.canContinue !== true) throw new Error('Automatic continuation is unavailable for this conversation.');
+  if (candidate.isRunning || candidate.capabilities?.canContinue !== true) throw new Error('Delivery Loop is unavailable for this conversation.');
   const context = await readContext(candidate, { signal });
   if (context.awaitingTurn || context.incomplete || !recommendation.contextDigest || context.contextDigest !== recommendation.contextDigest) {
     await manager.invalidate(candidate);
@@ -34,7 +34,7 @@ export async function continueAnalyzedSession({ candidate, manager, root, settin
   await beforeEnroll(candidate);
   await requireProviderLink({ root, provider: candidate.provider, expectedEpoch: link.epoch });
   manager.requireRecommendation(candidate, recommendationOptions);
-  if (signal?.aborted) throw new Error('Automatic continuation was cancelled before enrollment.');
+  if (signal?.aborted) throw new Error('Delivery Loop was cancelled before enrollment.');
   return enroll({ root, provider: candidate.provider, session: candidate.session, ...settings, expectedProviderEpoch: link.epoch });
 }
 
@@ -46,7 +46,7 @@ function startingPresentation(candidate, status, reason) {
   const canPresent = work && !work.needsAttention && !['running', 'stopped', 'archived', 'approval', 'question'].includes(work.state);
   return { ...candidate, autoContinueStatus: status, autoContinueReason: reason,
     ...(canPresent ? { workState: { ...work, state: status,
-      label: status === 'starting' ? '自動継続を準備中' : '自動復旧中', reason,
+      label: status === 'starting' ? 'Delivery Loop を準備中' : '自動復旧中', reason,
       nextAction: null, needsAttention: false } } : {}) };
 }
 
@@ -133,7 +133,7 @@ export function createAutomaticContinuation({ root, getManager, selectCandidate,
             retries.set(key, { attempt, count, at: now() + Math.min(60_000, 1000 * 2 ** Math.min(count - 1, 6)) });
           } else retries.delete(key);
           errors.set(key, { epoch: candidate.autoContinueEpoch, recoverable,
-            reason: recoverable ? 'The AI connection is temporarily unavailable. Automatic continuation will retry when the connection is available.' : continuationFailureReason(error) });
+            reason: recoverable ? 'The AI connection is temporarily unavailable. Delivery Loop will retry when the connection is available.' : continuationFailureReason(error) });
         }
       }).finally(() => {
         if (controller.signal.aborted) { attempted.delete(key); retries.delete(key); }
@@ -152,14 +152,14 @@ export function createAutomaticContinuation({ root, getManager, selectCandidate,
       if (candidate.autoContinue === true && candidate.capabilities?.canAutoContinue === true &&
           !['managed', 'pending_takeover'].includes(candidate.binding?.mode)) {
         if (pending.has(key)) return startingPresentation(candidate, 'starting',
-          'Auto-continue is saved. Preparing to continue this conversation in the background.');
+          'Delivery Loop is on. Preparing Delivery Loop for this conversation in the background.');
         const failure = errors.get(key);
         if (failure?.recoverable && failure.epoch === candidate.autoContinueEpoch)
           return startingPresentation(candidate, 'recovering', failure.reason);
       }
       if (candidate.autoContinue === true && candidate.isRunning !== true &&
           ['unmanaged', 'monitor'].includes(candidate.binding?.mode || 'unmanaged') && candidate.analysis?.state === 'needs_user') return {
-        ...candidate, autoContinueStatus: 'needs_user', autoContinueReason: candidate.analysis.reason || 'Your decision is needed before automatic continuation can proceed.',
+        ...candidate, autoContinueStatus: 'needs_user', autoContinueReason: candidate.analysis.reason || 'Your decision is needed before Delivery Loop can proceed.',
       };
       const error = errors.get(`${candidate.provider}:${candidate.session}`);
       if (error && candidate.autoContinue === true && candidate.autoContinueEpoch === error.epoch &&

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');