@awak-app/simy-cli 0.7.11 → 0.7.13

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 });
+  }
+});

package/src/update-detachment/worker-ledger-runtime.js

@@ -0,0 +1,34 @@
+// Retained with the worker: receipt intake survives the dispatching host.
+
+export function recordWorkerEvidence(spec, kind, evidence, { createStateStore, digest, atomicSave, readState, readDispatchGate, recordDispatchReceipt, withLock }) {
+  if (!spec.ledger) return;
+  const { identity, taskId, attemptId, generation, recordRef } = spec.ledger;
+  const scope = createStateStore(identity);
+  const gate = readDispatchGate(identity.root);
+  const attempt = gate.attempts[digest(attemptId)];
+  if (!attempt || attempt.taskHash !== digest(taskId) || attempt.identityHash !== digest(identity) || attempt.generation !== generation) throw new Error('Worker ledger attempt mismatch');
+  if (scope.read().tasks[digest(taskId)]?.recordRef !== recordRef || recordRef !== `${spec.directory}/snapshot.json`) throw new Error('Worker registered snapshot mismatch');
+  const providerExecutionId = `worker:${attemptId}:${spec.runtime}`;
+  const resultRef = kind === 'result' ? `${spec.directory}/result.json` : null;
+  const receiptId = `${attemptId}:worker:${kind}`;
+  recordDispatchReceipt({ root: identity.root, attemptId, receiptId, providerExecutionId, resultRef });
+  const state = scope.read();
+  if (!state.receipts[digest(receiptId)]) scope.transact(state.revision, next => {
+    next.attempts[digest(attemptId)] = { id: attemptId, taskHash: digest(taskId), identityHash: digest(identity), generation, providerExecutionId, workerRef: spec.directory };
+    next.receipts[digest(receiptId)] = { attemptId, generation, kind, evidenceRef: `${spec.directory}/${kind === 'handoff' ? 'handoff' : 'result'}.json`, ...(kind === 'result' ? { outputRef: `${spec.directory}/stdout`, stderrRef: `${spec.directory}/stderr`, resultRef, usageRef: resultRef } : {}) };
+    return next;
+  });
+  if (kind === 'result') withLock(recordRef, () => {
+    const snapshot = readState(recordRef);
+    if (!snapshot || digest(snapshot.identity) !== digest(identity) || snapshot.task.id !== taskId || snapshot.attemptId !== attemptId || snapshot.generation !== generation) throw new Error('Worker preservation snapshot mismatch');
+    if (snapshot.resultRef === resultRef && snapshot.resultDigest === digest(evidence)) return;
+    snapshot.resultDigest = digest(evidence);
+    snapshot.revision++;
+    snapshot.task.state = snapshot.task.stopRequested || evidence.status === 'stopped' ? 'stopped' : evidence.status;
+    snapshot.task.stopRequested ||= evidence.status === 'stopped';
+    snapshot.outputRef = `${spec.directory}/stdout`;
+    snapshot.resultRef = resultRef;
+    snapshot.usageRef = `${spec.directory}/result.json`;
+    atomicSave(recordRef, snapshot);
+  });
+}