@awak-app/simy-cli 0.7.10 → 0.7.12

package/src/update-detachment/reconcile.js

@@ -0,0 +1,105 @@
+import { isDeepStrictEqual } from 'node:util';
+
+const IDENTITY = ['provider', 'session', 'account', 'origin', 'worktree', 'device', 'root'];
+const POLICY = ['model', 'permissions', 'approvals', 'budget', 'deadline'];
+const STOPPED = new Set(['stopped', 'paused', 'paused_by_user', 'cancelled']);
+const ATTEMPT_STATES = new Set(['intent', 'sending', 'sent', 'running', 'result_saved', 'confirmed']);
+const present = value => typeof value === 'string' && value.length > 0;
+const own = (object, key) => Object.hasOwn(object || {}, key);
+
+// Pure assessment: no persistence, writer acquisition, provider turn or replay.
+export function assessReconciliation(snapshot, observation, { now = Date.now(), maxAgeMs = 5_000, connectionOnly = false } = {}) {
+  const taskState = snapshot?.task?.state;
+  const stopped = STOPPED.has(taskState);
+  const result = (status, reasons, evidence = {}) => ({
+    status, reasons, connectionState: status === 'ready' ? 'ready' : 'recovery_required',
+    taskState, preserveStop: stopped, canReleaseGate: status === 'ready' && !stopped,
+    discardNextStep: status !== 'ready', replayAttempts: false,
+    nextAction: status === 'already_running' ? 'wait_original_provider' :
+      status === 'changed' ? 'review_current_state' : status === 'recovery_required' ? 'inspect_original_conversation' : 'none',
+    evidence,
+  });
+  const recovery = reason => result('recovery_required', [reason]);
+  if (!snapshot || !observation || !IDENTITY.every(key => present(snapshot.identity?.[key]))) return recovery('snapshot_identity_missing');
+  if (!IDENTITY.every(key => observation.identity?.[key] === snapshot.identity[key])) return recovery('provider_identity_mismatch');
+  if (!['codex', 'claude'].includes(snapshot.identity.provider)) return recovery('unsupported_provider');
+  if (!present(taskState) || !present(snapshot.revision) || !Number.isSafeInteger(snapshot.generation) || snapshot.generation < 0) return recovery('snapshot_invalid');
+  if (!POLICY.every(key => own(snapshot.policy, key) && snapshot.policy[key] !== undefined && own(observation.policy, key) && observation.policy[key] !== undefined) || !present(snapshot.policy.model) || !present(observation.policy.model)) return recovery('policy_unobserved');
+  if (observation.generation !== snapshot.generation) return recovery('owner_generation_mismatch');
+  if (!Number.isFinite(now) || !Number.isFinite(maxAgeMs) || maxAgeMs < 0 || !Number.isFinite(observation.observedAt) ||
+      observation.observedAt > now || now - observation.observedAt > maxAgeMs) return recovery('observation_stale');
+  if (observation.consistent !== true || !present(observation.revision)) return recovery('observation_unstable');
+  const history = observation.history;
+  if (!present(snapshot.historyCursor) || history?.incomplete !== false || history.truncated !== false ||
+      history.fromCursor !== snapshot.historyCursor || !present(history.cursor) || !Array.isArray(history.events) ||
+      history.events.some(event => !present(event?.id)) || new Set(history.events.map(event => event.id)).size !== history.events.length) return recovery('history_cursor_unverified');
+  if (!Array.isArray(snapshot.artifacts) || !Array.isArray(observation.artifacts) ||
+      !Array.isArray(snapshot.attempts) || !Array.isArray(observation.executions)) return recovery('evidence_unobserved');
+  const writer = observation.writer;
+  if (snapshot.identity.provider === 'codex') {
+    const readOnlyBoundary = connectionOnly === true && writer?.source === 'read_only_boundary' && writer.acquisitionRequired === true && writer.verified === false && writer.state === 'idle' && writer.id === snapshot.identity.session && snapshot.writer?.id === snapshot.identity.session;
+    if (!readOnlyBoundary && (!present(snapshot.writer?.id) || writer?.verified !== true || writer.id !== snapshot.writer.id ||
+        !['idle', 'running'].includes(writer.state))) return recovery('codex_writer_unverified');
+  } else if (observation.liveHook?.verified !== true ||
+      observation.liveHook.pid !== snapshot.liveHook?.pid || observation.liveHook.identity !== snapshot.liveHook?.identity ||
+      observation.liveHook.startedAt !== snapshot.liveHook?.startedAt || !present(observation.liveHook.identity) ||
+      !Number.isSafeInteger(observation.liveHook.pid) || observation.liveHook.pid < 2 || !present(observation.liveHook.startedAt) ||
+      !['idle', 'running'].includes(writer?.state)) return recovery('claude_live_hook_unverified');
+
+  const attempts = snapshot.attempts;
+  if (attempts.some(attempt => !present(attempt?.id) || !ATTEMPT_STATES.has(attempt.state)) ||
+      new Set(attempts.map(attempt => attempt.id)).size !== attempts.length) return recovery('attempt_ledger_invalid');
+  if (observation.executions.some(execution => !present(execution?.id) || !['running', 'completed', 'failed', 'cancelled'].includes(execution.state)) ||
+      new Set(observation.executions.map(execution => execution.id)).size !== observation.executions.length) return recovery('execution_evidence_invalid');
+  const executionIds = attempts.filter(attempt => attempt.state !== 'intent').map(attempt => attempt.providerExecutionId);
+  if (new Set(executionIds).size !== executionIds.length) return recovery('attempt_execution_ambiguous');
+  if (observation.executions.some(execution => !attempts.some(attempt => attempt.state !== 'intent' &&
+      attempt.providerExecutionId === execution.id && attempt.id === execution.attemptId))) return recovery('untracked_execution');
+  const matches = [];
+  for (const attempt of attempts) {
+    if (attempt.state === 'intent') return recovery('attempt_intent_unresolved');
+    if (!present(attempt.providerExecutionId)) return recovery('attempt_send_outcome_unknown');
+    const execution = observation.executions.find(item => item.id === attempt.providerExecutionId);
+    if (!execution || execution.attemptId !== attempt.id) return recovery('attempt_execution_unmatched');
+    if (['completed', 'failed', 'cancelled'].includes(execution.state) && !present(execution.resultRef)) return recovery('execution_result_missing');
+    if (['result_saved', 'confirmed'].includes(attempt.state) &&
+        (execution.state !== 'completed' || !present(attempt.resultRef) || attempt.resultRef !== execution.resultRef)) return recovery('saved_result_mismatch');
+    matches.push({ attemptId: attempt.id, providerExecutionId: execution.id, state: execution.state,
+      ...(execution.resultRef ? { resultRef: execution.resultRef } : {}) });
+  }
+  const evidence = { writerAcquisitionRequired: connectionOnly === true && writer.acquisitionRequired === true, historyCursor: history.cursor, attempts: matches,
+    artifacts: structuredClone(observation.artifacts), currentPolicy: Object.fromEntries(POLICY.map(key => [key, structuredClone(observation.policy[key])])) };
+  // These observations update the plan; they never authorize the old plan.
+  const changed = POLICY.filter(key => !isDeepStrictEqual(snapshot.policy[key], observation.policy[key]));
+  if (changed.length || history.events.length || history.cursor !== snapshot.historyCursor ||
+      !isDeepStrictEqual(snapshot.artifacts, observation.artifacts)) return result('changed', ['manual_or_provider_progress', ...changed.map(key => `${key}_changed`)], evidence);
+  if (writer.state === 'running' || matches.some(item => item.state === 'running')) return result('already_running', ['original_provider_running'], evidence);
+  if (matches.some(item => ['failed', 'cancelled'].includes(item.state))) return result('recovery_required', ['execution_did_not_complete'], evidence);
+  if (attempts.length && attempts.every(attempt => attempt.state !== 'intent') && matches.every(item => item.state === 'completed')) return result('completed', ['execution_results_observed'], evidence);
+  if (stopped) return result('changed', ['user_stop_preserved'], evidence);
+  if (taskState !== 'active') return result('changed', ['task_not_runnable'], evidence);
+  return result('ready', ['identity_history_writer_and_policy_verified'], evidence);
+}
+
+// readSnapshot is PR1's read-only normalized view, not a state-store implementation.
+// Two ledger/observation samples fence concurrent manual edits and owner changes.
+export async function reconcileSession({ readSnapshot, adapter, now = Date.now, maxAgeMs, connectionOnly = false }) {
+  try {
+    if (typeof readSnapshot !== 'function' || typeof adapter?.observe !== 'function') throw new Error('Missing reader');
+    const snapshot = structuredClone(await readSnapshot());
+    const first = structuredClone(await adapter.observe(structuredClone(snapshot)));
+    const observation = structuredClone(await adapter.observe(structuredClone(snapshot)));
+    const current = await readSnapshot();
+    if (!isDeepStrictEqual(snapshot, current) || !isDeepStrictEqual({ ...first, observedAt: undefined }, { ...observation, observedAt: undefined })) return {
+      status: 'recovery_required', reasons: ['concurrent_change'], connectionState: 'recovery_required',
+      taskState: current?.task?.state, preserveStop: STOPPED.has(current?.task?.state), canReleaseGate: false,
+      discardNextStep: true, replayAttempts: false, nextAction: 'inspect_original_conversation', evidence: {},
+    };
+    return assessReconciliation(snapshot, observation, { now: now(), maxAgeMs, connectionOnly });
+  } catch {
+    // Provider errors can contain private transcript/authentication data.
+    return { status: 'recovery_required', reasons: ['observation_unavailable'], connectionState: 'recovery_required',
+      canReleaseGate: false, preserveStop: true, discardNextStep: true, replayAttempts: false,
+      nextAction: 'inspect_original_conversation', evidence: {} };
+  }
+}

package/src/update-detachment/reconciliation-adapter.js

@@ -0,0 +1,13 @@
+import { reconcileSession } from './reconcile.js';
+
+// Use PR2's assessment without interpreting a changed/stopped/unknown task as
+// permission to release the root barrier. The caller supplies the registered
+// scope reader and original-provider observation adapter, never a new session.
+export function createCoordinatorReconciler({ readSnapshot, adapter, now, maxAgeMs } = {}) {
+  if (typeof readSnapshot !== 'function' || typeof adapter?.observe !== 'function') return undefined;
+  return async () => {
+    const result = await reconcileSession({ readSnapshot, adapter, now, maxAgeMs });
+    return { verified: result.status === 'ready' && result.canReleaseGate === true,
+      unresolvedAttempts: result.status === 'ready' ? 0 : null, assessment: result };
+  };
+}

package/src/update-detachment/runtime.js

@@ -0,0 +1,319 @@
+import { readCodexPolicyContext } from './codex-context.js';
+import { mkdirSync, realpathSync } from 'node:fs';
+import { randomUUID } from 'node:crypto';
+import { join, resolve } from 'node:path';
+import { execFile } from 'node:child_process';
+import { promisify } from 'node:util';
+import { readFile, lstat, readlink, realpath } from 'node:fs/promises';
+import { atomicSave, readState, digest, withLock } from './state-store.js';
+import { readDispatchGate, adoptHookOwner, DISPATCH_PROTOCOL, confirmDispatch, flushDispatchIntake, readTaskAdmission } from './dispatch-gate.js';
+import { createLedgerCoordinatorAdapters } from './ledger-adapter.js';
+import { listDispatchRegistrations, normalizeDispatchIdentity } from './provenance.js';
+import { reconcileSession } from './reconcile.js';
+import { createLedgerExecutionWorker } from './worker-ledger.js';
+import { processIdentity, recordPath, updateRecord, hasPendingUserStop, hasPendingUpdateInvalidation, taskDirectory } from '../codex-plugins/simy/hooks/delivery-loop.mjs';
+import { openCodexAppServer, readCodexSession, readCodexObservation } from '../session-supervision/codex-app-server.js';
+import { observeClaudeReadOnly } from './claude-observation.js';
+
+const execFileAsync = promisify(execFile);
+export async function worktreeEvidence(worktree) {
+  const options={cwd:worktree,timeout:5000,maxBuffer:8*1024*1024};
+  const [head,diff,files] = await Promise.all([
+    execFileAsync('git',['rev-parse','HEAD'],options),
+    execFileAsync('git',['diff','--binary','HEAD','--'],options),
+    execFileAsync('git',['ls-files','--others','--exclude-standard','-z'],options),
+  ]);
+  const names=files.stdout.split('\0').filter(Boolean);
+  if(names.length>256)throw failure('artifact_scope_too_large');
+  const untracked=[];
+  for(const name of names){ const file=join(worktree,name), details=await lstat(file);
+    if(details.size>4*1024*1024)throw failure('artifact_scope_too_large');
+    if(!details.isFile() && !details.isSymbolicLink())throw failure('artifact_type_unknown');
+    untracked.push([name,digest(details.isSymbolicLink() ? await readlink(file) : await readFile(file))]); }
+  return [{ref:'workspace',digest:digest([head.stdout.trim(),diff.stdout,untracked])}];
+}
+const stopped = new Set(['stopped','paused','paused_by_user','cancelled']);
+const terminal = new Set(['completed','reported_done','failed','succeeded']);
+const taskState = run => stopped.has(run.state) ? run.state : run.managed?.pendingApproval ? 'approval_wait' : ['blocked','waiting_human','recovery_required'].includes(run.state) ? 'needs_user' : 'active';
+const originalTaskId = record => record.run.managed?.taskId || record.run.id;
+const authority = record => digest([record.run?.id,record.run?.state,record.run?.managed,record.run?.deadline,record.run?.continuations,record.run?.failures,record.autoContinue,record.process,record.cwd,record.run?.executionCwd]);
+const boundaryEvidence = record => digest([record?.runtime,record?.updateObservation,record?.hookSessionProcess,record?.hookEndedAt]);
+const failure = code => Object.assign(new Error(`Update connection: ${code}`),{code});
+
+// Only metadata and existing process observations. No turn/start, resume, new
+// Claude process, model selection, account mutation or provider authentication.
+export async function observeOriginalProvider(record, { openClient = openCodexAppServer, inspectProcess = processIdentity, baseline, readCurrentRecord, readInvalidation, claudeObservationOptions } = {}) {
+  if (record.provider === 'claude') {
+    const proof=await observeClaudeReadOnly(record,{...claudeObservationOptions,inspectProcess});
+    if(typeof readCurrentRecord!=='function')throw failure('claude_current_boundary_unavailable');
+    const current=await readCurrentRecord();
+    const evidence=value=>digest([value?.runtime,value?.updateObservation,value?.hookSessionProcess,value?.hookEndedAt,authority(value || {})]);
+    if(!current || evidence(current)!==evidence(record))throw failure('claude_boundary_changed');
+    if(typeof readInvalidation!=='function' || await readInvalidation(current))throw failure('claude_boundary_changed');
+    return proof;
+  }
+  const client = await openClient({cancelOnAbort:true, signal:AbortSignal.timeout(8000)});
+  try {
+    const metadata = await readCodexSession(client,record.session);
+    const observed = await readCodexObservation(client,record.session);
+    const page = await client.request('thread/turns/list',{threadId:record.session,cursor:null,limit:5,sortDirection:'desc',itemsView:'summary'},2000);
+    if(!Array.isArray(page?.data) || page.data.some(turn=>!turn?.id || !['completed','interrupted','failed'].includes(turn.status)))throw failure('provider_history_not_settled');
+    const coverage=baseline?.latestTurnId ? page.data.some(turn=>turn.id===baseline.latestTurnId) : page.data.length===0 ? page.nextCursor==null : observed.latestTurnId===page.data[0].id;
+    if(!coverage)throw failure('provider_history_coverage_unknown');
+    const raw = await client.request('thread/read',{threadId:record.session,includeTurns:false},2000);
+    const policy=await readCodexPolicyContext(raw.thread?.path,record.session,record.cwd);
+    if(typeof observed.isRunning !== 'boolean')throw failure('codex_turn_boundary_unobserved');
+    return {identity:{session:metadata.session,worktree:await realpath(metadata.cwd)},model:policy.model,permissions:policy.permissions,
+      cursor:digest([page.data,metadata.lastActivityAt,policy.revision]),latestTurnId:page.data[0]?.id || null,executionStates:page.data.map(turn=>({id:turn.id,state:turn.status})),historyCoverage:coverage,running:observed.isRunning,
+      // Connection-only evidence. The existing execution path must acquire its
+      // writer and verify fresh permissions before each new turn.
+      writer:{id:record.session,verified:false,state:observed.isRunning?'running':'idle',source:'read_only_boundary',acquisitionRequired:true}};
+  } finally { await client.close(); }
+}
+
+export function createUpdateRuntime({ root, origin, readContext, listRecords, observe = observeOriginalProvider,
+  worker = null, now=Date.now } = {}) {
+  mkdirSync(root,{recursive:true,mode:0o700});root=realpathSync(root); const file=join(root,'update-detachment','transaction.json');
+  let transaction=readState(file), ownerTransferred=false;
+  const workerFor=identity=>worker || createLedgerExecutionWorker({identity});
+  const context=()=>readContext?.() || {runs:[],directTasks:[],localTasks:[]};
+  const write=patch=>withLock(file,()=> {
+    const current=readState(file);
+    if (transaction && current?.revision!==transaction.revision) throw failure('transaction_revision_changed');
+    transaction={schemaVersion:1,operationId:randomUUID(),tasks:[],...current,...patch,revision:(current?.revision || 0)+1};
+    atomicSave(file,transaction);
+  });
+  let presented=null;
+  const uiState = task => task.stop_requested ? 'stopped' : ['stopped','cancelled'].includes(task.status || task.state) ? 'stopped' : ['paused','paused_by_user'].includes(task.status || task.state) ? 'paused' : task.managed?.pendingApproval ? 'approval_wait' : ['running','queued','active','dispatching','coding'].includes(task.status || task.state) ? 'running' : 'needs_user';
+  const rows=()=> (transaction?.connectionState==='detaching' ? transaction?.pendingTasks || [] : transaction?.tasks || []).map(task=>({title:task.title || 'Provider task',taskState:task.canResume===false && !['paused','paused_by_user','cancelled','stopped','approval_wait'].includes(task.uiState)?'needs_user':['paused_by_user','cancelled'].includes(task.uiState)?'paused':task.uiState || 'needs_user',
+    ...(task.canResume===false?{canResume:false,reason:'Open the original conversation to review and continue.'}:{}),
+    disposition:task.workerPreserved?'continuing':transaction.connectionState==='detaching'?'waiting_for_boundary':'saved',executionPreserved:task.workerPreserved===true}));
+  const pendingTasks=async()=> {
+    const c=context(),records=(await listRecords()).filter(record=>record.run && !terminal.has(record.run.state));
+    return [...records.map(record=>({title:record.title || 'Provider task',uiState:uiState(record.run)})),
+      ...(c.runs || []).map(run=>({title:'Coding task',uiState:uiState(run)})),
+      ...(c.localTasks || []).map(task=>({title:'Local task',uiState:uiState(task)})),
+      ...(c.directTasks || []).map(task=>({title:'Direct task',uiState:uiState(task)}))];
+  };
+  const adapters=createLedgerCoordinatorAdapters({root,readWriters:async()=> {
+    const writers=[];
+    for(const record of await listRecords()) {
+      if(!record.run || stopped.has(record.run.state) || terminal.has(record.run.state))continue;
+      const owner=record.hookSessionProcess || record.process;
+      if(!owner?.identity || !Number.isSafeInteger(owner.pid))throw failure('original_writer_inventory_unavailable');
+      const actual=await processIdentity(owner.pid);
+      if(actual!==owner.identity)throw failure('original_writer_identity_changed');
+      const capability=readDispatchGate(root).writerCapabilities?.[digest([record.provider,record.session])];
+      if(capability?.protocol!==DISPATCH_PROTOCOL || !capability.moduleDigest || capability.pid!==owner.pid || capability.processIdentity!==actual)throw failure('original_writer_protocol_unverified');
+      writers.push({provider:record.provider,session:record.session,pid:owner.pid,processIdentity:actual,moduleDigest:capability.moduleDigest});
+    }
+    return writers;
+  }});
+  const store={read:async()=>({...await adapters.store.read(),...transaction,connectionState:readDispatchGate(root).connection}),
+    write:async patch=>{write({...patch,...(patch.connectionState==='detaching'?{pendingTasks:await pendingTasks()}:{}),...(patch.connectionState==='connected' && transaction?.updateState==='applying'?{updateState:'succeeded'}:patch.connectionState==='recovery_required' && transaction?.updateState==='applying'?{updateState:'failed'}:{})});await adapters.store.write(patch);}};
+  const records=async()=> (await listRecords()).filter(record=>record.run);
+  const currentRecord=async record=>(await records()).find(item=>item.provider===record.provider && item.session===record.session);
+  const identity=async record=> {
+    const actor=context().actor;
+    if (!actor?.account || !actor?.device || actor.origin!==origin) throw failure('account_or_device_unavailable');
+    return {root,origin,account:actor.account,device:actor.device,provider:record.provider,session:record.session,worktree:await realpath(taskDirectory(record))};
+  };
+  const bind=async record=> {
+    const expected=normalizeDispatchIdentity(await identity(record)),taskId=originalTaskId(record);
+    const recordRef=recordPath(join(root,'delivery-hooks'),record.provider,record.session);
+    const matches=listDispatchRegistrations(root,{retained:true}).filter(item=>item.recordRef===recordRef && item.taskId===taskId);
+    if(!matches.length || matches.some(item=>digest(item.identity)!==digest(expected)))throw failure('original_provenance_unavailable');
+    return matches[0].identity;
+  };
+  const capture=async()=> {
+    const tasks=[];
+    for (const record of await records()) {
+      // Closed records remain in their original durable storage. They have no
+      // live writer to reconnect and may legitimately outlive their worktree.
+      // The global receipt check below still rejects every unresolved attempt.
+      if(terminal.has(record.run.state))continue;
+      const binding=await bind(record), provider=await observe(record,{readCurrentRecord:()=>currentRecord(record),readInvalidation:current=>hasPendingUpdateInvalidation(join(root,'delivery-hooks'),current)});
+      if(provider.identity.session!==binding.session || provider.identity.worktree!==await realpath(record.cwd)) throw failure('provider_identity_changed');
+      if(provider.running) return null;
+      tasks.push({taskId:originalTaskId(record),identity:binding,sessionCwd:await realpath(record.cwd),
+        title:record.title || record.provider,uiState:stopped.has(record.run.state)?record.run.state:record.run.managed?.pendingApproval?'approval_wait':taskState(record.run)==='active'?'running':'needs_user',
+        canResume:provider.readOnlyReconnect===true?false:undefined,boundaryEvidence:provider.readOnlyReconnect===true?boundaryEvidence(record):null,
+        authority:authority(record),artifacts:await worktreeEvidence(binding.worktree), recordRef:recordPath(join(root,'delivery-hooks'),record.provider,record.session), provider,
+        policy:{model:provider.model,permissions:provider.permissions,approvals:digest(record.run.managed?.approvedAction || null),budget:digest([record.run.continuations,record.run.failures,record.run.managed?.usage]),deadline:record.run.deadline ?? null}});
+    }
+    return tasks;
+  };
+  const boundary=async()=> {
+    const startingGate=readDispatchGate(root);
+    if(startingGate.connection!=='detaching')return {safe:false,liveExecutions:0,pendingWrites:0,unsettledPermissions:0};
+    const c=context(), execution=[...(c.runs||[]),...(c.localTasks||[])];
+    const unowned=execution.filter(run=>run.child || run.operation || run.pendingLedgerUpdate || run.ledgerUpdateRunning || ['queued','running','dispatching','coding'].includes(run.status));
+    const workers=[];
+    for(const task of c.directTasks || []) {
+      if(!['queued','running','stopping'].includes(task.status)) continue;
+      if(!task.worker_handle) {unowned.push(task);continue;}
+      const owner=workerFor(task.worker_handle.identity);
+      if(typeof owner.handoff !== 'function'){unowned.push(task);continue;}
+      const proof=await owner.handoff(task.worker_handle),state=proof.state;
+      if(proof.verified !== true || !['running','completed','stopping'].includes(state?.state)) {unowned.push(task);continue;}
+      const preservation=proof.preservation || owner.readSnapshot(task.worker_handle);
+      if(!preservation?.policy || preservation.task.id!==task.id){unowned.push(task);continue;}
+      workers.push({taskId:task.id,identity:task.worker_handle.identity,handle:task.worker_handle,
+        workerPreserved:state.state==='running',uiState:task.stop_requested || preservation.task.stopRequested?'stopped':'running',title:'Direct task',
+        policy:preservation.policy,deadlineAt:preservation.policy.deadline,authority:digest([preservation.policy,preservation.metadata]),
+        generation:task.worker_handle.generation,preservation});
+    }
+    const pendingWrites=execution.filter(run=>run.pendingLedgerUpdate||run.ledgerUpdateRunning).length;
+    if(unowned.length || pendingWrites) return {safe:false,liveExecutions:unowned.length,pendingWrites,unsettledPermissions:0};
+    const tasks=await capture(); if(!tasks) return {safe:false,liveExecutions:1,pendingWrites:0,unsettledPermissions:0};
+    flushDispatchIntake(root);
+    let ledger=readDispatchGate(root);
+    for(const attempt of Object.values(ledger.attempts)) {
+      if(attempt.phase!=='result_saved')continue;
+      const task=tasks.find(item=>attempt.taskHash===digest(item.taskId) && attempt.identityHash===digest(item.identity));
+      if(!task || task.identity.provider!=='codex')continue;
+      const receipts=Object.values(ledger.receipts).filter(receipt=>receipt.attemptId===attempt.id);
+      const ids=[...new Set(receipts.map(receipt=>receipt.providerExecutionId).filter(Boolean))];
+      const refs=[...new Set(receipts.map(receipt=>receipt.resultRef).filter(Boolean))];
+      const source=readState(task.recordRef),saved=source?.run?.managed?.executionAttempt;
+      if(ids.length!==1 || refs.length!==1 || saved?.id!==attempt.id || saved.phase!=='checkpointed' || refs[0]!==`delivery-record:${task.identity.provider}:${task.identity.session}:${attempt.id}` || !task.provider.executionStates?.some(turn=>turn.id===ids[0] && turn.state==='completed'))continue;
+      // A durable exact checkpoint plus the actual provider's exact completed
+      // turn proves intake; unrelated conversation progress is never a receipt.
+      confirmDispatch({root,attemptId:attempt.id});
+    }
+    ledger=readDispatchGate(root);
+    const unresolved=Object.values(ledger.attempts).filter(attempt=>attempt.phase!=='confirmed' && !workers.some(task=>task.handle.attemptId===attempt.id && attempt.taskHash===digest(task.taskId) && attempt.identityHash===digest(task.identity) && attempt.generation===task.generation));
+    if(unresolved.length)return {safe:false,liveExecutions:0,pendingWrites:0,unsettledPermissions:0};
+    const currentGate=readDispatchGate(root);
+    if(currentGate.connection!=='detaching' || currentGate.generation!==startingGate.generation)throw failure('boundary_owner_changed');
+    for(const task of tasks)if(task.canResume===false)await adapters.gate.fenceTask({identity:task.identity,taskId:task.taskId,
+      reason:{code:task.policy.model?'provider_policy_unknown':'provider_model_unknown',evidenceRef:task.recordRef}});
+    write({tasks:[...tasks,...workers]});
+    return {safe:true,liveExecutions:workers.filter(task=>task.workerPreserved).length,workerHandoffVerified:true,pendingWrites:0,unsettledPermissions:0};
+  };
+  const reconcile=async()=> {
+    const actor=context().actor, assessments=[];
+    const workers=(transaction?.tasks || []).filter(task=>task.handle);
+    if(Object.values(readDispatchGate(root).attempts).some(attempt=>attempt.phase!=='confirmed' && !workers.some(task=>task.handle.attemptId===attempt.id)))return {verified:false,unresolvedAttempts:1};
+    for (const task of transaction?.tasks || []) {
+      if(task.handle) {
+        if(actor?.account!==task.identity.account || actor?.origin!==task.identity.origin || actor?.device!==task.identity.device || task.identity.root!==root)return {verified:false,unresolvedAttempts:1};
+        const owner=workerFor(task.identity),proof=await owner.handoff(task.handle),snapshot=proof.preservation || owner.readSnapshot(task.handle);
+        if(proof.verified!==true || !['running','completed','stopping'].includes(proof.state?.state) || snapshot.policy?.deadline!==task.deadlineAt || digest([snapshot.policy,snapshot.metadata])!==task.authority)return {verified:false,unresolvedAttempts:1};
+        if(task.preservation.task.stopRequested && !snapshot.task.stopRequested)return {verified:false,unresolvedAttempts:1};
+        continue;
+      }
+      if(actor?.account!==task.identity.account || actor?.device!==task.identity.device || actor?.origin!==task.identity.origin) return {verified:false,unresolvedAttempts:1};
+      const find=async()=> (await records()).find(record=>recordPath(join(root,'delivery-hooks'),record.provider,record.session)===task.recordRef);
+      const readSnapshot=async()=> {
+        const record=await find(); if(!record || authority(record)!==task.authority)throw failure('task_authority_changed');
+        const ledger=readDispatchGate(root);
+        if(Object.values(ledger.attempts).some(attempt=>attempt.taskHash===digest(task.taskId) && attempt.phase!=='confirmed'))throw failure('unresolved_attempt');
+        return {identity:task.identity,revision:task.authority,generation:ledger.generation,task:{state:taskState(record.run)},policy:task.policy,
+          historyCursor:task.provider.cursor,artifacts:task.artifacts,attempts:[],writer:task.provider.writer,liveHook:task.provider.liveHook};
+      };
+      if(task.canResume===false) {
+        await readSnapshot();
+        for(let sample=0;sample<2;sample++) {
+          const record=await find();if(!record || authority(record)!==task.authority || digest(await bind(record))!==digest(task.identity))throw failure('task_authority_changed');
+          const current=await observe(record,{baseline:task.provider,readCurrentRecord:find,readInvalidation:current=>hasPendingUpdateInvalidation(join(root,'delivery-hooks'),current)});
+          if(current.readOnlyReconnect!==true || current.canResume!==false || current.permissions!==null || current.running!==false || current.historyCoverage!==true ||
+              current.identity?.session!==task.identity.session || current.identity?.worktree!==task.sessionCwd || current.cursor!==task.provider.cursor ||
+              digest(current.liveHook)!==digest(task.provider.liveHook) || digest(await worktreeEvidence(task.identity.worktree))!==digest(task.artifacts))throw failure('read_only_connection_changed');
+          const admission=readTaskAdmission({root,identity:task.identity,taskId:task.taskId});
+          if(admission.record?.status!=='blocked' || admission.canResume!==false)throw failure('task_fence_unavailable');
+        }
+        assessments.push({status:'connected_read_only',canResume:false,reasons:['provider_policy_unknown']});
+        // Adopting this hook generation permits lifecycle intake only: every
+        // new dispatch still encounters the durable task admission fence.
+        await updateRecord(join(root,'delivery-hooks'),task.identity.provider,task.identity.session,async current=>{
+          if(!current || authority(current)!==task.authority || boundaryEvidence(current)!==task.boundaryEvidence)throw failure('claude_boundary_changed');
+          const owner=task.provider.liveHook,latestActor=context().actor;
+          if(await processIdentity(owner.pid)!==owner.identity || latestActor?.account!==task.identity.account || latestActor?.device!==task.identity.device || latestActor?.origin!==task.identity.origin)throw failure('original_claude_owner_unavailable');
+          if(hasPendingUpdateInvalidation(join(root,'delivery-hooks'),current))throw failure('claude_boundary_changed');
+          if(hasPendingUserStop(join(root,'delivery-hooks'),current))throw failure('user_stop_preserved');
+          const admission=readTaskAdmission({root,identity:task.identity,taskId:task.taskId});
+          if(admission.record?.status!=='blocked' || admission.canResume!==false)throw failure('task_fence_unavailable');
+          // The record lock plus durable lifecycle/stop markers reject events
+          // that arrived while the asynchronous process check held this lock.
+          adoptHookOwner({root,provider:task.identity.provider,session:task.identity.session,expectedRevision:admission.revision});
+          return current;
+        });
+        continue;
+      }
+      const adapter={observe:async snapshot=> {
+        const record=await find(), current=await observe(record,{baseline:task.provider,readCurrentRecord:find,readInvalidation:current=>hasPendingUpdateInvalidation(join(root,'delivery-hooks'),current)});
+        const liveIdentity=await identity(record);
+        if(current.identity?.session!==liveIdentity.session || current.identity?.worktree!==task.sessionCwd || await realpath(record.cwd)!==task.sessionCwd)throw failure('provider_identity_changed');
+        return {identity:liveIdentity,revision:digest([current.cursor,current.writer,current.permissions]),observedAt:now(),generation:snapshot.generation,consistent:true,
+          policy:{...task.policy,model:current.model,permissions:current.permissions},writer:current.writer,liveHook:current.liveHook,artifacts:await worktreeEvidence(task.identity.worktree),executions:[],
+          history:{fromCursor:snapshot.historyCursor,cursor:current.cursor,incomplete:current.historyCoverage!==true,truncated:current.historyCoverage!==true,events:current.cursor===snapshot.historyCursor?[]:[{id:current.cursor}]}};
+      }};
+      const result=await reconcileSession({readSnapshot,adapter,now,connectionOnly:true}); assessments.push(result);
+      const preserved=result.status==='changed' && result.reasons.every(reason=>['user_stop_preserved','task_not_runnable'].includes(reason));
+      if(result.status!=='ready' && !preserved)return {verified:false,unresolvedAttempts:1,assessments};
+      // Verified original hook lifetime, no cold process takeover.
+      adoptHookOwner({root,provider:task.identity.provider,session:task.identity.session,expectedRevision:readDispatchGate(root).revision});
+    }
+    return {verified:true,unresolvedAttempts:0,assessments};
+  };
+  return {bind,boundary,reconcile,store,gate:adapters.gate,
+    async initialize() {if(!transaction)write({connectionState:readDispatchGate(root).connection,phase:'startup',updateState:'pending'});},
+    snapshot(base,update) {
+      if(ownerTransferred)transaction=readState(file);
+      const action=base.state==='connected' && update?.state==='waiting_for_idle'?'detach_update':base.state==='detaching'?'cancel_detach_update':!base.busy && ['detached','recovery_required'].includes(base.state)?'update_reconnect':null;
+      const frame={...base,schemaVersion:1,connectionState:base.state,
+        updateState:transaction?.updateState || 'pending',tasks:rows(),actions:action?[action]:[]};
+      const fingerprint=digest(frame);
+      if(!ownerTransferred && transaction && transaction.presentation!==fingerprint)write({presentation:fingerprint});
+      presented={...frame,operationId:transaction?.operationId,revision:transaction?.revision || 0};
+      return presented;
+    },
+    validate(command,base,update) {
+      const frame=this.snapshot(base,update);
+      if(command.operationId!==frame.operationId || command.revision!==frame.revision || !frame.actions.includes(command.action) || transaction?.claimedCommands?.includes(command.id))throw failure('stale_operation');
+      write({claimedCommands:[...(transaction?.claimedCommands || []).slice(-255),command.id]});
+    },
+    async prepareHandoff() {
+      const gate=readDispatchGate(root);
+      if(gate.connection!=='detached' || transaction?.connectionState!=='detached')throw failure('handoff_not_detached');
+      const token=randomUUID(),ownerIdentity=await processIdentity(process.pid);
+      if(!ownerIdentity)throw failure('handoff_owner_unavailable');
+      write({transferToken:token,ownerPid:process.pid,ownerIdentity,generation:gate.generation,updateState:'applying'});
+      for(const task of context().directTasks || []) {
+        if(transaction.tasks.some(saved=>saved.handle && saved.taskId===task.id)) {
+          task.observation_suspended=true;task.update_owner_transferred=true;
+        }
+      }
+      adapters.handoff();ownerTransferred=true;return token;
+    },
+    async acceptHandoff(token) {
+      transaction=readState(file);
+      const original=transaction;
+      if(!original || original.transferToken!==token || original.generation!==readDispatchGate(root).generation || readDispatchGate(root).connection!=='detached' || original.connectionState!=='detached' || await processIdentity(original.ownerPid)!==original.ownerIdentity)throw failure('handoff_identity_changed');
+      // Claim coordinator ownership before consuming the transfer token. Both
+      // the durable revision and token are checked again after asynchronous IO.
+      const ownerIdentity=await processIdentity(process.pid);
+      if(!ownerIdentity)throw failure('handoff_owner_unavailable');
+      await adapters.gate.close();
+      write({ownerPid:process.pid,ownerIdentity,transferToken:null});
+    },
+    async reclaimFailedHandoff() {
+      const current=readState(file);
+      if(!ownerTransferred || !current)return;
+      if(current.ownerPid!==process.pid && await processIdentity(current.ownerPid)===current.ownerIdentity)throw failure('candidate_owner_still_live');
+      transaction=current;
+      const ownerIdentity=await processIdentity(process.pid);
+      if(!ownerIdentity)throw failure('handoff_owner_unavailable');
+      write({transferToken:null,ownerPid:process.pid,ownerIdentity,updateState:'failed'});
+      for(const task of context().directTasks || []) {
+        if(transaction.tasks.some(saved=>saved.handle && saved.taskId===task.id)) {
+          task.observation_suspended=false;task.update_owner_transferred=false;
+        }
+      }
+      ownerTransferred=false;
+      // Never reopen admission or steal a crashed candidate's coordinator lock.
+    },
+    transferred:()=>ownerTransferred,
+  };
+}

package/src/update-detachment/state-store.js

@@ -0,0 +1 @@
+export * from '../codex-plugins/simy/hooks/update-state-store.mjs';

package/src/update-detachment/worker-entry.js

@@ -0,0 +1,145 @@
+import * as ledgerStore from './update-state-store.mjs';
+import * as ledgerGate from './update-dispatch-gate.mjs';
+const ledgerApi = { ...ledgerStore, ...ledgerGate };
+// Copied with its decoder into a content-addressed runtime before launch.
+import { randomUUID } from 'node:crypto';
+import { spawn } from 'node:child_process';
+import { createServer } from 'node:net';
+import { open, mkdtemp, chmod, rm } from 'node:fs/promises';
+import { tmpdir } from 'node:os';
+import path from 'node:path';
+import { createProviderStreamDecoder } from './provider-stream.mjs';
+import { recordWorkerEvidence } from './worker-ledger-runtime.mjs';
+import { durableJson, ownedProcessIdentity } from './worker-storage.mjs';
+
+process.once('message', async (spec) => {
+  let child;
+  let server;
+  let socketDirectory;
+  const output = [];
+  const usage = [];
+  let terminalError = null;
+  let providerSessionId = null;
+  let providerSessionSaved = false;
+  let stopped = false;
+  let deadlineExceeded = false;
+  let writes = Promise.resolve();
+  let timer;
+  let escalation;
+  let completion;
+  let storageError = null;
+  const failedOutputs = new Set();
+  let stdout;
+  let stderr;
+  const rememberStorageError = (error) => { storageError ||= error.message; };
+  const save = async (name, value) => {
+    try { await durableJson(spec.directory, name, value); } catch (error) { rememberStorageError(error); }
+  };
+  const owner = { attemptId: spec.attemptId, identity: spec.identity, runtime: spec.runtime, pid: process.pid, ownerToken: randomUUID(), ...(spec.ledger ? { taskId: spec.ledger.taskId, generation: spec.ledger.generation, identityHash: spec.ledger.identityHash } : {}) };
+  const signal = (value) => {
+    if (!child?.pid) return;
+    try { process.kill(-child.pid, value); } catch (error) { if (error.code !== 'ESRCH') throw error; }
+  };
+  const stop = () => {
+    stopped = true;
+    // Persist the stop before signalling; reconnect must not resume it.
+    writes = writes.then(() => save('stop.json', { ...owner, at: Date.now() })).then(() => {
+      signal('SIGTERM');
+      escalation ||= setTimeout(() => signal('SIGKILL'), 1500);
+    });
+    return writes;
+  };
+  try {
+    owner.processIdentity = await ownedProcessIdentity(process.pid);
+    socketDirectory = await mkdtemp(path.join(tmpdir(), 'simy-owner-'));
+    await chmod(socketDirectory, 0o700);
+    const socket = path.join(socketDirectory, 'ipc');
+    server = createServer((connection) => {
+      let input = '';
+      connection.setTimeout(2000, () => connection.destroy());
+      connection.on('data', async (chunk) => {
+        input += chunk;
+        if (input.length > 4096) return connection.destroy();
+        if (!input.includes('\n')) return;
+        connection.pause();
+        try {
+          const request = JSON.parse(input);
+          if (request.attemptId !== owner.attemptId || JSON.stringify(request.identity) !== JSON.stringify(owner.identity)) throw new Error('Owner mismatch');
+          if (request.operation === 'stop') await stop();
+          else if (request.operation !== 'inspect') throw new Error('Unsupported operation');
+          await writes;
+          connection.end(JSON.stringify({ ...owner, acknowledged: true, stopped, output: output.slice(-100), token_usage: { records: usage.slice(-100), truncated: usage.length > 100 }, storageError }) + '\n');
+        } catch { connection.destroy(); }
+      });
+    });
+    await new Promise((resolve, reject) => { server.once('error', reject); server.listen(socket, resolve); });
+    await chmod(socket, 0o600);
+    await durableJson(spec.directory, 'owner.json', { ...owner, socket, deadlineAt: spec.deadlineAt });
+    stdout = await open(path.join(spec.directory, 'stdout'), 'wx', 0o600);
+    stderr = await open(path.join(spec.directory, 'stderr'), 'wx', 0o600);
+    const onLine = (line) => { output.push(line); if (output.length > 400) output.shift(); };
+    const decoder = createProviderStreamDecoder({ backend: spec.backend, onLine, onEvent: event => { providerSessionId ||= event.type === 'thread.started' ? event.thread_id : event.type === 'system' ? event.session_id : null; }, onUsage: (record) => usage.push({ ...record, phase: 'direct', backend: spec.backend }), onTerminalError: (error) => { terminalError ||= error; } });
+    const errorDecoder = createProviderStreamDecoder({ backend: spec.backend, stream: 'stderr', onLine });
+    // The claim/intent exists before this sole invocation. A lost launch ACK is never replayed.
+    await durableJson(spec.directory, 'dispatch.json', { ...owner, state: 'sending', at: Date.now() });
+    if (spec.deadlineAt !== null && Date.now() >= spec.deadlineAt) throw new Error('Worker deadline already expired');
+    child = spawn(spec.command.bin, spec.command.args, { cwd: spec.cwd, env: { ...process.env, ...spec.command.env }, detached: true, stdio: ['ignore', 'pipe', 'pipe'] });
+    completion = new Promise((resolve) => {
+      let spawnError = null;
+      child.once('error', (error) => { spawnError = error.message; });
+      child.once('close', (code, exitSignal) => resolve({ code, signal: exitSignal, spawnError }));
+    });
+    const capture = (stream, file, parser) => stream.on('data', (chunk) => {
+      stream.pause();
+      writes = writes.then(async () => {
+        if (!failedOutputs.has(file)) { try { await file.write(chunk); await file.sync(); } catch (error) { failedOutputs.add(file); rememberStorageError(error); } }
+        parser.push(chunk.toString('utf8'));
+        if (providerSessionId && !providerSessionSaved) {
+          await save('provider-execution.json', { ...owner, providerSessionId });
+          providerSessionSaved = true;
+        }
+      }).catch(rememberStorageError).finally(() => stream.resume());
+    });
+    capture(child.stdout, stdout, decoder);
+    capture(child.stderr, stderr, errorDecoder);
+    if (spec.deadlineAt !== null) timer = setTimeout(() => { deadlineExceeded = true; void stop(); }, Math.max(1, spec.deadlineAt - Date.now()));
+    await durableJson(spec.directory, 'started.json', { ...owner, providerPid: child.pid ?? null, at: Date.now() });
+    const handoff = { ...owner, providerPid: child.pid ?? null, providerProcessIdentity: await ownedProcessIdentity(child.pid), deadlineAt: spec.deadlineAt, acknowledged: true };
+    await durableJson(spec.directory, 'handoff.json', handoff);
+    recordWorkerEvidence(spec, 'handoff', handoff, ledgerApi);
+    if (process.connected) {
+      process.send({ ...owner, acknowledged: true }, () => { if (process.connected) process.disconnect(); });
+    }
+    const exit = await completion;
+    clearTimeout(timer); clearTimeout(escalation);
+    await writes;
+    decoder.flush(); errorDecoder.flush();
+    await stdout.close().catch(rememberStorageError); await stderr.close().catch(rememberStorageError);
+    const receipt = {
+      ...owner, ...exit, deadlineAt: spec.deadlineAt, finishedAt: Date.now(), providerSessionId, output,
+      result: output.at(-1) || null, token_usage: { records: usage },
+      status: storageError ? 'recovery_required' : deadlineExceeded ? 'failed' : stopped ? 'stopped' : exit.code === 0 && !terminalError ? 'succeeded' : 'failed',
+      error: storageError || (deadlineExceeded ? 'Worker deadline exceeded.' : stopped ? null : terminalError || exit.spawnError || (exit.code !== 0 ? `Provider exited with code ${exit.code}.` : null)),
+    };
+    await durableJson(spec.directory, 'result.json', receipt);
+    recordWorkerEvidence(spec, 'result', receipt, ledgerApi);
+  } catch (error) {
+    rememberStorageError(error);
+    await save('recovery.json', { ...owner, status: 'recovery_required', error: error.message });
+    if (process.connected) {
+      process.send({ error: 'Worker requires recovery; do not replay the attempt.' }, () => { if (process.connected) process.disconnect(); });
+    }
+    // Receipt failure after dispatch must not drop the executing owner's deadline.
+    if (completion) {
+      const exit = await completion;
+      await writes;
+      await save('recovery.json', { ...owner, ...exit, status: 'recovery_required', error: error.message, finishedAt: Date.now() });
+    }
+  } finally {
+    clearTimeout(timer); clearTimeout(escalation);
+    await stdout?.close().catch(() => {});
+    await stderr?.close().catch(() => {});
+    server?.close();
+    if (socketDirectory) await rm(socketDirectory, { recursive: true, force: true });
+  }
+});