@awak-app/simy-cli 0.5.42 → 0.5.44

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

@@ -0,0 +1,81 @@
+import { continueSession, readSessionAutoContinue } from './index.js';
+import { readContinuationContext } from './continuation-analysis.js';
+
+// Shared by explicit Continue and automatic enrollment. Analysis alone never
+// dispatches work: the exact current provider context is checked again here.
+export async function continueAnalyzedSession({ candidate, manager, root, settings = {}, signal,
+  readContext = readContinuationContext, enroll = continueSession, beforeEnroll = () => {} }) {
+  const recommendation = manager.requireRecommendation(candidate);
+  if (candidate.isRunning || candidate.capabilities?.canContinue !== true) throw new Error('Automatic continuation 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);
+    throw new Error('This conversation changed; wait for its updated analysis.');
+  }
+  manager.requireRecommendation(candidate);
+  await beforeEnroll();
+  if (signal?.aborted) throw new Error('Automatic continuation was cancelled before enrollment.');
+  return enroll({ root, provider: candidate.provider, session: candidate.session, ...settings });
+}
+
+// One pending enrollment per identity. A failed attempt is retried only after
+// context/opt-in changes; an existing (including terminal) run is never reset.
+export function createAutomaticContinuation({ root, getManager, selectCandidate,
+  readSetting = readSessionAutoContinue, readContext = readContinuationContext, enroll = continueSession,
+  onChange = () => {} }) {
+  const pending = new Map(), attempted = new Map(), errors = new Map();
+  let closed = false;
+  const tick = candidates => {
+    if (closed) return;
+    for (const candidate of candidates) {
+      if (pending.size >= 3) break;
+      if (candidate.autoContinue !== true || !candidate.autoContinueEpoch || candidate.isRunning ||
+          candidate.capabilities?.canAutoContinue !== true || candidate.capabilities?.canContinue !== true) continue;
+      const key = `${candidate.provider}:${candidate.session}`;
+      if (pending.has(key)) continue;
+      let recommendation;
+      const manager = getManager();
+      try { recommendation = manager.requireRecommendation(candidate); } catch { continue; }
+      const attempt = `${candidate.autoContinueEpoch}:${recommendation.contextDigest}`;
+      if (attempted.get(key) === attempt) continue;
+      attempted.set(key, attempt);
+      errors.delete(key);
+      const controller = new AbortController();
+      const guard = async () => {
+        const setting = await readSetting({ root, provider: candidate.provider, session: candidate.session });
+        if (closed || controller.signal.aborted || !setting.enabled || setting.epoch !== candidate.autoContinueEpoch || setting.hasRun) throw new Error('Automatic continuation was disabled or already enrolled.');
+        return setting;
+      };
+      const job = Promise.resolve().then(async () => {
+        const setting = await guard();
+        const fresh = await selectCandidate(candidate);
+        if (!fresh.autoContinue || fresh.autoContinueEpoch !== candidate.autoContinueEpoch) throw new Error('Automatic continuation setting changed.');
+        await continueAnalyzedSession({ root, candidate: fresh, manager, signal: controller.signal,
+          readContext, enroll, beforeEnroll: guard,
+          settings: { ...setting.settings, autoContinueEpoch: candidate.autoContinueEpoch } });
+      }).catch(error => {
+        if (!closed && !controller.signal.aborted && !/disabled|already enrolled|setting changed|conversation changed; wait|needs a current recommendation/i.test(error?.message || '')) {
+          errors.set(key, { epoch: candidate.autoContinueEpoch, reason: 'Could not start auto-continue. Check the original conversation and retry.' });
+        }
+      }).finally(() => { pending.delete(key); if (!closed) onChange(); });
+      pending.set(key, { job, controller });
+    }
+  };
+  return { tick,
+    retry(provider, session) {
+      const key = `${provider}:${session}`;
+      if (!closed && !pending.has(key)) { attempted.delete(key); errors.delete(key); }
+    },
+    project(candidate) {
+      const error = errors.get(`${candidate.provider}:${candidate.session}`);
+      if (candidate.autoContinue === true && candidate.autoContinueEpoch === error?.epoch && candidate.capabilities?.canContinue === true &&
+          !['no_action', 'needs_user', 'waiting', 'uncertain'].includes(candidate.analysis?.state)) return {
+        ...candidate, autoContinueStatus: 'error', autoContinueReason: error.reason,
+      };
+      return candidate;
+    },
+    revoke(provider, session) { pending.get(`${provider}:${session}`)?.controller.abort(); },
+    async whenIdle() { await Promise.allSettled([...pending.values()].map(entry => entry.job)); },
+    async close() { closed = true; for (const entry of pending.values()) entry.controller.abort(); await Promise.allSettled([...pending.values()].map(entry => entry.job)); },
+  };
+}

package/src/session-supervision/index.js

@@ -1,9 +1,26 @@
 import { realpath } from 'node:fs/promises';
-import { controlDelivery, listRecords, processIdentity, startDelivery, updateRecord } from '../codex-plugins/simy/hooks/delivery-loop.mjs';
+import { randomUUID } from 'node:crypto';
+import { TERMINAL as TERMINAL_RUNS, controlDelivery, listRecords, processIdentity, startDelivery, updateRecord } from '../codex-plugins/simy/hooks/delivery-loop.mjs';
 import { listCodexSessions, openCodexAppServer, readCodexSession } from './codex-app-server.js';
 import { listClaudeSessions, readClaudeSession } from './claude-sessions.js';
 import { originalSessionTarget } from './original-session-target.js';
 
+function autoContinueState(record, isRunning, supported) {
+  if (record?.autoContinue !== true) return { autoContinueStatus: 'off', autoContinueReason: null };
+  const state = record.run?.state;
+  if (state === 'budget_exhausted') return { autoContinueStatus: 'limit', autoContinueReason: 'This conversation reached its continuation limit. Its budgets cannot be reset.' };
+  if (['completed', 'reported_done'].includes(state)) return { autoContinueStatus: 'finished', autoContinueReason: 'Bounded continuation finished for this conversation.' };
+  const managed = record.run?.managed;
+  const recoverableCause = record.run?.recoveryCause === 'process_exit' || managed?.resumeChannel === 'codex_app_server' && ['session_supervision', 'approved_action'].includes(record.run?.recoveryCause);
+  if (state === 'recovery_required' && (!managed?.autoRecovery || !recoverableCause || managed.pendingApproval)) return {
+    autoContinueStatus: 'needs_user', autoContinueReason: 'Existing supervision needs your attention before more work can continue.',
+  };
+  if (['paused', 'blocked', 'stopped', 'failed', 'verification_pending'].includes(state)) return { autoContinueStatus: 'needs_user', autoContinueReason: 'Existing supervision needs your attention before more work can continue.' };
+  if (!supported) return { autoContinueStatus: 'unavailable', autoContinueReason: 'The original provider continuation channel is unavailable.' };
+  return { autoContinueStatus: record.run ? 'supervising' : isRunning ? 'waiting' : 'watching',
+    autoContinueReason: record.run ? 'Continuing within the existing task budget.' : isRunning ? 'Waiting for the original turn to finish.' : 'Checking settled requests for worthwhile remaining work.' };
+}
+
 function initialDiagnosisPlan(objective, contextBootstrap = false) {
   const action = { kind: 'read', scope: 'task', summary: contextBootstrap ? 'Understand the original user request and current progress without changing files' : 'Inspect the selected conversation and acceptance evidence without changing files' };
   return {
@@ -36,7 +53,7 @@ export async function discoverSessions({ root, openClient = openCodexAppServer,
   const records = await listRecords(root);
   let discovered = [], codexError = null, claude = [], claudeError = null;
   try { discovered = await withClient(openClient, client => listCodexSessions({ client, inspectState: true,
-    prioritySessions: records.filter(record => record.provider === 'codex' && (record.monitor || record.tracked || record.run)).map(record => record.session) })); }
+    prioritySessions: records.filter(record => record.provider === 'codex' && (record.autoContinue || record.monitor || record.tracked || record.run)).map(record => record.session) })); }
   catch (error) { codexError = error?.code === 'unavailable' ? 'Codex executable unavailable.' : error?.code === 'unsupported' ? 'This Codex version lacks a verified app-server writer lock; update before enrollment.' : 'Codex conversation discovery unavailable.'; }
   try { claude = await listClaude(); } catch { claudeError = 'Claude conversation discovery unavailable.'; }
   const byKey = new Map();
@@ -70,13 +87,18 @@ export async function discoverSessions({ root, openClient = openCodexAppServer,
       ...(item.providerGoal !== undefined ? { providerGoal: item.providerGoal } : {}),
       ...(item.goalReadState ? { goalReadState: item.goalReadState } : {}),
       tracked: typeof record?.tracked === 'boolean' ? record.tracked : record?.monitor === true,
+      autoContinue: record?.autoContinue === true,
+      autoContinueEpoch: record?.autoContinue === true ? record.autoContinueEpoch : null,
+      ...autoContinueState(record, isRunning, supported || liveHook),
       lastActivityAt: item.lastActivityAt, observation: item.observation, availability: item.availability,
-      binding: { mode, taskId: run?.managed?.taskId || null },
+      taskId: run?.managed?.taskId || record?.associationTaskId || null,
+      binding: { mode, taskId: run?.managed?.taskId || record?.associationTaskId || null },
       originalSessionTarget: originalSessionTarget(item.provider, item.session),
       continuationMode: item.provider === 'claude' ? liveHook ? 'live_hook' : 'manual' : supported ? 'codex_app_server' : 'manual',
       capabilities: { canMonitor: item.capabilities?.canMonitor ?? true,
         canAnalyze: !run && (item.provider === 'codex' ? item.observation.source === 'codex_app_server' && !codexError : item.observation.source === 'claude_local_index' && !claudeError),
-        canEnroll: (supported || liveHook) && !run, canContinue: (supported || liveHook) && !run, canAutoContinue: supported || liveHook },
+        canEnroll: (supported || liveHook) && !run, canContinue: (supported || liveHook) && !run,
+        canAutoContinue: (supported || liveHook) && (!run || Boolean(run.managed) && !TERMINAL_RUNS.has(run.state)) },
       reason: item.provider === 'claude' ? liveHook ? 'Live SIMY hook can continue this Claude session at its next Stop boundary; cold CLI takeover is unavailable.' :
         process.platform === 'win32' ? 'Claude live hook enrollment is unavailable on Windows because provider process identity cannot be verified; monitoring remains available.' :
           'Claude enrollment needs a live matching SIMY SessionStart hook and provider process; cold CLI takeover is unavailable.' :
@@ -85,11 +107,37 @@ export async function discoverSessions({ root, openClient = openCodexAppServer,
   }))).sort((a, b) => (b.lastActivityAt || 0) - (a.lastActivityAt || 0));
   // Keep existing bindings visible during a truncated discovery or provider
   // outage, even when newer unbound conversations fill the candidate window.
-  const bound = projected.filter(item => item.binding.mode !== 'unmanaged');
-  const sessions = [...bound, ...projected.filter(item => item.binding.mode === 'unmanaged').slice(0, Math.max(0, 200 - bound.length))];
+  const bound = projected.filter(item => item.autoContinue || item.binding.mode !== 'unmanaged');
+  const sessions = [...bound, ...projected.filter(item => !item.autoContinue && item.binding.mode === 'unmanaged').slice(0, Math.max(0, 200 - bound.length))];
   return { sessions, providers: { codex: { discovery: codexError ? 'unavailable' : 'ready', reason: codexError }, claude: { discovery: claudeError ? 'unavailable' : 'local_index', reason: claudeError } }, refreshedAt: now };
 }
 
+// Explicit execution authority: legacy monitor/tracked records stay read-only.
+export async function setSessionAutoContinue({ root, provider, session, enabled, ...options }) {
+  if (!['codex', 'claude'].includes(provider) || typeof enabled !== 'boolean') throw new Error('Unsupported automatic continuation request.');
+  if (enabled) await trackSession({ root, provider, session, tracked: true, ...options });
+  return updateRecord(root, provider, session, async previous => {
+    if (!previous) throw new Error('Refresh this conversation before changing automatic continuation.');
+    if (enabled && previous.run && !previous.run.managed) throw new Error('Automatic continuation is unavailable for this conversation.');
+    if (enabled && TERMINAL_RUNS.has(previous.run?.state)) throw new Error('Bounded continuation finished or reached its limit; budgets cannot be reset.');
+    if (enabled && provider === 'codex' && !previous.admission?.model) throw new Error('Automatic continuation is unavailable for this conversation.');
+    if (enabled && provider === 'claude' && !await liveClaudeHook(previous,
+      { session, cwd: previous.cwd, observation: { source: previous.admission?.source } }, options.inspectProcess || processIdentity)) throw new Error('Claude needs a live matching SIMY SessionStart hook; cold CLI takeover is unavailable.');
+    const epoch = previous.autoContinue === enabled && previous.autoContinueEpoch ? previous.autoContinueEpoch : randomUUID();
+    const next = { ...previous, autoContinue: enabled, autoContinueEpoch: epoch,
+      ...(enabled ? { tracked: true, monitor: true, autoContinueSettings: { autonomyPolicy: 'balanced', maxMinutes: 30, maxContinuations: 6, maxFailures: 3 } } : { tracked: false, monitor: false }) };
+    // Adopt existing supervision without restarting it or renewing its budgets.
+    if (next.run?.managed) next.run.managed.autoContinueEpoch = epoch;
+    return next;
+  });
+}
+
+export async function readSessionAutoContinue({ root, provider, session }) {
+  const record = (await listRecords(root)).find(item => item.provider === provider && item.session === session);
+  return { enabled: record?.autoContinue === true, epoch: record?.autoContinueEpoch || null,
+    settings: record?.autoContinueSettings, hasRun: Boolean(record?.run) };
+}
+
 // Tracking is local observation metadata. It neither starts nor stops the
 // original provider task and never grants automatic continuation authority.
 export async function trackSession({ root, provider, session, tracked = true, openClient = openCodexAppServer, readClaude = readClaudeSession, now = Date.now() }) {
@@ -133,7 +181,7 @@ export async function monitorSession({ root, provider, session, monitor = true,
 }
 
 export async function enrollSession({ root, provider, session, objective, acceptanceCriteria, contextBootstrap = false, autonomyPolicy = 'balanced',
-  maxMinutes = 30, maxContinuations = 6, maxFailures = 3, maxNoProgressMinutes, maxTokens, openClient = openCodexAppServer,
+  maxMinutes = 30, maxContinuations = 6, maxFailures = 3, maxNoProgressMinutes, maxTokens, autoContinueEpoch, openClient = openCodexAppServer,
   readClaude = readClaudeSession, inspectProcess = processIdentity, now = Date.now() }) {
   if (!['codex', 'claude'].includes(provider)) throw new Error('This provider does not have a verified exact-session enrollment channel.');
   if (maxTokens !== undefined && provider !== 'codex') throw new Error('Token-budgeted supervision requires host-observed Codex usage; Claude live hooks cannot enforce this budget.');
@@ -159,7 +207,7 @@ export async function enrollSession({ root, provider, session, objective, accept
   const admission = provider === 'codex' ? { source: 'codex_app_server', provider, session, cwd, model: metadata.model } : undefined;
   const liveRecord = provider === 'claude' ? (await listRecords(root)).find(item => item.provider === provider && item.session === session) : null;
   const run = await startDelivery({ root, provider, session, cwd, objective: objective.trim(), nextStep: 'Inspect current evidence and propose the next assessed action.',
-    maxMinutes, maxContinuations, maxFailures, now, admission, inspectProcess,
+    maxMinutes, maxContinuations, maxFailures, now, admission, inspectProcess, autoContinueEpoch,
     liveHookAdmission: liveRecord ? { hookStartedAt: liveRecord.hookStartedAt, pid: liveRecord.process.pid, identity: liveRecord.process.identity } : undefined,
     managed: { acceptanceCriteria, contextBootstrap, autonomyPolicy, maxNoProgressMinutes, maxTokens, approvalScopes: ['task'], approvalPolicy: 'wait',
       initialAction: initialPlan.alternatives[0].action, initialPlan, remainingWork: objective.trim(),