@awak-app/simy-cli 0.7.32 → 0.7.33

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

@@ -1,3 +1,4 @@
+import { continuationReadinessRevision, retryableAnalysis, automaticAnalysisRetryAllowed, observeContinuationWait, projectContinuationWait, ANALYSIS_RETRY_DELAYS_MS, CONTINUATION_WAIT_NOTICE_MS } from './continuation-readiness.js';
 import { createHash, randomUUID } from 'node:crypto';
 import { lstat, mkdir, readFile, rename, rm, writeFile } from 'node:fs/promises';
 import { join } from 'node:path';
@@ -33,9 +34,11 @@ const canDispatchRecommendation = candidate => eligible(candidate) &&
 // Recommendations are metadata only. This worker never enrolls a conversation
 // or dispatches its task; the normal managed bootstrap still checks context.
 export async function createContinuationAnalysisManager({ root, analyze = analyzeContinuation,
-  now = Date.now, onChange = () => {}, timeoutMs = 120_000, concurrency = 3 } = {}) {
+  now = Date.now, onChange = () => {}, timeoutMs = 120_000, concurrency = 3,
+  retryDelaysMs = ANALYSIS_RETRY_DELAYS_MS, waitNoticeAfterMs = CONTINUATION_WAIT_NOTICE_MS } = {}) {
   if (!Number.isInteger(concurrency) || concurrency < 1 || concurrency > 4) throw new TypeError('Analysis concurrency must be an integer from 1 to 4.');
   if (!Number.isFinite(timeoutMs) || timeoutMs <= 0) throw new TypeError('Analysis timeout must be positive.');
+  if (!Array.isArray(retryDelaysMs) || retryDelaysMs.length > 4 || retryDelaysMs.some(value => !Number.isFinite(value) || value <= 0) || !Number.isFinite(waitNoticeAfterMs) || waitNoticeAfterMs <= 0) throw new TypeError('Invalid continuation retry policy.');
   await mkdir(root, { recursive: true, mode: 0o700 });
   if ((await lstat(root)).isSymbolicLink()) throw new Error('Invalid session analysis cache.');
   const path = join(root, 'cache.json');
@@ -105,13 +108,14 @@ export async function createContinuationAnalysisManager({ root, analyze = analyz
     } finally { await rm(temporary, { force: true }); }
   };
   const changed = () => { void Promise.resolve().then(onChange).catch(() => {}); };
-  const enqueue = (candidate, force = false, forceAnalysis = false) => {
+  const enqueue = (candidate, force = false, forceAnalysis = false, resetRetry = false) => {
     const key = keyOf(candidate), revision = continuationAnalysisRevision(candidate);
     const entry = entries.get(key);
     if (entry?.revision === revision && (['queued', 'analyzing'].includes(entry.result?.state) ||
       !force && !['failed', 'uncertain'].includes(entry.result?.state))) return false;
     entries.delete(key);
     entries.set(key, { revision, analysisVersion: CONTINUATION_ANALYSIS_VERSION, cwd: candidate.cwd,
+      retry: !resetRetry && entry?.revision === revision ? entry.retry : undefined,
       forceAnalysis: forceAnalysis || entry?.forceAnalysis === true && ['queued', 'analyzing'].includes(entry.result?.state),
       settledResult: entry?.cwd === candidate.cwd ? entry.settledResult : null,
       requestId: entry?.cwd === candidate.cwd && ['queued', 'analyzing'].includes(entry.result?.state) ? entry.requestId : undefined,
@@ -153,7 +157,8 @@ export async function createContinuationAnalysisManager({ root, analyze = analyz
   };
   const runJob = async selected => {
     const signal = selected.controller.signal;
-    const timeout = setTimeout(() => selected.controller.abort(), timeoutMs);
+    let timedOut = false;
+    const timeout = setTimeout(() => { timedOut = true; selected.controller.abort(); }, timeoutMs);
     timeout.unref?.();
     let aborted;
     const cancellation = new Promise((_, reject) => {
@@ -169,10 +174,14 @@ export async function createContinuationAnalysisManager({ root, analyze = analyz
         result.providerGoal?.status === 'active' && result.providerGoal.textTruncated !== true);
       if (!RESULT_STATES.has(result?.state) || typeof result.reason !== 'string' ||
         (result.state === 'continue' && (!result.objective || !result.remaining?.length || !result.nextAction || !grounded))) {
-        throw new Error('Invalid session analysis result.');
+        throw Object.assign(new Error('Invalid session analysis result.'), { code: 'analysis_invalid_result' });
       }
-    } catch {
-      result = { state: 'failed', reason: 'The conversation could not be analyzed. Retry when its provider is available.' };
+    } catch (error) {
+      // Keep structured nontechnical failures (identity, authority, incomplete
+      // context) out of the technical retry budget, including thrown failures.
+      const reasonCode = timedOut ? 'analysis_timeout' : signal.aborted ? 'analysis_cancelled'
+        : typeof error?.code === 'string' && /^[A-Za-z0-9_]{1,80}$/.test(error.code) ? error.code : 'analysis_failed';
+      result = { state: 'failed', reasonCode, reason: 'The conversation could not be analyzed. Retry when its provider is available.' };
     } finally {
       // Every job owns its cancellation and waits for the provider's process
       // receipt/cleanup before releasing either its slot or its session key.
@@ -196,8 +205,14 @@ export async function createContinuationAnalysisManager({ root, analyze = analyz
         return;
       }
       const settledResult = finishedAnalysis(result, selected.previousAnalysis || entry.settledResult);
+      let retry;
+      if (retryableAnalysis(result) && automaticAnalysisRetryAllowed(current)) {
+        const failures = (selected.entry.retry?.failures || 0) + 1;
+        const delay = retryDelaysMs[failures - 1];
+        retry = { failures, ...(delay !== undefined ? { nextAt: now() + delay } : {}), exhausted: delay === undefined };
+      }
       entries.set(selected.key, { revision: selected.revision, analysisVersion: CONTINUATION_ANALYSIS_VERSION, cwd: current.cwd, settledResult,
-        completedAt: now(), authRecoveryAttemptedAt: selected.entry.authRecoveryAttemptedAt, authRecoverySignedOutAt: selected.entry.authRecoverySignedOutAt,
+        completedAt: now(), retry, authRecoveryAttemptedAt: selected.entry.authRecoveryAttemptedAt, authRecoverySignedOutAt: selected.entry.authRecoverySignedOutAt,
         requestId: selected.entry.requestId, result: { ...result, analyzedAt: settledResult?.analyzedAt || now() } });
       await persist(); changed();
     });
@@ -278,11 +293,9 @@ export async function createContinuationAnalysisManager({ root, analyze = analyz
           const goalObserved = candidate.goalReadState !== 'unavailable';
           const goalChanged = previous && previous.goalEvidenceVersion === 1 && Object.hasOwn(previous, 'goalRevision') && previous.goalObserved !== false && goalObserved && previous.goalRevision !== goalRevision;
           const trackingEnabled = candidate.tracked === true && (!previous || Object.hasOwn(previous, 'tracked') && previous.tracked !== true);
-          // A known turn boundary is stronger than updated_at: tool/status
-          // events in that same turn must not enqueue or cancel paid inference.
-          const newActivity = document.initialized && (previous ?
-            (turnOf(candidate) && previous.latestTurnId ? turnOf(candidate) !== previous.latestTurnId : active > previous.activity) ||
-            (candidate.isRunning === true) !== (previous.isRunning === true) : active > document.baselineAt);
+          // An ON preference can predate a usable provider/workspace. Analyze
+          // once when readiness returns, even without a new turn or activity.
+          const readinessRevision = continuationReadinessRevision(candidate);
           const entry = entries.get(key);
           // Rebase unchanged old cache keys once without rerunning historical
           // inference when semantic goal/turn keys become available.
@@ -296,18 +309,32 @@ export async function createContinuationAnalysisManager({ root, analyze = analyz
             entry.settledResult = entry.result?.contextDigest ? entry.result : null;
             dirty = true;
           }
+          const dispatchReady = eligible(candidate) && candidate.capabilities?.canAutoContinue !== false &&
+            candidate.autoContinueAvailability?.canEnable !== false && candidate.dispatchReadiness?.state !== 'blocked';
+          const readinessRecovered = candidate.autoContinue === true && dispatchReady &&
+            (previous?.canAnalyze === false || previous?.dispatchReady === false) &&
+            (!entry || entry.revision !== revision || retryableAnalysis(entry.result) && !entry.retry?.exhausted &&
+              (!Number.isFinite(entry.retry?.nextAt) || now() >= entry.retry.nextAt));
+          const consentChanged = candidate.autoContinue === true && previous && Object.hasOwn(previous, 'autoContinueEpoch') && previous.autoContinueEpoch !== candidate.autoContinueEpoch;
+          // A known turn boundary is stronger than updated_at: tool/status
+          // events in that same turn must not enqueue or cancel paid inference.
+          const newActivity = document.initialized && (previous ?
+            (turnOf(candidate) && previous.latestTurnId ? turnOf(candidate) !== previous.latestTurnId : active > previous.activity) ||
+            (candidate.isRunning === true) !== (previous.isRunning === true) : active > document.baselineAt);
           // A reader that raced a terminal boundary (or a provider without live
           // status) is retried at discovery cadence, never a busy inference loop.
           const schemaRefresh = entry && !['queued', 'analyzing', 'failed'].includes(entry.result?.state) &&
             entry.result?.analysisVersion !== CONTINUATION_ANALYSIS_VERSION && entry.analysisVersion !== CONTINUATION_ANALYSIS_VERSION;
+          const automaticRetry = automaticAnalysisRetryAllowed(candidate) && retryableAnalysis(entry?.result) &&
+            entry?.revision === revision && Number.isFinite(entry?.retry?.nextAt) && now() >= entry.retry.nextAt;
           const recheck = entry?.result?.reasonCode === 'turn_settling' || entry?.result?.awaitingTurn === true && candidate.isRunning !== true;
-          if (eligible(candidate) && (backfill.has(key) || newActivity || recheck || trackingEnabled || goalChanged || schemaRefresh)) {
-            dirty = enqueue(candidate, recheck || trackingEnabled || goalChanged || schemaRefresh, trackingEnabled || goalChanged || schemaRefresh) || dirty;
+          if (eligible(candidate) && (backfill.has(key) || newActivity || recheck || trackingEnabled || readinessRecovered || consentChanged || automaticRetry || goalChanged || schemaRefresh)) {
+            dirty = enqueue(candidate, recheck || trackingEnabled || readinessRecovered || consentChanged || automaticRetry || goalChanged || schemaRefresh, trackingEnabled || readinessRecovered || consentChanged || automaticRetry || goalChanged || schemaRefresh, consentChanged) || dirty;
           }
-          if (previous?.revision !== revision || previous?.activity !== active || previous?.goalEvidenceVersion !== 1 || previous?.goalObserved !== goalObserved || (previous?.tracked === true) !== (candidate.tracked === true) ||
+          if (previous?.readinessRevision !== readinessRevision || previous?.autoContinueEpoch !== candidate.autoContinueEpoch || previous?.canAnalyze !== eligible(candidate) || previous?.revision !== revision || previous?.activity !== active || previous?.goalEvidenceVersion !== 1 || previous?.goalObserved !== goalObserved || (previous?.tracked === true) !== (candidate.tracked === true) ||
               previous && (!Object.hasOwn(previous, 'goalRevision') || !Object.hasOwn(previous, 'tracked'))) {
             known.delete(key); known.set(key, { revision, cwd: candidate.cwd, activity: active, isRunning: candidate.isRunning, latestTurnId: turnOf(candidate),
-              tracked: candidate.tracked === true, goalRevision, goalObserved, goalEvidenceVersion: 1 }); dirty = true;
+              tracked: candidate.tracked === true, canAnalyze: eligible(candidate), readinessRevision, dispatchReady, autoContinueEpoch: candidate.autoContinueEpoch, wait: previous?.wait, goalRevision, goalObserved, goalEvidenceVersion: 1 }); dirty = true;
           }
         }
         // Cancelling owned analysis is separate from stopping the original
@@ -335,7 +362,45 @@ export async function createContinuationAnalysisManager({ root, analyze = analyz
       } else if (previous && ['queued', 'analyzing'].includes(analysis.state)) {
         analysis.previousAnalysis = previous;
       }
-      return { ...candidate, analysis };
+      return { ...candidate, analysis: { ...analysis, ...(entry?.revision === revision && entry.retry ? { retry: { ...entry.retry } } : {}) } };
+    },
+    async observeContinuationWaits(sessions) {
+      await exclusive(async () => {
+        if (closed || suspended) return;
+        let dirty = false;
+        for (const candidate of sessions) {
+          const key = keyOf(candidate), previous = known.get(key);
+          if (!previous || previous.cwd !== candidate.cwd) continue;
+          const wait = observeContinuationWait(candidate, previous.wait, now());
+          if (JSON.stringify(wait) !== JSON.stringify(previous.wait || null)) { known.set(key, { ...previous, wait }); dirty = true; }
+        }
+        if (dirty) await persist();
+      });
+    },
+    projectContinuationWait(candidate) {
+      const previous = known.get(keyOf(candidate));
+      return previous && previous.cwd === candidate.cwd ? projectContinuationWait(candidate, previous.wait, now(), waitNoticeAfterMs) : candidate;
+    },
+    async takeContinuationWaitNotifications(sessions) {
+      return exclusive(async () => {
+        if (closed || suspended) return [];
+        const events = [];
+        for (const candidate of sessions) {
+          const key = keyOf(candidate), previous = known.get(key), wait = previous?.wait;
+          if (previous?.cwd !== candidate.cwd || !wait || wait.notified) continue;
+          // The final UI projection has needs_user; reconstruct the pre-notice
+          // status for the same known runtime condition without granting work.
+          const current = { ...candidate, autoContinueStatus: candidate.continuationWait?.id === wait.id ? wait.status : candidate.autoContinueStatus };
+          const projected = projectContinuationWait(current, wait, now(), waitNoticeAfterMs);
+          if (!projected.continuationWait?.needsAttention) continue;
+          known.set(key, { ...previous, wait: { ...wait, notified: true } });
+          events.push({ type: 'notify', id: wait.id, kind: 'needs_decision', continuationWaitId: wait.id,
+            sessionIdentity: `${candidate.provider}|${candidate.session}`, provider: candidate.provider, session: candidate.session,
+            objective: String(candidate.title || '').slice(0, 200) });
+        }
+        if (events.length) await persist();
+        return events;
+      });
     },
     async request(candidate, { requestId } = {}) {
       if (requestId !== undefined && (typeof requestId !== 'string' || !requestId || requestId.length > 128)) throw new Error('Invalid analysis request identity.');
@@ -344,7 +409,7 @@ export async function createContinuationAnalysisManager({ root, analyze = analyz
       await exclusive(async () => {
         if (closed || suspended) throw new Error('Session analysis is unavailable.');
         candidates.set(keyOf(candidate), candidate);
-        let dirty = enqueue(candidate, true, true);
+        let dirty = enqueue(candidate, true, true, true);
         const entry = entries.get(keyOf(candidate));
         if (requestId && entry.requestId !== requestId) { entry.requestId = requestId; dirty = true; }
         if (dirty) { await persist(); changed(); }

package/src/session-supervision/claude-desktop-lineage.js

@@ -72,7 +72,7 @@ async function metadata(path, desktopId, sessions) {
     if (item.sessionId === desktopId && UUID.test(item.cliSessionId || '') && typeof item.cwd === 'string' && isAbsolute(item.cwd)) {
       value = { desktopId, session: item.cliSessionId, cwd: resolve(item.cwd),
         ...(complete ? { providerArchived: typeof item.isArchived === 'boolean' ? item.isArchived : typeof item.archived === 'boolean' ? item.archived : undefined,
-          pullRequests: normalizePullRequests(item.pullRequests || item.gitHubPullRequests || item.githubPullRequests || item.githubPRs || item.gitHubPRs || item.gitHubPR || item.pullRequest || (item.prUrl ? { url: item.prUrl, state: item.prStatus } : null)) } : {}),
+          pullRequests: normalizePullRequests(item.pullRequests || item.prs || item.gitHubPullRequests || item.githubPullRequests || item.githubPRs || item.gitHubPRs || item.gitHubPR || item.pullRequest || (item.prUrl ? { url: item.prUrl, state: item.prStatus } : null)) } : {}),
         parentDesktopId: complete && LOCAL.test(item.spawnedFrom?.sessionId || '') ? item.spawnedFrom.sessionId : null };
     }
     const after = await lstat(path, { bigint: true });

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

@@ -165,7 +165,7 @@ async function inspectTranscript(root, projectName, fileName, observedAt, includ
   finally { await handle?.close(); }
 }
 
-async function collect({ home = homedir(), all = false, limit = 100, session = null, prioritySessions = [], includeContext = false, cacheMetadata = false, includeStatistics = false, includeBoundary = false, humanRequest = null, signal } = {}) {
+async function collect({ home = homedir(), all = false, limit = 100, session = null, prioritySessions = [], includeContext = false, cacheMetadata = false, includeStatistics = false, includeBoundary = false, humanRequest = null, signal, onProgress } = {}) {
   if (signal?.aborted) return [];
   const root = await projectsRoot(home);
   if (!root) return [];
@@ -212,7 +212,8 @@ async function collect({ home = homedir(), all = false, limit = 100, session = n
     ...recentSessionWindow(descriptors.filter(item => desktopLineage.get(item.session)?.providerArchived !== true), { limit: maximum, priority: item => priorities.has(item.session) }),
     ...recentSessionWindow(descriptors.filter(item => desktopLineage.get(item.session)?.providerArchived === true), { limit: maximum, priority: item => priorities.has(item.session) }),
   ];
-  const filesToInspect = all ? selected : selected.slice(0, MAX_TRANSCRIPTS);
+  const filesToInspect = (all ? selected : selected.slice(0, MAX_TRANSCRIPTS)).sort((a, b) => b.lastActivityAt - a.lastActivityAt);
+  let nextProgress = 25, progress = Promise.resolve();
   let nextFile = 0;
   // Catalog prefixes are bounded independently of full transcript size. Use a
   // small I/O pool; exact-context/statistics reads stay serial and identity-safe.
@@ -224,8 +225,19 @@ async function collect({ home = homedir(), all = false, limit = 100, session = n
       candidate = decorateLineage(candidate);
       const key = `${candidate.session}\0${candidate.cwd}${includeContext || includeStatistics || includeBoundary || humanRequest ? `\0${file.projectName}\0${file.fileName}` : ''}`;
       if (!result.has(key) || candidate.lastActivityAt > result.get(key).lastActivityAt) result.set(key, candidate);
+      if (onProgress && result.size >= nextProgress) {
+        nextProgress = Math.max(100, result.size * 2);
+        // Desktop parent links require the final cross-identity validation below.
+        const snapshot = [...result.values()].map(item => {
+          if (item.parentSessionSource !== 'claude_desktop_spawned_from') return item;
+          const { parentSession, parentSessionSource, ...independent } = item; return independent;
+        });
+        progress = progress.then(() => { signal?.throwIfAborted(); return onProgress(snapshot); });
+        await progress;
+      }
     }
   }));
+  await progress;
   if (signal?.aborted) return [];
   // Resolve old parents outside the recent window through their own validated
   // transcript. Never manufacture selectable conversations from Desktop JSON.
@@ -264,8 +276,8 @@ async function collect({ home = homedir(), all = false, limit = 100, session = n
   ];
 }
 
-export async function listClaudeSessions({ home, all = false, limit, prioritySessions, signal } = {}) {
-  return collect({ home, all, limit, prioritySessions, signal, cacheMetadata: true });
+export async function listClaudeSessions({ home, all = false, limit, prioritySessions, signal, onProgress } = {}) {
+  return collect({ home, all, limit, prioritySessions, signal, onProgress, cacheMetadata: true });
 }
 
 export async function readClaudeSession(session, { home } = {}) {

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

@@ -235,40 +235,45 @@ export function codexThreadMetadata(thread) {
   };
 }
 
-export async function listCodexSessions({ client, all = false, signal, maxPages = 40, pageSize = 25, maxSessions = RECENT_SESSION_LIMIT, archived = false, inspectState = false, prioritySessions = [], observationBudgetMs = 3000, codexHome } = {}) {
+export async function listCodexSessions({ client, all = false, signal, onPage, maxPages = 40, pageSize = 25, maxSessions = RECENT_SESSION_LIMIT, archived = false, inspectState = false, prioritySessions = [], observationBudgetMs = 3000, codexHome } = {}) {
   const sessions = [];
   const windowSize = all ? Infinity : Math.min(maxSessions, maxPages * pageSize);
   const cursors = new Set(), ids = new Set();
-  let cursor = null, listed = 0, pages = 0, batchSize = pageSize;
-  while (pages < Math.max(maxPages, Math.ceil(windowSize / batchSize)) && listed < windowSize) {
-    signal?.throwIfAborted();
-    const limit = Math.min(batchSize, windowSize - listed);
-    let response;
-    try { response = await client.request('thread/list', { cursor, limit, sourceKinds: SOURCE_KINDS,
-      archived, sortKey: 'updated_at', sortDirection: 'desc', useStateDbOnly: true }); }
-    catch (error) {
-      // Keep the transport's byte limit. Retry the same cursor in smaller
-      // batches rather than dropping discovery for large metadata envelopes.
-      if (error?.code !== 'response_too_large' || limit <= 1) throw error;
-      batchSize = Math.max(1, Math.floor(limit / 2));
-      continue;
-    }
-    if (!Array.isArray(response?.data) || response.data.length > limit)
-      throw new CodexAppServerError('invalid_page', 'Codex returned an invalid conversation page.');
-    const threads = response.data;
-    listed += threads.length; pages++;
-    for (const thread of threads) {
-      const metadata = codexThreadMetadata(thread);
-      if (metadata && SOURCE_KINDS.includes(metadata.source) && !ids.has(metadata.session)) {
-        ids.add(metadata.session); sessions.push(metadata);
+  let cursor = null, listed = 0, pages = 0, batchSize = pageSize, nextProgress = 0;
+  try {
+    while (pages < Math.max(maxPages, Math.ceil(windowSize / batchSize)) && listed < windowSize) {
+      signal?.throwIfAborted();
+      const limit = Math.min(batchSize, windowSize - listed);
+      let response;
+      try { response = await client.request('thread/list', { cursor, limit, sourceKinds: SOURCE_KINDS,
+        archived, sortKey: 'updated_at', sortDirection: 'desc', useStateDbOnly: true }); }
+      catch (error) {
+        // Keep the transport's byte limit. Retry the same cursor in smaller
+        // batches rather than dropping discovery for large metadata envelopes.
+        if (error?.code !== 'response_too_large' || limit <= 1) throw error;
+        batchSize = Math.max(1, Math.floor(limit / 2));
+        continue;
       }
+      if (!Array.isArray(response?.data) || response.data.length > limit)
+        throw new CodexAppServerError('invalid_page', 'Codex returned an invalid conversation page.');
+      const threads = response.data;
+      listed += threads.length; pages++;
+      for (const thread of threads) {
+        const metadata = codexThreadMetadata(thread);
+        if (metadata && SOURCE_KINDS.includes(metadata.source) && !ids.has(metadata.session)) {
+          ids.add(metadata.session); sessions.push(metadata);
+        }
+      }
+      if (onPage && (pages === 1 || sessions.length >= nextProgress)) {
+        await onPage(sessions); nextProgress = Math.max(100, sessions.length * 2);
+      }
+      cursor = response?.nextCursor || null;
+      if (!cursor) break;
+      if (typeof cursor !== 'string' || cursors.has(cursor))
+        throw new CodexAppServerError('invalid_page', 'Codex repeated a conversation page cursor.');
+      cursors.add(cursor);
     }
-    cursor = response?.nextCursor || null;
-    if (!cursor) break;
-    if (typeof cursor !== 'string' || cursors.has(cursor))
-      throw new CodexAppServerError('invalid_page', 'Codex repeated a conversation page cursor.');
-    cursors.add(cursor);
-  }
+  } finally { if (onPage && sessions.length && !signal?.aborted) await onPage(sessions); }
   const deadline = Date.now() + Math.max(1, Math.min(observationBudgetMs, 5000));
   // A recent page can omit an explicitly supervised conversation, including
   // a newly created desktop chat. Read its exact metadata without loading or
@@ -802,7 +807,11 @@ export async function executeCodexAppServer(record, { webOrigin, openClient = op
   const captureWorkspace = async () => {
     const files = [];
     const repository = await repositoryIdentity(taskDirectory(record), { signal }).catch(() => null);
-    try { const digest = await workspaceIdentity(taskDirectory(record), root, files, { signal }); return { digest, files, repository, potentiallyIncomplete: files.length === 256, at: Date.now() }; }
+    // Exploratory work must not spend minutes hashing build outputs before
+    // an AI can inspect the actual obstacle. Only optional preparation is
+    // bounded; outcome-review manifests below keep their complete checks.
+    const budget = !reviewing ? { maxEntries: 1024, maxBytes: 16 * 1024 * 1024, deadline: Date.now() + 1500 } : {};
+    try { const digest = await workspaceIdentity(taskDirectory(record), root, files, { signal, ...budget }); return { digest, files, repository, potentiallyIncomplete: files.length === 256, at: Date.now() }; }
     catch { return { unavailable: true, repository, reason: 'Workspace inventory unavailable; continue discovery and use available evidence.' }; }
   };
   const beforeEvidence = searchEnabled(run.managed) && !reviewing ? await captureWorkspace() : null;

package/src/session-supervision/continuation-readiness.js

@@ -0,0 +1,58 @@
+import { createHash } from 'node:crypto';
+
+const digest = value => createHash('sha256').update(JSON.stringify(value)).digest('hex');
+export const ANALYSIS_RETRY_DELAYS_MS = [30_000, 120_000];
+export const CONTINUATION_WAIT_NOTICE_MS = 15 * 60_000;
+
+// Observation timestamps and translated prose are intentionally excluded.
+export const continuationReadinessRevision = candidate => digest([
+  candidate.cwd, candidate.capabilities?.canAnalyze === true,
+  candidate.capabilities?.canContinue === true, candidate.capabilities?.canAutoContinue === true,
+  candidate.autoContinueAvailability?.canEnable, candidate.autoContinueAvailability?.reasonCode,
+  candidate.continuationReasonCode, candidate.continuationAdmission?.source,
+  candidate.continuationAdmission?.model, Boolean(candidate.continuationAdmission),
+  candidate.dispatchReadiness?.state, candidate.dispatchReadiness?.code,
+]);
+
+const retryable = new Set(['analysis_failed', 'analysis_invalid_result', 'analysis_unavailable',
+  'analysis_timeout', 'timeout', 'unavailable', 'context_unavailable', 'ETIMEDOUT',
+  'ECONNRESET', 'ECONNREFUSED', 'EAI_AGAIN']);
+export const retryableAnalysis = result => ['failed', 'uncertain'].includes(result?.state) &&
+  retryable.has(result.reasonCode || (result.state === 'failed' ? 'analysis_failed' : ''));
+
+export function automaticAnalysisRetryAllowed(candidate) {
+  return candidate.autoContinue === true && !candidate.archived && !candidate.localHidden &&
+    candidate.isRunning !== true && !['stopped', 'completed', 'approval', 'question'].includes(candidate.workState?.state) &&
+    candidate.autoContinueStatus !== 'needs_user';
+}
+
+export function continuationWaitReason(candidate) {
+  if (!automaticAnalysisRetryAllowed(candidate)) return null;
+  if (candidate.analysis?.state === 'needs_user' || candidate.analysis?.state === 'no_action' ||
+      candidate.analysis?.state === 'waiting' && candidate.analysis?.blocker?.type === 'external_dependency') return null;
+  if (candidate.analysis?.retry?.exhausted) return 'analysis_retry_exhausted';
+  if (['queued', 'analyzing'].includes(candidate.analysis?.state)) return 'analysis_pending';
+  if (candidate.autoContinueAvailability?.canEnable === false || candidate.capabilities?.canAutoContinue === false ||
+      candidate.capabilities?.canAnalyze === false || candidate.dispatchReadiness?.state === 'blocked') {
+    return candidate.autoContinueAvailability?.reasonCode || candidate.dispatchReadiness?.code || 'runtime_unavailable';
+  }
+  if (['error', 'recovering', 'starting', 'unavailable'].includes(candidate.autoContinueStatus)) return 'continuation_unavailable';
+  if (retryableAnalysis(candidate.analysis)) return candidate.analysis.reasonCode || 'analysis_failed';
+  return null;
+}
+
+export function observeContinuationWait(candidate, previous, now) {
+  const reasonCode = continuationWaitReason(candidate);
+  if (!reasonCode || !candidate.autoContinueEpoch) return null;
+  if (previous?.epoch === candidate.autoContinueEpoch && Number.isFinite(previous.since)) return { ...previous, reasonCode, status: candidate.autoContinueStatus };
+  return { id: digest([candidate.provider, candidate.session, candidate.autoContinueEpoch, now]),
+    epoch: candidate.autoContinueEpoch, since: now, reasonCode, status: candidate.autoContinueStatus, notified: false };
+}
+
+export function projectContinuationWait(candidate, wait, now, noticeAfterMs = CONTINUATION_WAIT_NOTICE_MS) {
+  if (!wait || wait.epoch !== candidate.autoContinueEpoch || !continuationWaitReason(candidate)) return candidate;
+  const needsAttention = wait.reasonCode === 'analysis_retry_exhausted' || now - wait.since >= noticeAfterMs;
+  return { ...candidate, continuationWait: { id: wait.id, since: wait.since, reasonCode: wait.reasonCode, needsAttention },
+    ...(needsAttention ? { autoContinueStatus: 'needs_user',
+      autoContinueReason: 'Auto Continue is saved, but work has been waiting for execution conditions. Check the original conversation or refresh its connection.' } : {}) };
+}

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

@@ -72,9 +72,9 @@ export function sessionDecisionPresentation(candidate, run) {
     title: pair('続けるために、この点を教えてください', 'Answer to continue'), question: pair(clean(question.text), clean(question.text)),
     context: pair('回答を受け取ってから目的を確認し、許可された作業を続けます。', 'After your answer, AI checks the goal and continues within the existing permissions.'),
   }, { answerFields: { ...control, taskId: run.taskId, questionId: question.id }, choices: [] });
-  if (candidate.isRunning || run?.dependencyWait || run?.autoRecovery && ['recovery_required', 'auto_resuming'].includes(run.state) ||
+  if (candidate.isRunning && candidate.workState?.stale !== true || run?.dependencyWait || run?.autoRecovery && ['recovery_required', 'auto_resuming'].includes(run.state) ||
       ['supervising', 'watching', 'waiting', 'starting', 'recovering'].includes(candidate.autoContinueStatus)) return null;
-  if (run && (['recovery_required', 'paused', 'failed', 'blocked'].includes(run.state) || run.state === 'verification_pending' && run.canResume)) {
+  if (run && (['recovery_required', 'paused', 'failed', 'blocked', 'stopped'].includes(run.state) || run.state === 'verification_pending' && run.canResume)) {
     const acceptancePending = run.state === 'verification_pending';
     const providerName = candidate.provider === 'claude' ? 'Claude' : candidate.provider === 'codex' ? 'Codex' : 'AI';
     const reasons = {
@@ -85,11 +85,13 @@ export function sessionDecisionPresentation(candidate, run) {
       hook_owner_mismatch: pair('元のAI会話の接続が変わりました。', 'The connection to the original AI session changed.'),
     };
     const reason = acceptancePending ? pair('最終確認は未完了ですが、許可済みの残作業を続けられます。再開しても検証済みにはなりません。', 'Acceptance is still pending. Authorized remaining work can continue without marking the result verified.')
+      : run.state === 'stopped' ? pair('中断・停止が記録されています。再開を選ぶまで作業は続けません。', 'An interruption or stop is recorded. Work waits for an explicit resume choice.')
       : run.state === 'paused' ? pair('この作業は停止中です。停止の指示は自動で解除しません。', 'This work is paused. A stop instruction is never cleared automatically.')
       : reasons[run.recoveryCause] || pair('作業を続けるための条件を確認できていません。', 'The conditions for continuing have not been established.');
     const choices = [];
     if (run.canReplan && frozen) choices.push(choice(pair('AIに状況確認を任せる', 'Ask AI to investigate'), pair('目的・履歴・制限を維持して原因と安全な次の手順を調べます。操作の許可を追加することはありません。', 'Investigate the cause and next steps while keeping the goal, history and limits. No new permission is granted.'), 'delivery_replan', {}, 'primary'));
-    if (run.canResume && frozen) choices.push(choice(pair(acceptancePending ? '未完了の作業を続ける' : '再開を依頼する', acceptancePending ? 'Continue remaining work' : 'Request resume'), pair(acceptancePending ? '元の目的・履歴・制限を維持して残作業を確認します。最終確認を済ませたことにはしません。' : '保存した目的と履歴を引き継ぎます。接続や権限が不足する場合は、その内容を案内します。', acceptancePending ? 'Keep the goal, history and limits while checking what remains. This does not accept the result.' : 'Keep the saved goal and history. Any missing connection or permission will be shown.'), 'delivery_resume', {}, choices.length ? 'secondary' : 'primary'));
+    const enablesAutoContinue = candidate.provider === 'codex' && run.managed !== true && run.state === 'stopped' && candidate.autoContinue !== true;
+    if (run.canResume && frozen) choices.push(choice(pair(enablesAutoContinue ? '自動継続をオンにして再開' : acceptancePending ? '未完了の作業を続ける' : '再開を依頼する', enablesAutoContinue ? 'Resume with Auto Continue' : acceptancePending ? 'Continue remaining work' : 'Request resume'), pair(enablesAutoContinue ? '自動継続をオンにして元の会話の読み取り専用の状況確認から再開します。元の目的・権限・停止履歴・予算を維持します。' : acceptancePending ? '元の目的・履歴・制限を維持して残作業を確認します。最終確認を済ませたことにはしません。' : '保存した目的と履歴を引き継ぎます。接続や権限が不足する場合は、その内容を案内します。', enablesAutoContinue ? 'Turn on Auto Continue and resume with read-only diagnosis in the original conversation. Preserve its goal, permissions, stop history and budgets.' : acceptancePending ? 'Keep the goal, history and limits while checking what remains. This does not accept the result.' : 'Keep the saved goal and history. Any missing connection or permission will be shown.'), 'delivery_resume', {}, choices.length ? 'secondary' : 'primary'));
     choices.push(choice(pair(`元の${providerName}会話を開く`, 'Open original conversation ↗'), pair('接続や権限の確認が必要な場合、元のAI会話で確認できます。会話を開くだけでは作業を再開しません。', 'Check the original conversation. Opening it does not resume work.'), 'open_original', {}, 'link'));
     if (candidate.autoContinue === true) choices.push(choice(pair('自動継続をオフにする', 'Turn off Auto Continue'), pair('今後の自動継続をオフにします。作業の履歴は残ります。', 'Turn off future automatic continuation and retain the history.'), 'session_set_auto_continue', { ...identity, enabled: false }));
     const actionable = frozen && (run.canReplan || run.canResume);
@@ -106,6 +108,12 @@ export function sessionDecisionPresentation(candidate, run) {
     context: pair('自動継続はオフです。オンにすると、元の目的と権限の範囲で残作業を確認します。結果を受け入れる操作ではありません。', 'Auto Continue is off. Turning it on checks remaining work within the original goal and permissions. It does not accept the result.'),
   }, { choices: [choice(pair('自動継続をオンにする', 'Turn on Auto Continue'), pair('自動継続の設定を保存します。作業の開始や完了を証明するものではありません。', 'Save consent for Auto Continue. This does not confirm that work started or finished.'), 'session_set_auto_continue', { ...identity, enabled: true }, 'primary'),
     choice(pair('元の会話を開く', 'Open original conversation ↗'), pair('会話を開くだけでは作業を再開しません。', 'Opening the conversation does not resume work.'), 'open_original', {}, 'link')] });
+  if (candidate.continuationWait?.needsAttention === true && candidate.autoContinue === true) return model('continuation_wait', {
+    title: pair('自動継続の条件を確認してください', 'Check Auto Continue conditions'),
+    question: pair('自動継続はオンのまま、実行条件の確認を待っています。元の会話や接続状態を確認してください。', 'Auto Continue is still on, waiting for execution conditions. Check the original conversation or its connection.'),
+    context: pair('設定・目的・停止指示・承認待ちは維持しています。この通知で作業を再開したり、権限を追加したりしません。', 'The setting, goal, stops and pending approvals are preserved. This notice does not resume work or grant permission.'),
+  }, { choices: [choice(pair('状況を再確認する', 'Refresh status'), pair('条件を再確認します。', 'Recheck conditions.'), 'refresh', identity),
+    choice(pair('元の会話を開く', 'Open original conversation ↗'), pair('元の会話を確認します。', 'Check the original conversation.'), 'open_original', {}, 'link')] }, 'helper');
   if (candidate.autoContinueStatus === 'needs_user' || candidate.analysis?.state === 'needs_user') return model('unresolved', {
     title: pair('必要な判断内容を確認します', 'Check what needs a decision'),
     question: pair('判断していただく内容をまだ特定できていません。具体的な内容が分かるまで、操作の許可は求めません。', 'The required decision has not been identified. No approval is requested until it is clear.'),