@awak-app/simy-cli 0.6.2 → 0.6.5

package/src/session-supervision/index.js

@@ -5,6 +5,7 @@ import { listCodexSessions, openCodexAppServer, readCodexSession, CodexAppServer
 import { listClaudeSessions, readClaudeSession } from './claude-sessions.js';
 import { originalSessionTarget } from './original-session-target.js';
 import { readCodexTitles, sessionTitle } from './session-titles.js';
+import { RECENT_SESSION_LIMIT, recentSessionWindow, retainedSession } from './discovery-window.js';
 
 function autoContinueState(record, isRunning, supported) {
   if (record?.autoContinue !== true) return { autoContinueStatus: 'off', autoContinueReason: null };
@@ -58,28 +59,34 @@ export async function discoverSessions({ root, openClient = openCodexAppServer,
   const assertActive = () => { if (signal?.aborted) throw new CodexAppServerError('cancelled', 'Conversation discovery was cancelled.'); };
   assertActive();
   const records = await listRecords(root);
+  const priorities = records.filter(retainedSession);
   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.autoContinue || record.monitor || record.tracked || record.run)).map(record => record.session) }), signal); }
+    maxSessions: RECENT_SESSION_LIMIT,
+    prioritySessions: priorities.filter(record => record.provider === 'codex').map(record => record.session) }), signal); }
   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.'; }
   assertActive();
-  try { claude = await listClaude({ signal }); } catch { claudeError = 'Claude conversation discovery unavailable.'; }
+  try { claude = await listClaude({ signal, limit: RECENT_SESSION_LIMIT,
+    prioritySessions: priorities.filter(record => record.provider === 'claude').map(record => record.session) }); }
+  catch { claudeError = 'Claude conversation discovery unavailable.'; }
   assertActive();
   const byKey = new Map();
   const recordsByKey = new Map(records.map(record => [`${record.provider}:${record.session}`, record]));
   for (const item of [...discovered, ...claude]) byKey.set(`${item.provider}:${item.session}`, item);
   for (const record of records) {
     const key = `${record.provider}:${record.session}`;
-    if (!byKey.has(key) && (record.observedAt || record.admission || record.monitor || record.run)) byKey.set(key, {
+    if (!byKey.has(key) && (record.observedAt || record.admission || retainedSession(record))) byKey.set(key, {
       provider: record.provider, session: record.session, cwd: record.cwd, title: '', source: record.admission?.source || 'hook',
       lastActivityAt: record.observedAt || record.admission?.validatedAt || record.run?.updatedAt || null,
       observation: { source: record.admission?.source || `${record.provider}_hook`, observedAt: record.observedAt || record.admission?.validatedAt || null },
       availability: 'unknown', model: record.admission?.model || null,
     });
   }
-  // Historical sessions must not fan out hundreds of process-inspection
-  // subprocesses. Preserve input ordering while limiting live metadata probes.
-  const items = [...byKey.values()], projected = new Array(items.length);
+  // Select recent history before live probes, keeping explicit supervision
+  // visible even during a truncated discovery or provider outage.
+  const items = recentSessionWindow([...byKey.values()], {
+    priority: item => retainedSession(recordsByKey.get(`${item.provider}:${item.session}`)),
+  }), projected = new Array(items.length);
   const codexTitles = items.some(item => item.provider === 'codex' && !sessionTitle(item.title)) ? await listCodexTitles() : new Map();
   assertActive();
   let nextItem = 0;
@@ -136,15 +143,11 @@ export async function discoverSessions({ root, openClient = openCodexAppServer,
   }));
   assertActive();
   projected.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.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 };
+  return { sessions: projected, 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, continuationPolicy, hardMaxMinutes, hardMaxContinuations, providerTokenCeiling, ...options }) {
+export async function setSessionAutoContinue({ root, provider, session, enabled, continuationPolicy, ...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 => {
@@ -155,18 +158,13 @@ export async function setSessionAutoContinue({ root, provider, session, enabled,
     if (enabled && provider === 'claude') await requireClaudeChannel(previous,
       { session, cwd: previous.cwd, observation: { source: previous.admission?.source } }, options.inspectProcess || processIdentity);
     const epoch = previous.autoContinue === enabled && previous.autoContinueEpoch ? previous.autoContinueEpoch : randomUUID();
-    const settings = { autonomyPolicy: 'balanced', maxMinutes: 30, maxContinuations: 6, maxFailures: 3,
-      ...previous.autoContinueSettings,
-      ...(continuationPolicy === undefined ? {} : { continuationPolicy }),
-      ...(hardMaxMinutes === undefined ? {} : { hardMaxMinutes }),
-      ...(hardMaxContinuations === undefined ? {} : { hardMaxContinuations }),
-      ...(providerTokenCeiling === undefined ? {} : { providerTokenCeiling }) };
+    // Settings persisted by older versions may carry removed time, turn and
+    // token caps; only the fields that still govern a task are forwarded.
+    const { autonomyPolicy = 'balanced', maxFailures = 3, continuationPolicy: savedPolicy } = previous.autoContinueSettings || {};
+    const settings = { autonomyPolicy, maxFailures,
+      ...(continuationPolicy ?? savedPolicy) === undefined ? {} : { continuationPolicy: continuationPolicy ?? savedPolicy } };
     if (settings.continuationPolicy !== undefined && !['bounded', 'progress'].includes(settings.continuationPolicy)) throw new Error('Choose a continuation policy.');
-    for (const [key, maximum] of [['hardMaxMinutes', 1440], ['hardMaxContinuations', 50], ['providerTokenCeiling', 15_000_000]]) {
-      if (settings[key] !== undefined && (!Number.isSafeInteger(settings[key]) || settings[key] < 1 || settings[key] > maximum)) throw new Error('Invalid continuation ceiling.');
-    }
-    if (providerTokenCeiling !== undefined && provider !== 'codex') throw new Error('Token ceilings require host-observed Codex usage.');
-    if (previous.run && [continuationPolicy, hardMaxMinutes, hardMaxContinuations, providerTokenCeiling].some(value => value !== undefined)) throw new Error('Change an existing task through its explicit continuation controls.');
+    if (previous.run && continuationPolicy !== undefined) throw new Error('Change an existing task through its explicit continuation controls.');
     const next = { ...previous, autoContinue: enabled, autoContinueEpoch: epoch,
       ...(enabled ? { tracked: true, monitor: true, autoContinueSettings: settings } : { tracked: false, monitor: false }) };
     // Adopt existing supervision without restarting it or renewing its budgets.
@@ -224,7 +222,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, continuationPolicy, hardMaxMinutes, hardMaxContinuations, providerTokenCeiling, autoContinueEpoch, openClient = openCodexAppServer,
+  maxFailures = 3, maxNoProgressMinutes, continuationPolicy, 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 (typeof objective !== 'string' || !objective.trim() || objective.length > 4000) throw new Error('A concrete objective is required.');
@@ -249,13 +247,13 @@ 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 readRecord(root, provider, 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, continuationPolicy, hardMaxMinutes, hardMaxContinuations, providerTokenCeiling, now, admission, inspectProcess, autoContinueEpoch,
+    maxFailures, continuationPolicy, 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',
+    managed: { acceptanceCriteria, contextBootstrap, autonomyPolicy, maxNoProgressMinutes, approvalScopes: ['task'], approvalPolicy: 'wait',
       initialAction: initialPlan.alternatives[0].action, initialPlan, remainingWork: objective.trim(),
       autoRecovery: provider === 'codex', resumeChannel: provider === 'codex' ? 'codex_app_server' : null,
       resumeModel: metadata.model } });
-  return { provider, session, taskId: run.run.managed.taskId, state: run.run.state, deadline: run.run.deadline };
+  return { provider, session, taskId: run.run.managed.taskId, state: run.run.state };
 }
 
 export async function continueSession(options) {

package/src/session-supervision/stop-notifications.js

@@ -0,0 +1,43 @@
+import { createHash } from 'node:crypto';
+import { deliveryStop } from '../codex-plugins/simy/hooks/delivery-loop.mjs';
+
+// Auto-continue works while nobody is watching, so a person must learn when it
+// stops. Map a stopped run to a notification kind; the native window owns copy.
+export function stopNotificationKind(run, now = Date.now()) {
+  if (!run?.managed?.autoContinueEpoch) return null;
+  // The clock keeps aging while paused; the persisted human decision takes
+  // precedence over a threshold that was reached only after that decision.
+  if (run.state === 'paused') return run.reason === 'Paused by user.' ? null : deliveryStop(run, now) ? 'paused' : null;
+  if (run.state === 'blocked' || run.state === 'verification_pending') return 'needs_decision';
+  if (run.state === 'recovery_required' && run.managed.autoRecovery !== true) return 'needs_decision';
+  if (run.state === 'failed' || run.state === 'budget_exhausted') return 'failed';
+  if (run.state === 'completed' || run.state === 'reported_done') return 'finished';
+  return null;
+}
+
+// The first observation is a baseline: restarting SIMY must not replay alerts
+// for runs that stopped earlier. Each distinct stop is announced once.
+export function createStopNotifier({ emit, now = Date.now } = {}) {
+  // Retain one stop fingerprint per currently observed task, rather than an
+  // event cache whose eviction could replay the entire historical baseline.
+  const seen = new Map();
+  let baseline = true;
+  return {
+    observe(records) {
+      const present = new Set();
+      for (const record of records) {
+        const run = record?.run, kind = stopNotificationKind(run, now());
+        const key = JSON.stringify([record.provider, record.session, run?.managed?.taskId]);
+        present.add(key);
+        if (!kind) { seen.delete(key); continue; }
+        const id = createHash('sha256').update(JSON.stringify([record.provider, record.session, run.managed.taskId, run.state, run.revision, run.reason])).digest('hex').slice(0, 32);
+        if (seen.get(key) === id) continue;
+        seen.set(key, id);
+        if (!baseline) emit({ type: 'notify', id, kind, provider: record.provider, session: record.session,
+          objective: String(run.objective || '').slice(0, 200) });
+      }
+      for (const key of seen.keys()) if (!present.has(key)) seen.delete(key);
+      baseline = false;
+    },
+  };
+}