@awak-app/simy-cli 0.7.26 → 0.7.28

package/src/delivery-hooks/supervisor.js

@@ -21,6 +21,7 @@ import { hasPendingUserStop, recordPath, canExecuteAutonomousExternal, automatic
 import { resolveBackendExecutable } from '../backend-executable.js';
 import { safeProviderFailure, providerEnvironmentIdentity, checkProviderRetry } from '../session-supervision/provider-failure.js';
 import { executeCodexAppServer, inspectCodexAppServer } from '../session-supervision/codex-app-server.js';
+import { reconcileNativeHandoff } from '../session-supervision/native-handoff.js';
 import { acquireWorkspaceLease, leaseOwnerDead } from '../session-supervision/workspace-lease.js';
 import { createTaskPool } from '../codex-plugins/simy/hooks/loop-kernel.mjs';
 
@@ -158,11 +159,22 @@ export async function executeCodexResume(record, { signal, root, leaseId, execut
   });
 }
 
-export async function tickManagedTasks({ root, webOrigin, now = Date.now(), execute, inspectProcess = processIdentity, signal, beforeClaim, authorizeDispatch, readRecords, observeTurn, observeAuthentication, inspectProvider = inspectCodexAppServer, shouldYield } = {}) {
+export async function tickManagedTasks({ root, webOrigin, now = Date.now(), execute, inspectProcess = processIdentity, signal, beforeClaim, authorizeDispatch, readRecords, observeTurn, observeAuthentication, inspectProvider = inspectCodexAppServer, shouldYield, nativeHandoff = reconcileNativeHandoff } = {}) {
   const tickWallStart = Date.now();
   const currentTime = () => now + Math.max(0, Date.now() - tickWallStart);
   if (signal?.aborted) return;
-  const readCandidates = readRecords || (() => listRecords(root));
+  const sourceRecords = readRecords || (() => listRecords(root)), nativeOwned = new Set();
+  const selected = await sourceRecords(), identity = r => `${r.provider}:${r.session}`;
+  const selectedIds = new Set(selected.map(identity));
+  // OFF changes the consent epoch and removes a task from a scoped activation.
+  // Still reconcile its old native queue on reconnect, without admitting work
+  // outside this supervisor's selected scope.
+  const cancellationOnly = readRecords ? (await listRecords(root)).filter(r => r.run?.managed?.nativeHandoff && !selectedIds.has(identity(r))) : [];
+  for (const record of [...selected, ...cancellationOnly]) {
+    if (signal?.aborted || await shouldYield?.()) return;
+    if ((!execute || record.run?.managed?.nativeHandoff) && await nativeHandoff({ root, record, signal, authorize: authorizeDispatch, cancelOnly: !selectedIds.has(identity(record)) })) nativeOwned.add(identity(record));
+  }
+  const readCandidates = async () => (await sourceRecords()).filter(r => !nativeOwned.has(`${r.provider}:${r.session}`));
   await reconcilePurposeTasks({ root, signal, now, observeTurn, observeAuthentication, readRecords: readCandidates });
   await reconcileRecords({ root, now, ...(inspectProcess ? { inspectProcess } : {}), records: await readCandidates() });
   if (signal?.aborted) return;

package/src/desktop-host.js

@@ -763,7 +763,6 @@ export async function startDesktopHost({ input = process.stdin, output = process
         scope: requestedScope,
         deviceSession: localCliApiSession(),
       });
-      stopNotifier.observe(records);
       const projection = await actionAssociations.beginProjection?.({ records });
       status.deliveryHooks = await (dependencies.deliveryHookStatus || deliveryHookStatus)({ root: deliveryRoot, records: projection?.records || records }).catch(() => ({ error: "Delivery hook status unavailable", providers: {}, runs: [] }));
       await actionAssociations.decorate(status.deliveryHooks, projection);
@@ -822,7 +821,12 @@ export async function startDesktopHost({ input = process.stdin, output = process
         status = { ...structuredClone(latestConnectionStatus), deliveryHooks: status.deliveryHooks, sessionSupervision: status.sessionSupervision };
       }
       status.teamThreads = teamThreads?.snapshot();
-      if (!closed && !relay) emitStatus(status);
+      if (!closed && !relay) {
+        // Native stop admission waits for this authorized projection, so an old
+        // running frame cannot suppress a newly stopped conversation.
+        stopNotifier.observe(records);
+        emitStatus(status);
+      }
     }).finally(() => { publishing = null; if (publishAgain && !closed) { publishAgain = false; setImmediate(() => { void publish().catch(() => {}); }); } });
     return publishing;
   };

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

@@ -28,7 +28,7 @@ export async function continueAnalyzedSession({ candidate, manager, root, settin
   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.');
+    throw Object.assign(new Error('This conversation changed; wait for its updated analysis.'), { code: 'continuation_context_changed' });
   }
   manager.requireRecommendation(candidate, recommendationOptions);
   await beforeEnroll(candidate);
@@ -119,6 +119,13 @@ export function createAutomaticContinuation({ root, getManager, selectCandidate,
           readContext, enroll, beforeEnroll: async selected => { await guard(); await beforeEnroll(selected); },
           settings: { ...setting.settings, ...(fresh.provider === 'codex' ? { purposeDriven: true } : {}), autoContinueEpoch: candidate.autoContinueEpoch } });
       }).catch(error => {
+        // No enrollment was attempted: the fresh-context check invalidated its
+        // recommendation. A settled reread may have the very same digest, so
+        // retaining this attempt would suppress that valid start forever.
+        if (error?.code === 'continuation_context_changed') {
+          attempted.delete(key); retries.delete(key);
+          return;
+        }
         if (!closed && !controller.signal.aborted && !/disabled|already enrolled|setting changed|conversation changed; wait|needs a current recommendation/i.test(error?.message || '')) {
           const recoverable = transientStartFailure(error?.code);
           if (recoverable) {

package/src/session-supervision/codex-native-connection.js

@@ -0,0 +1,101 @@
+import WebSocket from 'ws';
+import { homedir } from 'node:os';
+import { join, isAbsolute } from 'node:path';
+import { stat, realpath } from 'node:fs/promises';
+
+const READ_METHODS = new Set(['thread/read', 'thread/loaded/list', 'thread/turns/list', 'thread/queue/list']);
+export class CodexNativeConnectionError extends Error {
+  constructor(code, message) { super(message); this.name = 'CodexNativeConnectionError'; this.code = code; }
+}
+const failure = (code, message) => new CodexNativeConnectionError(code, message);
+
+// Connect to the existing owner. Closing this client never kills the daemon,
+// resumes/unloads a thread, changes its settings, or releases its writer lock.
+export async function openCodexNativeConnection({
+  codexHome = process.env.CODEX_HOME || join(homedir(), '.codex'),
+  socketPath = join(codexHome, 'app-server-control', 'app-server-control.sock'),
+  timeoutMs = 5000, signal,
+} = {}) {
+  signal?.throwIfAborted();
+  if (!isAbsolute(socketPath) || /[\r\n?#]/.test(socketPath)) throw failure('native_socket_invalid', 'Expected an absolute local Codex socket path.');
+  const info = await stat(socketPath);
+  if (!info.isSocket() || typeof process.getuid === 'function' && info.uid !== process.getuid()) throw failure('native_socket_invalid', 'Codex socket is not owned by this user.');
+  const expectedHome = await realpath(codexHome);
+  const ws = new WebSocket(`ws+unix://${socketPath}:/`, { handshakeTimeout: timeoutMs, maxPayload: 8 * 1024 * 1024 });
+  const pending = new Map(), listeners = new Set();
+  let sequence = 0, closed = false;
+  const rejectPending = () => {
+    for (const item of pending.values()) { clearTimeout(item.timer); item.reject(failure(item.write ? 'native_submission_unknown' : 'native_connection_closed', item.write ? 'Submission result is unknown; reconcile its client message ID before retrying.' : 'Codex owner connection closed.')); }
+    pending.clear();
+  };
+  const close = () => { if (closed) return; closed = true; signal?.removeEventListener('abort', close); rejectPending(); ws.terminate(); };
+  ws.on('error', close);
+  ws.on('close', close);
+  ws.on('message', bytes => {
+    let message;
+    try { message = JSON.parse(bytes.toString()); } catch { close(); return; }
+    if (!message || typeof message !== 'object' || Array.isArray(message)) { close(); return; }
+    if (message.id !== undefined && !message.method) {
+      const item = pending.get(message.id); if (!item) return;
+      clearTimeout(item.timer); pending.delete(message.id);
+      if (message.error) item.reject(failure(message.error.code, String(message.error.message || 'Codex request failed.').slice(0, 300)));
+      else item.resolve(message.result);
+    } else if (message.method && message.id === undefined) {
+      // Approval requests belong to the original client, never this adapter.
+      for (const listener of listeners) listener(message.method, message.params || {});
+    }
+  });
+  signal?.addEventListener('abort', close, { once: true });
+  const rpc = (method, params = {}, write = false) => {
+    if (closed || signal?.aborted) return Promise.reject(failure('native_connection_closed', 'Codex owner connection closed.'));
+    const id = ++sequence;
+    return new Promise((resolve, reject) => {
+      const timer = setTimeout(() => { pending.delete(id); reject(failure(write ? 'native_submission_unknown' : 'native_request_timeout', write ? 'Submission result is unknown; reconcile its client message ID before retrying.' : 'Codex owner request timed out.')); }, timeoutMs);
+      pending.set(id, { resolve, reject, timer, write });
+      ws.send(JSON.stringify({ id, method, params }), error => { if (error) close(); });
+    });
+  };
+  try {
+    await new Promise((resolve, reject) => {
+      const timer = setTimeout(() => { cleanup(); reject(failure('native_connection_timeout', 'Codex owner handshake timed out.')); }, timeoutMs);
+      const cleanup = () => { clearTimeout(timer); ws.off('open', opened); ws.off('close', ended); };
+      const opened = () => { cleanup(); resolve(); };
+      const ended = () => { cleanup(); reject(failure('native_connection_closed', 'Codex owner connection closed.')); };
+      ws.once('open', opened); ws.once('close', ended);
+      if (signal?.aborted) close();
+    });
+    const initialized = await rpc('initialize', { clientInfo: { name: 'simy_native_continuation', version: '1.0.0' }, capabilities: { experimentalApi: true } });
+    if (!initialized?.codexHome || await realpath(initialized.codexHome) !== expectedHome) throw failure('native_owner_mismatch', 'Codex owner belongs to a different home.');
+    ws.send(JSON.stringify({ method: 'initialized' }));
+    return {
+      close,
+      onNotification(listener) { listeners.add(listener); return () => listeners.delete(listener); },
+      request(method, params) {
+        if (!READ_METHODS.has(method)) throw failure('native_method_unsupported', 'Use the explicit native continuation submission operation.');
+        return rpc(method, params);
+      },
+      startQueued(threadId, queuedSubmissionId) {
+        if (!threadId || !queuedSubmissionId) throw failure('native_submission_invalid', 'An exact queued submission is required.');
+        return rpc('thread/queue/start', { threadId, queuedSubmissionId }, true);
+      },
+      cancelQueued(threadId, queuedSubmissionId) {
+        if (!threadId || !queuedSubmissionId) throw failure('native_submission_invalid', 'An exact queued submission is required.');
+        return rpc('thread/queue/delete', { threadId, queuedSubmissionId }, true);
+      },
+      async enqueue({ threadId, cwd, clientUserMessageId, text, beforeEnqueue }) {
+        if (!/^[0-9a-f-]{36}$/i.test(threadId) || !isAbsolute(cwd || '') || typeof clientUserMessageId !== 'string' || !clientUserMessageId.trim() ||
+            typeof text !== 'string' || !text.trim() || Buffer.byteLength(text) > 256 * 1024 || typeof beforeEnqueue !== 'function') throw failure('native_submission_invalid', 'Continuation requires exact identity, a stable receipt ID, text and a current authorization check.');
+        const result = await rpc('thread/read', { threadId, includeTurns: false });
+        const thread = result?.thread;
+        if (thread?.id !== threadId || thread.ephemeral || await realpath(thread.cwd) !== await realpath(cwd) || !['idle', 'active'].includes(thread.status?.type)) throw failure('native_thread_unavailable', 'The exact conversation is not loaded in this Codex owner.');
+        // The delivery controller supplies the existing OFF/stop/epoch check.
+        // Queueing does not steer the active turn or override native policies.
+        await beforeEnqueue();
+        const response = await rpc('thread/queue/add', { threadId, clientUserMessageId, input: [{ type: 'text', text }] }, true);
+        const receipt = response?.queuedSubmission;
+        if (!receipt?.id || receipt.clientUserMessageId !== clientUserMessageId) throw failure('native_submission_unknown', 'Codex did not return a matching queue receipt; reconcile before retrying.');
+        return { threadId, clientUserMessageId, queuedSubmissionId: receipt.id, status: 'queued' };
+      },
+    };
+  } catch (error) { close(); throw error; }
+}

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

@@ -8,7 +8,7 @@ import { runStructuredProviderReview } from '../sqm/review-worker.js';
 import { inspectProviderStatus } from '../desktop-status.js';
 import { createHash } from 'node:crypto';
 
-export const CONTINUATION_ANALYSIS_VERSION = 11;
+export const CONTINUATION_ANALYSIS_VERSION = 12;
 const BLOCKER_TYPES = ['approval', 'missing_information', 'external_dependency', 'execution_failure'];
 const STATES = ['continue', 'no_action', 'needs_user', 'waiting', 'uncertain'];
 const string = maximum => ({ type: 'string', maxLength: maximum });

package/src/session-supervision/index.js

@@ -7,7 +7,7 @@ import { effectiveAcceptanceCriteria } from '../codex-plugins/simy/hooks/accepta
 import { purposeFailureMode } from '../codex-plugins/simy/hooks/purpose-search.mjs';
 import { realpath } from 'node:fs/promises';
 import { randomUUID } from 'node:crypto';
-import { TERMINAL as TERMINAL_RUNS, advanceDeliveryControlRevision, deliveryDecisionRevision, canUpgradeDelivery, enablePurposeDelivery, claudeHookChannel, controlDelivery, listRecords, readRecord, processIdentity, startDelivery, updateRecord, recordProviderArchive } from '../codex-plugins/simy/hooks/delivery-loop.mjs';
+import { TERMINAL as TERMINAL_RUNS, advanceDeliveryControlRevision, deliveryDecisionRevision, associationBlocksFollowup, canUpgradeDelivery, enablePurposeDelivery, claudeHookChannel, controlDelivery, listRecords, readRecord, processIdentity, startDelivery, updateRecord, recordProviderArchive } from '../codex-plugins/simy/hooks/delivery-loop.mjs';
 import { listCodexSessions, codexThreadMetadata, openCodexAppServer, readCodexSession, readCodexArchiveStates, CodexAppServerError } from './codex-app-server.js';
 import { listClaudeSessions, readClaudeSession } from './claude-sessions.js';
 import { loadPurposeRuleSet } from './purpose-instruction.js';
@@ -336,7 +336,7 @@ export async function discoverSessions({ root, openClient = openCodexAppServer,
       // implicit reset through the auto-continue preference.
       followup: !archived && supported && item.provider === 'codex' &&
         run?.state === 'reported_done' && !run.managed && run.id && !record.automaticStartBlocked &&
-        !record.associationTaskId && !(record.autoContinue === false && record.autoContinueEpoch)
+        !associationBlocksFollowup(record) && !(record.autoContinue === false && record.autoContinueEpoch)
         ? { previousRunId: run.id } : null,
       ...autoContinueState(record, isRunning, availability),
       lastActivityAt: item.lastActivityAt, createdAt: item.createdAt ?? null, observation, availability: item.availability,
@@ -465,6 +465,9 @@ export async function setSessionAutoContinue({ root, provider, session, enabled,
   });
   // Consent is durable now. Provider reads and ordinary-loop promotion belong
   // to the background coordinator, so their failure cannot undo this response.
+  if (!enabled && updated.run?.managed?.nativeHandoff) {
+    void import('./native-handoff.js').then(({ reconcileNativeHandoff }) => reconcileNativeHandoff({ root, record: updated })).catch(() => {});
+  }
   return updated;
 }
 

package/src/session-supervision/native-handoff.js

@@ -0,0 +1,251 @@
+import { createHash, randomUUID } from 'node:crypto';
+import { realpath, mkdir, writeFile, rename, rm } from 'node:fs/promises';
+import { join } from 'node:path';
+import { openCodexNativeConnection } from './codex-native-connection.js';
+import { readRecord, updateRecord, checkpointDelivery, automaticContinuationAllowed, hasPendingUserStop, managedBudgetReason, assessedCheckpointContract, queuePurposeDiagnosis, rootDirectory, notifyState } from '../codex-plugins/simy/hooks/delivery-loop.mjs';
+import { failureLimitReached } from '../codex-plugins/simy/hooks/purpose-search.mjs';
+import { requireProviderLink } from '../provider-links.js';
+
+const key = r => createHash('sha256').update(JSON.stringify([r.run.id, r.autoContinueEpoch, r.run.controlRevision, r.run.revision, r.run.managed.decision?.id])).digest('hex');
+function approved(m) {
+  const a = m?.approvedAction, d = m?.decision;
+  return d?.outcome === 'wait' && a?.id === d.id &&
+    ['kind', 'scope', 'summary'].every(field => a.action?.[field] === d.action?.[field]) &&
+    (!a.dispatchedAt || a.nativeHandoffId && a.nativeHandoffId === m.nativeHandoff?.id);
+}
+function allowed(r, root, settling = false) {
+  const m = r?.run?.managed;
+  return r?.provider === 'codex' && r.autoContinue === true && automaticContinuationAllowed(r) &&
+    r.run.state === 'recovery_required' && !r.run.stopReason && m?.autoRecovery === true && m.resumeChannel === 'codex_app_server' &&
+    (m.decision?.outcome === 'proceed' || approved(m)) && ['read', 'local_edit', 'local_test', ...(approved(m) ? ['external'] : [])].includes(m.decision?.action?.kind) &&
+    !m.resumeLease && !m.liveWorkspaceLease && !m.outcomeAudit?.lease && !m.pendingApproval && !m.executionUncertain &&
+    !m.nativeWait && !m.userQuestion && !m.understandingQuestion && !m.dependencyWait && !m.authenticationWait &&
+    !['verifying', 'understanding', 'needs_clarification', 'action_association'].includes(m.phase) &&
+    !m.providerWarning && (settling || !m.usageBlocked && !m.maxTokens) && !m.purpose?.nativeBoundary &&
+    !hasPendingUserStop(root, r) && (settling || !managedBudgetReason(r.run, Date.now()));
+}
+function countNativeStart(run, handoff) {
+  if (handoff.countedAt) return;
+  handoff.countedAt = Date.now(); run.continuations += 1;
+}
+function busyRetry(r) {
+  const m = r?.run?.managed, last = m?.attempts?.at(-1);
+  return last?.outcome === 'busy' && last.id === m.executionAttempt?.id && m.executionAttempt.decisionId === m.decision?.id && m.executionAttempt.phase === 'claimed' && !m.executionAttempt.dispatchedAt;
+}
+function pendingContinuation(r) {
+  const attempt = r?.run?.managed?.executionAttempt;
+  return busyRetry(r) || ['session_supervision', 'approved_action'].includes(r?.run?.recoveryCause) &&
+    (!attempt || attempt.phase === 'checkpointed' || r.run.managed.lastNativeHandoff?.recoveryDecisionId === r.run.managed.decision?.id || r.run.managed.lastNativeHandoff?.checkpointRevision === r.run.revision);
+}
+async function retainHandoff(root, h) {
+  if (!/^[a-f0-9]{64}$/.test(h.id)) throw Error('Invalid native handoff identity.');
+  const directory = join(root, 'native-handoffs'), file = join(directory, `${h.id}.json`), temporary = `${file}.${randomUUID()}.tmp`;
+  await mkdir(directory, { recursive: true, mode: 0o700 });
+  try { await writeFile(temporary, JSON.stringify(h), { mode: 0o600 }); await rename(temporary, file); }
+  finally { await rm(temporary, { force: true }); }
+  return { id: h.id, phase: h.phase, turnId: h.turnId || null, ...(h.checkpointRevision !== undefined ? { checkpointRevision: h.checkpointRevision } : {}), ...(h.recoveryDecisionId ? { recoveryDecisionId: h.recoveryDecisionId } : {}), archive: file };
+}
+async function queue(client, session) {
+  const rows = [], seen = new Set(); let cursor;
+  do {
+    const page = await client.request('thread/queue/list', { threadId: session, limit: 100, ...(cursor ? { cursor } : {}) });
+    if (!Array.isArray(page?.data) || rows.length + page.data.length > 1000 || cursor && seen.has(cursor)) throw Error('Incomplete native queue.');
+    if (cursor) seen.add(cursor);
+    rows.push(...page.data); cursor = page.nextCursor;
+  } while (cursor);
+  return rows;
+}
+async function findTurn(client, session, handoff) {
+  let cursor; const seen = new Set();
+  for (let pages = 0; pages < 20; pages++) {
+    const page = await client.request('thread/turns/list', { threadId: session, limit: 10, itemsView: 'summary', sortDirection: 'desc', ...(cursor ? { cursor } : {}) });
+    if (!Array.isArray(page?.data)) throw Error('Incomplete native turn history.');
+    for (const turn of page.data) {
+      if (turn.id === handoff.turnId || turn.items?.some(item => item.type === 'userMessage' &&
+          (item.clientId ? item.clientId === handoff.clientUserMessageId :
+            item.content?.some(part => part.type === 'text' && part.text === handoff.text)))) return turn;
+    }
+    if (!page.nextCursor || page.data.some(t => t.completedAt && t.completedAt * 1000 < handoff.createdAt - 1000)) return null;
+    cursor = page.nextCursor; if (seen.has(cursor)) throw Error('Repeated native history cursor.'); seen.add(cursor);
+  }
+  return null; // Absence is never permission to resend an uncertain submission.
+}
+
+// One durable handoff occupies the same task/decision across host restarts.
+// Return true while it owns continuation so the cold executor cannot race it.
+export async function reconcileNativeHandoff({ root = rootDirectory(), record, openClient = openCodexNativeConnection,
+  authorize = async () => {}, checkLink = requireProviderLink, signal, cancelOnly = false } = {}) {
+  let current = await readRecord(root, record.provider, record.session), h = current?.run?.managed?.nativeHandoff;
+  const replaceable = r => h && (h.checkpointRevision !== undefined || key(r) !== h.id && (h.phase === 'cancelled' || h.phase === 'finished' && r.run.managed.decision?.id !== h.decisionId));
+  if (replaceable(current)) {
+    current = await updateRecord(root, record.provider, record.session, async r => {
+      if (r?.run?.id === current.run.id && r.run.managed.nativeHandoff?.id === h.id && replaceable(r)) {
+        r.run.managed.lastNativeHandoff = await retainHandoff(root, r.run.managed.nativeHandoff);
+        delete r.run.managed.nativeHandoff;
+      }
+      return r;
+    });
+    h = current?.run?.managed?.nativeHandoff;
+  }
+  if (!h && (cancelOnly || !(allowed(current, root) && pendingContinuation(current)))) return false;
+  let client;
+  const mutate = fn => updateRecord(root, record.provider, record.session, async r => {
+    if (r?.run?.id !== current.run.id) throw Error('Original native handoff task changed.');
+    return fn(r);
+  });
+  try {
+    client = await openClient({ signal });
+    const view = (await client.request('thread/read', { threadId: record.session, includeTurns: false }))?.thread;
+    if (view?.id !== record.session || view.ephemeral || await realpath(view.cwd) !== await realpath(current.cwd) || !['idle', 'active'].includes(view.status?.type)) return !!h;
+    let rows = await queue(client, record.session);
+    if (!h) {
+      // Human follow-ups have priority. Do not append a stale automatic plan.
+      if (view.status.type !== 'idle' || rows.length) return true;
+      await checkLink({ root, provider: 'codex' }); await authorize(current);
+      current = await mutate(async r => {
+        if (!allowed(r, root) || !pendingContinuation(r) || key(r) !== key(current)) return r;
+        if (!r.run.managed.nativeHandoff) {
+          const id = key(r), marker = `[SIMY continuation ${id}]`;
+          r.run.managed.nativeHandoff = { id, decisionId: r.run.managed.decision.id, clientUserMessageId: `simy-${id}`, marker, phase: 'prepared', createdAt: Date.now(),
+            text: `${marker}\nContinue the existing authorized task in this conversation. Preserve the user's latest corrections, permissions, stops and budgets. Do only this selected action if it still matches the latest user instructions: ${JSON.stringify(r.run.managed.decision.action)}. If superseded, report an updated plan without executing the old action. Task context: ${r.run.managed.plan?.diagnosis || "Continue the original task."} Report what actually happened. ${assessedCheckpointContract(r.run.managed.decision, r.run.managed)} Do not reset this task or change SIMY state directly.` };
+        }
+        return r;
+      });
+      h = current?.run?.managed?.nativeHandoff; if (!h) return true;
+    }
+    const valid = r => allowed(r, root) && key(r) === h.id;
+    const own = rows.find(row => row.clientUserMessageId === h.clientUserMessageId);
+    if (own && !own.input?.some(part => part.type === 'text' && part.text === h.text)) throw Error('Native submission identity has different input.');
+    const turn = h.phase === 'prepared' ? null : await findTurn(client, record.session, h);
+    if (turn) {
+      current = await mutate(r => {
+        const live = r.run.managed.nativeHandoff;
+        if (live?.id === h.id) {
+          Object.assign(live, { phase: ['completed', 'failed', 'interrupted'].includes(turn.status) ? 'finished' : 'started', turnId: turn.id, turnStatus: turn.status, observedAt: Date.now() });
+          countNativeStart(r.run, live);
+        }
+        return r;
+      });
+      // A new ON/resume may change consent/control while the old turn runs.
+      // Preserve its result, then read it under the new intent instead of
+      // accepting its stale next plan or executing its action a second time.
+      if (!cancelOnly && ['completed', 'failed', 'interrupted'].includes(turn.status) && key(current) !== h.id) {
+        await mutate(r => {
+          const live = r.run.managed.nativeHandoff;
+          if (live?.id !== h.id || live.checkpointRevision !== undefined || key(r) === h.id || !allowed(r, root)) return r;
+          if (queuePurposeDiagnosis(r.run,
+            `Read the ${turn.status} native turn ${turn.id} and reconcile its results with the latest user instructions before continuing. Do not repeat effects already performed.`,
+            `native-control:${h.id}:${key(r)}`, Date.now(), 'checkpoint_rejected')) live.recoveryDecisionId = r.run.managed.decision.id;
+          return r;
+        });
+        return true;
+      }
+      if (!cancelOnly && ['completed', 'failed'].includes(turn.status) && allowed(current, root, true) && key(current) === h.id && current.run.managed.nativeHandoff.checkpointRevision === undefined) {
+        const final = turn.items?.filter(item => item.type === 'agentMessage' && ['final_answer', 'final', null, undefined].includes(item.phase)).at(-1)?.text;
+        try {
+          if (turn.status === 'failed') throw Error('Native turn failed; inspect its results before continuing.');
+          if (!final || Buffer.byteLength(final) > 16 * 1024) throw Error('Native result is missing or exceeds the checkpoint size limit.');
+          await checkpointDelivery({ root, provider: record.provider, session: record.session, cwd: current.cwd,
+            checkpoint: JSON.parse(final), expectedNativeHandoff: { id: h.id, turnId: turn.id, decisionId: h.decisionId,
+              runId: current.run.id, revision: current.run.revision, controlRevision: current.run.controlRevision, epoch: current.autoContinueEpoch } });
+        } catch (error) {
+          await mutate(r => {
+            const live = r.run.managed.nativeHandoff;
+            if (live?.id !== h.id || live.checkpointRevision !== undefined || !allowed(r, root, true) || key(r) !== h.id) return r;
+            live.resultError = String(error.message).slice(0, 300);
+            // Polling or replacement supervisors may observe the same failed
+            // result repeatedly. Charge it once, using the existing failure
+            // policy before admitting another diagnostic provider turn.
+            if (!live.failureCountedAt) {
+              live.failureCountedAt = Date.now();
+              r.run.failures += 1;
+            }
+            if (failureLimitReached(r.run)) {
+              r.run.state = 'failed'; r.run.recoveryCause = 'provider_error';
+              r.run.managed.autoRecovery = false;
+              r.run.reason = `Stopped after ${r.run.failures} failed attempts. Open the original conversation to see what went wrong.`;
+              r.run.updatedAt = Date.now(); notifyState(r.run, r.run.updatedAt);
+              return r;
+            }
+            // Read the completed turn before planning more work; never replay
+            // its effects merely because its final response was not parseable.
+            if (queuePurposeDiagnosis(r.run,
+              `Read the ${turn.status} native turn ${turn.id} and its actual work results, then continue the original unfinished task. The result could not be read: ${live.resultError}. Do not repeat effects already performed or create extra reports.`,
+              `native-result:${h.id}`, Date.now(), 'checkpoint_rejected')) {
+              live.recoveryDecisionId = r.run.managed.decision.id;
+            }
+            return r;
+          });
+        }
+      }
+      return true;
+    }
+    if (!valid(current)) {
+      if (own) await mutate(async r => {
+        if (r.run.managed.nativeHandoff?.id === h.id && !valid(r)) {
+          await client.cancelQueued(record.session, own.id);
+          Object.assign(r.run.managed.nativeHandoff, { phase: 'cancelled', cancelledAt: Date.now() });
+          const approval = r.run.managed.approvedAction;
+          if (approval?.nativeHandoffId === h.id) { delete approval.dispatchedAt; delete approval.nativeHandoffId; }
+        }
+        return r;
+      });
+      else if (h.phase === 'prepared') await mutate(r => { if (r.run.managed.nativeHandoff?.id === h.id) r.run.managed.nativeHandoff.phase = 'cancelled'; return r; });
+      return true;
+    }
+    if (cancelOnly) return true;
+    if (['started', 'finished', 'cancelled'].includes(h.phase)) return true;
+    if (!own && h.phase !== 'prepared') return true;
+    if (view.status.type !== 'idle' || rows.some(row => row.clientUserMessageId !== h.clientUserMessageId)) return true;
+    if (!own) {
+      // Persist intent BEFORE the external send. A crash at either side of the
+      // send is reconciled by client ID/history, never by another queue/add.
+      let claimed = false;
+      current = await mutate(r => {
+        if (valid(r) && r.run.managed.nativeHandoff?.phase === 'prepared') { r.run.managed.nativeHandoff.phase = 'submitting';
+          if (approved(r.run.managed)) Object.assign(r.run.managed.approvedAction, { dispatchedAt: Date.now(), nativeHandoffId: h.id });
+          claimed = true; }
+        return r;
+      });
+      if (!claimed) return true;
+      await mutate(async r => {
+        const live = r.run.managed.nativeHandoff;
+        if (!valid(r) || live?.id !== h.id || live.phase !== 'submitting') return r;
+        await checkLink({ root, provider: 'codex' }); await authorize(r);
+        const receipt = await client.enqueue({ threadId: record.session, cwd: r.cwd, clientUserMessageId: h.clientUserMessageId,
+          text: h.text, beforeEnqueue: async () => { signal?.throwIfAborted(); if (hasPendingUserStop(root, r)) throw Error('User stopped native continuation.'); await checkLink({ root, provider: 'codex' }); await authorize(r); } });
+        Object.assign(live, { phase: 'queued', queuedSubmissionId: receipt.queuedSubmissionId });
+        return r;
+      });
+      return true;
+    }
+    // Claim the exact queued ID durably before asking the owner to consume it.
+    let claimed = false; const startClaim = randomUUID();
+    // A still-present provider queue ID can be consumed after a crash before
+    // start. Never recreate it. The exact ID, not a positional queue head, is
+    // passed to Codex; a consumed entry cannot become a second submission.
+    current = await mutate(r => { if (valid(r) && ['submitting', 'queued', 'starting'].includes(r.run.managed.nativeHandoff?.phase)) { Object.assign(r.run.managed.nativeHandoff, { phase: 'starting', queuedSubmissionId: own.id, startClaim }); claimed = true; } return r; });
+    if (!claimed) return true;
+    await mutate(async r => {
+      const live = r.run.managed.nativeHandoff;
+      if (!valid(r) || live?.id !== h.id || live.phase !== 'starting' || live.startClaim !== startClaim) return r;
+      await checkLink({ root, provider: 'codex' }); await authorize(r); signal?.throwIfAborted();
+      const fresh = (await client.request('thread/read', { threadId: record.session, includeTurns: false }))?.thread;
+      rows = await queue(client, record.session);
+      if (fresh?.status?.type !== 'idle' || rows.length !== 1 || rows[0].id !== own.id) { live.phase = 'queued'; return r; }
+      signal?.throwIfAborted(); if (hasPendingUserStop(root, r)) return r;
+      await checkLink({ root, provider: 'codex' }); await authorize(r);
+      const started = await client.startQueued(record.session, own.id);
+      if (!started?.turn?.id) throw Error('Native start result is unknown.');
+      Object.assign(live, { phase: 'started', turnId: started.turn.id, observedAt: Date.now() });
+      countNativeStart(r.run, live);
+      return r;
+    });
+    return true;
+  } catch (error) {
+    if (signal?.aborted) return true;
+    // The intent survives disconnects, missing sockets, and malformed replies.
+    // Reconciliation on the next tick cannot replay a sent submission.
+    return !!(await readRecord(root, record.provider, record.session))?.run?.managed?.nativeHandoff;
+  } finally { await client?.close(); }
+}

package/src/session-supervision/purpose-recovery.js

@@ -61,6 +61,7 @@ export async function reconcilePurposeTasks({ root, signal, prepareCandidate = p
 
   for (let record of await readRecords()) {
     if (signal?.aborted) break;
+    if (record.run?.managed?.nativeHandoff) continue;
     try {
     let run = record.run;
     if (run?.managed?.providerCapabilityWait) continue;

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

@@ -1,15 +1,20 @@
 import { createHash } from 'node:crypto';
 import { deliveryStop } from '../codex-plugins/simy/hooks/delivery-loop.mjs';
 
+const pendingManualChecks = run => (run.managed.acceptanceCriteria || []).filter(item =>
+  item.check?.type === 'manual' && !Object.hasOwn(run.managed.verified || {}, item.id));
+
 // 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 && !run?.managed?.repairRequest) return null;
+  if (run.stopReason?.actor === 'user') 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 === 'paused') return /^(Paused by user\.|Automatic continuation paused by user\.|User interrupted the provider\.|Stopped by user\.)$/.test(run.reason || '') ? null : deliveryStop(run, now) ? 'paused' : null;
   if (run.state === 'auto_resuming' && !run.managed.resumeLease?.owner) return 'needs_decision';
-  if (run.state === 'blocked' || run.state === 'verification_pending' || run.state === 'reported_done') return 'needs_decision';
+  if (run.state === 'blocked') return run.blocker === 'external_dependency' || run.managed.dependencyWait ? null : 'needs_decision';
+  if (run.state === 'verification_pending') return pendingManualChecks(run).length ? 'needs_decision' : null;
   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') return 'finished';
@@ -19,24 +24,35 @@ export function stopNotificationKind(run, now = Date.now()) {
 // 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.
+  // Retain one stop fingerprint per task for this process. A temporarily empty
+  // discovery result must not turn the same historical stop into a new alert.
   const seen = new Map();
   let baseline = true;
   return {
     observe(records) {
       for (const record of records) {
-        const run = record?.run, kind = stopNotificationKind(run, now());
+        if (record.providerArchived || record.localHidden) continue;
+        const run = record?.run;
+        const kind = stopNotificationKind(run, now());
         const key = JSON.stringify([record.provider, record.session, run?.managed?.taskId]);
-        if (!kind) continue;
-        const id = createHash('sha256').update(JSON.stringify([record.provider, record.session, run.managed.taskId, run.id, kind, run.blocker, run.reason])).digest('hex').slice(0, 32);
+        if (!kind) {
+          if (run?.state === 'active' || run?.state === 'auto_resuming') seen.delete(key);
+          continue;
+        }
+        // Revisions and generated summaries change during maintenance without
+        // creating a new human task. Only a different stop/explicit request does.
+        const request = run.managed.pendingApproval || run.managed.understandingQuestion;
+        const id = createHash('sha256').update(JSON.stringify([record.provider, record.session, run.managed.taskId,
+          run.id, run.managed.autoContinueEpoch, kind, run.blocker || null, request?.id || null,
+          run.managed.userQuestion || null])).digest('hex').slice(0, 32);
         if (seen.get(key) === id) continue;
         seen.set(key, id);
+        const detail = request?.text || request?.summary || run.managed.userQuestion ||
+          (run.state === 'verification_pending' ? pendingManualChecks(run).map(item => item.description).filter(Boolean).join('; ') : null);
         if (!baseline) emit({ type: 'notify', id, kind, provider: record.provider, session: record.session,
-          objective: String(run.objective || '').slice(0, 200) });
+          objective: String(run.objective || '').slice(0, 200),
+          ...(detail ? { detail: String(detail).slice(0, 500) } : {}) });
       }
-      // Temporary provider absence or a diagnostic pass is not a new stop.
-      // Retain fingerprints until a materially different outcome is observed.
       baseline = false;
     },
   };

package/src/sqm/agent-skill.js

@@ -8,7 +8,7 @@ import { hookRuntimeCommand } from "../hook-runtime.js";
 import { inspectClaudePlugin, installClaudePlugin } from "./claude-plugin.js";
 
 export const SQM_AGENT_SKILL_ID = "simy-sqm-pr-check";
-export const SQM_AGENT_SKILL_VERSION = "3.2.0";
+export const SQM_AGENT_SKILL_VERSION = "3.3.0";
 export const SIMY_CODEX_PLUGIN_ID = "simy";
 export const SIMY_CODEX_PLUGIN_VERSION = "0.1.0";
 
@@ -42,6 +42,8 @@ Prefer the fixed local \`$HOME/.simy/bin/simy\` (or \`$SIMY_HOME/bin/simy\`) whe
 5. Verify the proof's repository, base, HEAD and working-tree/diff identity and its bound signature with SQM tooling. Use separate artifact paths outside the diff, and rerun after bound inputs change.
 6. Include proof paths, outcome reasons, matched modules, evaluated rules and scenario statuses from \`executions\` in the PR evidence, separating blocking and advisory results. A pass with \`no_applicable_rules\`, zero scenario evaluations or advisory-only checks does not establish feature or historical incident coverage. Scenario statuses are deterministic evaluations, not browser/provider/deployed execution evidence. Retain relevant uncovered incidents and their concrete regression result or gap; do not promote incomplete delivery acceptance. Zero coverage alone is not a Delivery Loop missing_information blocker: investigate rule applicability and available verification, and continue authorized repair or testing. Keep requested SQM acceptance unmet until it is actually satisfied; alternative tests do not substitute for it. Use an information wait only for a specific question that requires the user's answer.
 
+Before interpreting a passed proof, reason from the actual change to plausible failure mechanisms, independent of which rules matched. Query \`simy sqm knowledge --query "<mechanism>" --json\` using the same host/session, then expand the search when a principle suggests a different downstream risk. Read nextOffset and limitations. Connect historical mechanisms to current callers, data scale, frequency, concurrency, retries and shared resource limits; test counter-evidence and mark missing runtime evidence unverified. Query or polling changes may increase disk I/O without saying "IO" in the diff; a bounded indexed lookup may be safe. Cross-repository knowledge suggests a hypothesis and never transfers rule scope or evaluation. Report supported defects and concrete verification gaps separately from the deterministic proof; a passed proof is not a claim that these broader risks were checked.
+
 Do not replace SQM with an LLM review, and do not claim the check passed without reading the generated proof.
 Use existing authorization for minimal related repair and recheck; do not request another continuation after ordinary blockers are resolved. LLM judgment is the base, relevant HC-01–HC-102 lenses are supplemental, and explicit stops, irreversible actions and real permissions remain boundaries.
 `;

package/src/sqm/claude-plugin.js

@@ -28,7 +28,14 @@ export async function claudePluginFiles() {
   for (const name of ["loop-kernel.mjs", "loop-kernel/index.mjs", "loop-kernel/policy.json", "loop-kernel/pin.json", "loop-kernel/outcome-review.mjs", "loop-kernel/work-frontier.mjs", "loop-kernel/task-pool.mjs"]) {
     files.set(`hooks/${name}`, await readFile(path.join(SOURCE, "hooks", name), "utf8"));
   }
-  files.set("hooks/delivery-loop.mjs", await readFile(path.join(SOURCE, "hooks/delivery-loop.mjs"), "utf8"));
+  const collector = await readFile(new URL("../cli-observability.js", import.meta.url), "utf8");
+  files.set("hooks/cli-observability.mjs", collector.replace("./web-api.js", "./web-api.mjs"));
+  files.set("hooks/web-api.mjs", await readFile(new URL("../web-api.js", import.meta.url), "utf8"));
+  const deliveryLoop = await readFile(path.join(SOURCE, "hooks/delivery-loop.mjs"), "utf8");
+  files.set("hooks/delivery-loop.mjs", deliveryLoop.replace(
+    "const observeDeliveryRecord = (...args) => import('../../../cli-observability.js')\n  .then(({ observeDeliveryRecord: observe }) => observe(...args)).catch(() => false);",
+    "import { observeDeliveryRecord } from './cli-observability.mjs';",
+  ));
   files.set("hooks/recovery-incident.mjs", await readFile(path.join(SOURCE, "hooks/recovery-incident.mjs"), "utf8"));
   files.set("hooks/minimal-sufficient.mjs", await readFile(path.join(SOURCE, "hooks/minimal-sufficient.mjs"), "utf8"));
   files.set("hooks/outcome-progress.mjs", await readFile(path.join(SOURCE, "hooks/outcome-progress.mjs"), "utf8"));