@awak-app/simy-cli 0.7.10 → 0.7.12

package/src/session-supervision/pull-requests.js

@@ -0,0 +1,52 @@
+import { execFile } from 'node:child_process';
+import { promisify } from 'node:util';
+const execute = promisify(execFile);
+const PR_URL = /^https:\/\/github\.com\/([\w.-]+)\/([\w.-]+)\/pull\/(\d+)\/?$/;
+export function normalizePullRequests(value) {
+  const rows = Array.isArray(value) ? value : value ? [value] : [];
+  const unique = new Map();
+  for (const row of rows.slice(0, 32)) {
+    const url = typeof row === 'string' ? row : row?.url;
+    if (!PR_URL.test(url || '')) continue;
+    const state = String(row.state || row.status || '').toUpperCase();
+    unique.set(url, { url, state: row.merged === true || row.mergedAt ? 'MERGED' : ['OPEN', 'CLOSED', 'MERGED'].includes(state) ? state : 'UNKNOWN',
+      reviewDecision: ['CHANGES_REQUESTED', 'APPROVED', 'REVIEW_REQUIRED'].includes(row.reviewDecision) ? row.reviewDecision : null,
+      checkedAt: Number.isFinite(row.checkedAt) ? row.checkedAt : null });
+  }
+  return [...unique.values()];
+}
+
+// One cache per host, bounded concurrency, no network work on the 3s status tick.
+export function createPullRequestObserver({ read = async url => {
+  const match = PR_URL.exec(url);
+  const { stdout } = await execute('gh', ['pr', 'view', match[3], '--repo', `${match[1]}/${match[2]}`, '--json', 'url,state,reviewDecision,mergedAt'], { timeout: 2000, maxBuffer: 64 * 1024, windowsHide: true });
+  return JSON.parse(stdout);
+}, now = Date.now, ttlMs = 60_000, budgetMs = 3500 } = {}) {
+  const cache = new Map();
+  let cursor = 0;
+  return async (sessions, { signal } = {}) => {
+    const catalog = [...new Set(sessions.flatMap(item => (item.pullRequests || []).map(pr => pr.url)))];
+    // Continue after the last attempted URL, including when slow reads consume
+    // the budget. Restarting at row zero can starve the tail indefinitely.
+    const start = catalog.length ? cursor % catalog.length : 0;
+    const urls = [...catalog.slice(start), ...catalog.slice(0, start)].slice(0, 128);
+    let next = 0; const started = now();
+    await Promise.all(Array.from({ length: Math.min(4, urls.length) }, async () => {
+      while (next < urls.length && !signal?.aborted && now() - started < budgetMs) {
+        const url = urls[next++], previous = cache.get(url);
+        if (previous && now() - previous.at < ttlMs) continue;
+        try { const rows = normalizePullRequests(await read(url));
+          if (rows[0]?.url !== url) throw new Error('PR identity mismatch');
+          cache.set(url, { at: now(), value: { ...rows[0], checkedAt: now(), fetchFailed: false } });
+        } catch { cache.set(url, { at: now(), value: { ...(previous?.value || { url, state: 'UNKNOWN' }), fetchFailed: true } }); }
+      }
+    }));
+    cursor = catalog.length ? (start + next) % catalog.length : 0;
+    while (cache.size > 512) cache.delete(cache.keys().next().value);
+    return sessions.map(item => ({ ...item, pullRequests: (item.pullRequests || []).map(pr => {
+      const observed = cache.get(pr.url)?.value;
+      const value = observed ? { ...pr, ...observed, ...(observed.state === 'UNKNOWN' ? { state: pr.state } : {}) } : pr;
+      return { ...value, stale: !Number.isFinite(value.checkedAt) || now() - value.checkedAt > ttlMs };
+    }) }));
+  };
+}

package/src/session-supervision/work-state.js

@@ -0,0 +1,84 @@
+// Display-only state. Tracking/auto-continue consent is never evidence of execution.
+export const WORK_STATE_TTL_MS = 45_000;
+const freshObservation = (checkedAt, now) => Number.isFinite(checkedAt) && checkedAt <= now && now - checkedAt <= WORK_STATE_TTL_MS;
+export function sessionWorkState(candidate, run, { now = Date.now(), provider } = {}) {
+  const checkedAt = candidate.observation?.observedAt ?? null;
+  const stale = !freshObservation(checkedAt, now);
+  const fetchFailed = provider?.discovery === 'unavailable';
+  const freshness = { checkedAt, stale, fetchFailed };
+  const result = (state, label, reason, nextAction = null, needsAttention = false) =>
+    ({ state, label, reason, nextAction, needsAttention, ...freshness });
+  if (candidate.archived || candidate.localHidden) return result('archived', 'アーカイブ済み', candidate.localHidden ? 'この一覧だけで非表示にしています。' : '元の会話がアーカイブされています。', 'restore');
+  let nativeRuntimeUnknown = false;
+  if (Object.hasOwn(candidate.observation || {}, 'activeFlags')) {
+    const flags = candidate.observation.activeFlags;
+    nativeRuntimeUnknown = stale || fetchFailed || !Array.isArray(flags) || flags.some(flag => !['waitingOnApproval', 'waitingOnUserInput'].includes(flag));
+    if (!nativeRuntimeUnknown && flags.includes('waitingOnApproval')) return result('approval', '承認待ち', '元のAIが操作の承認を待っています。', 'review_approval', true);
+    if (!nativeRuntimeUnknown && flags.includes('waitingOnUserInput')) return result('question', '回答待ち', '元のAIが回答を待っています。', 'answer', true);
+  }
+  // Never display a cached active flag as a live observation after a sleep/outage.
+  if (!nativeRuntimeUnknown && !stale && !fetchFailed && candidate.isRunning === true) return result('running', 'AIが対応中', '元のAIが実行中です。');
+  const approval = run?.pendingApproval || run?.managed?.pendingApproval;
+  const question = run?.understandingQuestion || run?.managed?.understandingQuestion || run?.managed?.userQuestion;
+  const phase = run?.phase || run?.managed?.phase;
+  const stopped = run?.state === 'stopped' || run?.stopReason?.actor === 'user' ||
+    run?.state === 'paused' && /^(Paused by user\.|Automatic continuation paused by user\.|User interrupted the provider\.|Stopped by user\.)$/.test(run.reason || '');
+  if (stopped) return result('stopped', '自分で停止', '停止の指示を維持しています。', 'resume');
+  if (approval && !approval.denied || candidate.decisionRequest?.kind === 'approval')
+    return result('approval', '承認待ち', candidate.decisionRequest?.context || '実行する操作の確認が必要です。', 'review_approval', true);
+  if (question || phase === 'needs_clarification' || candidate.analysis?.state === 'needs_user' || candidate.decisionRequest?.kind === 'question')
+    return result('question', '回答待ち', candidate.decisionRequest?.question || '続けるために回答が必要です。', 'answer', true);
+  if ((run?.autoRecovery || run?.managed?.autoRecovery) && ['recovery_required', 'auto_resuming'].includes(run.state)) return result('checking', 'AIが状況確認中', '自動復旧の結果を待っています。');
+  if (['failed', 'recovery_required', 'budget_exhausted'].includes(run?.state) || candidate.analysis?.state === 'failed' || candidate.autoContinueStatus === 'error')
+    return result('error', '対応が必要', run?.reason || '作業が中断されています。', run?.canResume || run?.canReplan ? 'resume' : 'open_original', true);
+  if (run?.dependencyWait || run?.managed?.dependencyWait) return result('waiting', '依存条件待ち', '条件が変わるまで待機します。');
+  if (['blocked', 'verification_pending', 'reported_done', 'paused'].includes(run?.state) || candidate.analysis?.state === 'continue' && candidate.autoContinue !== true || candidate.autoContinueStatus === 'needs_user')
+    return result('unfinished', '残りの作業あり', run?.reason || candidate.analysis?.reason || '未完了の作業を再開できます。', 'resume', true);
+  if (nativeRuntimeUnknown) return result('unknown', '実行状態を確認できません', '元のAIの最新の実行状態を確認できません。', 'refresh');
+  const prs = candidate.pullRequests || [];
+  if (prs.some(pr => pr.state === 'OPEN' && pr.reviewDecision === 'CHANGES_REQUESTED')) return result('changes_requested', 'PRの修正要求', '関連PRに修正要求があります。', 'open_pr', true);
+  if (prs.some(pr => pr.state === 'OPEN')) return result('review', 'PRレビュー待ち', '関連PRのレビュー・統合を待っています。', 'open_pr');
+  if (prs.some(pr => pr.state === 'UNKNOWN' || pr.fetchFailed || pr.stale)) return result('pr_unknown', 'PRの状態確認待ち', '関連PRの最新状態を確認できません。', 'refresh');
+  // A merge or no-follow-up recommendation is not task completion. no_action
+  // also covers casual chat, cancellation and optional future improvements.
+  if (run?.state === 'completed' || !run && candidate.providerGoal?.status === 'complete')
+    return result('completed', '完了', '会話の作業完了を確認しました。');
+  if (candidate.isRunning === true && (stale || fetchFailed)) return result('unknown', '実行状態を確認できません', '最終確認後の実行状態は不明です。', 'refresh');
+  if (run && ['active', 'auto_resuming'].includes(run.state) || ['queued', 'analyzing'].includes(candidate.analysis?.state)) return result('checking', 'AIの対応待ち', '次の処理・状態確認を待っています。');
+  return result('idle', '次の依頼待ち', '現在の実行や対応依頼は確認されていません。');
+}
+
+export function compareSessionWork(a, b) {
+  const priority = item => item.workState?.state === 'running' ? 0 : item.workState?.needsAttention ? 1 : 2;
+  return priority(a) - priority(b) || (b.lastActivityAt || 0) - (a.lastActivityAt || 0) || `${a.provider}:${a.session}`.localeCompare(`${b.provider}:${b.session}`);
+}
+
+// Completion belongs to the whole known family. Idle history alone does not
+// create a human task; positively unfinished descendants do prevent completion.
+export function reconcileFamilyCompletion(sessions) {
+  const byKey = new Map(sessions.map(item => [`${item.provider}:${item.session}`, item]));
+  for (const child of sessions) {
+    if (['idle', 'completed', 'archived'].includes(child.workState?.state)) continue;
+    const seen = new Set(); let parent = child.parentSession;
+    while (parent) {
+      const key = `${parent.provider}:${parent.session}`;
+      if (seen.has(key)) break;
+      seen.add(key); const ancestor = byKey.get(key);
+      if (!ancestor) break;
+      if (ancestor.workState?.state === 'completed') ancestor.workState = { ...ancestor.workState,
+        state: 'family_unfinished', label: '子の作業が未完了', reason: '関連する子の作業が残っています。', nextAction: 'review_children', needsAttention: false };
+      parent = ancestor.parentSession;
+    }
+  }
+  return sessions;
+}
+
+// Fast connection heartbeats may carry the previous full projection while a
+// reader is blocked. Expire live labels there too, without losing pending work.
+export function expireSessionWorkState(candidate, now = Date.now()) {
+  const previous = candidate.workState;
+  if (!previous || freshObservation(previous.checkedAt, now)) return candidate;
+  if (previous.state !== 'running') return previous.stale ? candidate : { ...candidate, workState: { ...previous, stale: true } };
+  return { ...candidate, workState: { ...previous, state: 'unknown', label: '実行状態を確認できません',
+    reason: '最終確認後の実行状態は不明です。', nextAction: 'refresh', needsAttention: false, stale: true } };
+}

package/src/sqm/claude-plugin.js

@@ -45,11 +45,16 @@ export async function claudePluginFiles() {
   files.set("hooks/acceptance-policy.mjs", await readFile(path.join(SOURCE, "hooks/acceptance-policy.mjs"), "utf8"));
   files.set("hooks/purpose-rule-review.mjs", await readFile(path.join(SOURCE, "hooks/purpose-rule-review.mjs"), "utf8"));
   files.set("hooks/workspace-lease.mjs", await readFile(path.join(SOURCE, "hooks/workspace-lease.mjs"), "utf8"));
+  for (const name of ["update-state-store.mjs", "update-dispatch-gate.mjs", "update-dispatch-identity.mjs"]) files.set(`hooks/${name}`, await readFile(path.join(SOURCE, "hooks", name), "utf8"));
   files.set("hooks/connection-reminder.mjs", await readFile(path.join(SOURCE, "hooks/connection-reminder.mjs"), "utf8"));
   files.set("hooks/dev-work.mjs", await readFile(path.join(SOURCE, "hooks/dev-work.mjs"), "utf8"));
   const hooks = JSON.parse(await readFile(path.join(SOURCE, "hooks/hooks.json"), "utf8"));
   delete hooks.hooks.Interrupt; // Codex-only event; Claude interruptions cannot be vetoed.
   hooks.hooks.StopFailure = structuredClone(hooks.hooks.Stop);
+  // Observe policy/model invalidation without emitting continuation decisions.
+  // Supported by the pinned 2.1.201 CLI. PostModelSwitch is rejected by its
+  // manifest validator; Stop observations therefore cannot retain an old model.
+  hooks.hooks.ConfigChange = structuredClone(hooks.hooks.SessionStart);
   hooks.hooks.Notification = structuredClone(hooks.hooks.PermissionRequest);
   for (const [event, groups] of Object.entries(hooks.hooks)) {
     for (const group of groups) {

package/src/sqm/review-worker.js

@@ -431,6 +431,7 @@ async function runSingleProviderReview(
   request,
   {
     spawnImpl = spawn,
+    dispatchTransport = initiate => initiate(),
     inspectExecutor = inspectDesktopExecutor,
     executionTimeoutMs = DEFAULT_EXECUTION_TIMEOUT_MS,
     environment = process.env,
@@ -463,6 +464,10 @@ async function runSingleProviderReview(
   const workDir = await mkdtemp(join(tmpdir(), "simy-sqm-review-"));
   const schemaPath = join(workDir, "output-schema.json");
   const outputPath = join(workDir, "output.json");
+  let transportFailure;
+  const fencedTransport = initiate => {
+    try { return dispatchTransport(initiate); } catch (error) { transportFailure = error; throw error; }
+  };
   try {
     await writeFile(schemaPath, JSON.stringify(request.output_schema), { mode: 0o600 });
     const prompt = [
@@ -512,7 +517,7 @@ async function runSingleProviderReview(
             "-",
           ],
           prompt,
-          { spawnImpl, executionTimeoutMs: remaining, stallTimeoutMs: provider === "codex" && readOnlyAnalysis && allowAutomaticRetry && !stallRetried && remaining > codexAttemptTimeoutMs ? codexAttemptTimeoutMs : null, label, cwd: workDir, environment, provider, signal, readOnlyAnalysis, model, retryAttempt,
+          { spawnImpl, dispatchTransport: fencedTransport, executionTimeoutMs: remaining, stallTimeoutMs: provider === "codex" && readOnlyAnalysis && allowAutomaticRetry && !stallRetried && remaining > codexAttemptTimeoutMs ? codexAttemptTimeoutMs : null, label, cwd: workDir, environment, provider, signal, readOnlyAnalysis, model, retryAttempt,
             terminationGraceMs: Number.isInteger(terminationGraceMs) ? Math.max(1, Math.min(terminationGraceMs, 5_000)) : 1_000, onUsage, onContext },
         );
         selectedModel = model;
@@ -563,7 +568,7 @@ async function runSingleProviderReview(
       ...(processResult.diagnostic.retryAttempt === 1 ? { retryAttempt: 1 } : {}),
     };
   } catch (error) {
-    if (error instanceof SqmLocalReviewError || error?.code === 'desktop_access_required' || ['subscription_auth_required', 'subscription_auth_unknown'].includes(error?.code)) throw error;
+    if (error === transportFailure || error instanceof SqmLocalReviewError || error?.code === 'desktop_access_required' || ['subscription_auth_required', 'subscription_auth_unknown'].includes(error?.code)) throw error;
     throw new SqmLocalReviewError(`Local ${label} review failed before producing a structured result.`, {
       code: `${provider}_local_review_failed`,
     });
@@ -585,15 +590,19 @@ function codexAnalysisArguments(system) {
     '-c', `developer_instructions=${JSON.stringify(system)}`];
 }
 
-function spawnReview(command, args, prompt, { spawnImpl, executionTimeoutMs, stallTimeoutMs, cwd, environment, provider, signal, readOnlyAnalysis, terminationGraceMs, model, retryAttempt, onUsage, onContext }) {
+function spawnReview(command, args, prompt, { spawnImpl, dispatchTransport, executionTimeoutMs, stallTimeoutMs, cwd, environment, provider, signal, readOnlyAnalysis, terminationGraceMs, model, retryAttempt, onUsage, onContext }) {
   return new Promise((resolve, reject) => {
     if (signal?.aborted) return reject(providerFailure("analysis_cancelled"));
     let child;
     try {
-      child = spawnImpl(command, args, {
-        env: safeReviewEnvironment(environment, provider), cwd, windowsHide: true, detached: process.platform !== "win32", stdio: ["pipe", "pipe", "pipe"],
+      child = dispatchTransport(() => {
+        try {
+          return spawnImpl(command, args, {
+            env: safeReviewEnvironment(environment, provider), cwd, windowsHide: true, detached: process.platform !== "win32", stdio: ["pipe", "pipe", "pipe"],
+          });
+        } catch { throw providerFailure("provider_spawn_failed", { model }); }
       });
-    } catch { reject(providerFailure("provider_spawn_failed", { model })); return; }
+    } catch (error) { reject(error); return; }
     let stdout = "", stderrPending = "", outputBytes = 0, phase = "before_turn";
     let settled = false, terminalError = null, killTimer = null;
     let reportedTokens = -1, reportedContext = null;

package/src/update-detachment/claude-observation.js

@@ -0,0 +1,33 @@
+import { realpath } from 'node:fs/promises';
+import { readClaudeSession, readClaudeBoundary } from '../session-supervision/claude-sessions.js';
+import { processIdentity } from '../codex-plugins/simy/hooks/delivery-loop.mjs';
+import { digest } from './state-store.js';
+
+const fail = code => { throw Object.assign(new Error(`Update connection: ${code}`), { code }); };
+
+// This permits observation only. Unknown policy stays unknown, and callers must
+// install a durable session/task dispatch fence before releasing the root gate.
+export async function observeClaudeReadOnly(record, { inspectProcess = processIdentity,
+  readMetadata = readClaudeSession, readConversation = null, readBoundary = readClaudeBoundary } = {}) {
+  const owner = record.run?.managed?.liveHookOwner || record.process;
+  const hook = record.hookSessionProcess, runtime = record.runtime, boundary = record.updateObservation;
+  if (!owner?.identity || !record.hookStartedAt || record.hookEndedAt ||
+      hook?.pid !== owner.pid || hook.identity !== owner.identity || await inspectProcess(owner.pid) !== owner.identity)
+    fail('original_claude_owner_unavailable');
+  if (runtime?.process?.pid !== owner.pid || runtime.process.identity !== owner.identity || typeof runtime.isRunning !== 'boolean')
+    fail('claude_turn_boundary_unobserved');
+  if (runtime.isRunning) fail('claude_turn_running');
+  if (boundary?.process?.pid !== owner.pid || boundary.process.identity !== owner.identity || boundary.source !== 'Stop' ||
+      boundary.observedAt !== runtime.observedAt || boundary.observedAt < record.hookStartedAt || boundary.backgroundIdle !== true)
+    fail('claude_background_boundary_unobserved');
+  const metadata = await readMetadata(record.session);
+  if (metadata?.session !== record.session || await realpath(metadata.cwd) !== await realpath(record.cwd)) fail('provider_identity_changed');
+  const context = readConversation ? await readConversation(metadata) : await readBoundary(metadata);
+  if (readConversation ? !context || context.incomplete !== false || context.truncated !== false || !Array.isArray(context.messages) : !context || context.complete !== true || !/^[a-f0-9]{64}$/.test(context.digest)) fail('claude_history_coverage_unknown');
+  if (await inspectProcess(owner.pid) !== owner.identity) fail('original_claude_owner_unavailable');
+  return { identity: { session: metadata.session, worktree: await realpath(metadata.cwd) }, model: boundary.model || null,
+    permissions: null, permissionMode: boundary.permissionMode || null, canResume: false, readOnlyReconnect: true,
+    cursor: digest([context, metadata.lastActivityAt, boundary]), historyCoverage: true, running: false,
+    writer: { id: owner.identity, verified: false, state: 'idle', source: 'read_only_live_hook', acquisitionRequired: true },
+    liveHook: { pid: owner.pid, identity: owner.identity, startedAt: record.hookStartedAt, verified: true, source: 'original_live_hook' } };
+}

package/src/update-detachment/codex-context.js

@@ -0,0 +1,27 @@
+import { open, realpath } from 'node:fs/promises';
+import { resolve, relative, join } from 'node:path';
+import { homedir } from 'node:os';
+import { digest } from './state-store.js';
+
+// Read only session metadata and the newest turn_context. Never read auth.json,
+// copy prompts/tool output, write provider configuration or acquire a writer.
+export async function readCodexPolicyContext(file, session, worktree, { codexHome = process.env.CODEX_HOME || join(homedir(),'.codex') } = {}) {
+  if(typeof file!=='string')throw new Error('Codex rollout reference unavailable.');
+  const [base,target]=await Promise.all([realpath(codexHome),realpath(file)]);
+  const rel=relative(base,target); if(rel.startsWith('..') || resolve(base,rel)!==target || !/^(sessions|archived_sessions)[/\\]/.test(rel))throw new Error('Codex rollout outside existing account.');
+  const handle=await open(target,'r');
+  try {
+    const before=await handle.stat(); const head=Buffer.alloc(Math.min(32768,before.size));
+    await handle.read(head,0,head.length,0);
+    const size=Math.min(2*1024*1024,before.size), tail=Buffer.alloc(size);
+    await handle.read(tail,0,size,before.size-size);
+    const parse=line=>{try{return JSON.parse(line);}catch{return null;}};
+    const meta=head.toString().split('\n').map(parse).find(item=>item?.type==='session_meta');
+    const contexts=tail.toString().split('\n').map(parse).filter(item=>item?.type==='turn_context');
+    const context=contexts.at(-1)?.payload;
+    const after=await handle.stat();
+    if(before.size!==after.size || before.mtimeMs!==after.mtimeMs || meta?.payload?.id!==session || !context?.model ||
+      !context.sandbox_policy || context.approval_policy===undefined || await realpath(context.cwd)!==await realpath(worktree))throw new Error('Codex turn context is incomplete or changed.');
+    return {model:context.model,permissions:digest([context.sandbox_policy,context.approval_policy]),revision:digest(context)};
+  } finally {await handle.close();}
+}

package/src/update-detachment/coordinator.js

@@ -0,0 +1,117 @@
+// PR3 owns sequencing only. Persistence/fencing and provider identity checks are
+// supplied by PR1/PR2; absence of either must never become permission to update.
+export function createUpdateCoordinator({ store, gate, boundary, reconcile, now = Date.now,
+  preserveConnectedOnStartup = false, initialState = 'connected', onChange = () => {}, pollMs = 50, timeoutMs = 30_000, sleep = ms => new Promise(resolve => setTimeout(resolve, ms)) } = {}) {
+  let state = initialState, phase = 'unavailable', operation = null, cancelled = false;
+  const available = Boolean(store?.read && store?.write && gate?.close && gate?.open && boundary && reconcile);
+  const snapshot = () => ({ state, phase, available, busy: Boolean(operation),
+    canCancel: state === 'detaching', canReconnect: !operation && ['detached', 'recovery_required'].includes(state) });
+  const save = async (next, nextPhase, extra = {}) => {
+    // Await the durable commit before advertising or acting on a transition.
+    await store.write({ connectionState: next, phase: nextPhase, ...extra });
+    state = next; phase = nextPhase; onChange();
+  };
+  const requireAvailable = () => {
+    if (!available) throw Object.assign(new Error('Update detachment dependencies are unavailable.'), { code: 'detachment_unavailable' });
+  };
+  const exclusive = fn => {
+    if (operation) return Promise.reject(new Error('An update connection operation is already in progress.'));
+    operation = Promise.resolve().then(fn).finally(() => { operation = null; });
+    return operation;
+  };
+  const recover = async reason => {
+    state = 'recovery_required'; phase = reason;
+    await gate.close();
+    await save(state, phase);
+  };
+  const reconcileConnection = async () => {
+    await save('reconciling', 'identity_check');
+    const result = await reconcile(await store.read());
+    if (result?.verified !== true || result?.unresolvedAttempts !== 0) {
+      await recover('reconciliation_required');
+      return snapshot();
+    }
+    await save('ready', 'reconciled');
+    // Gate owns per-task eligibility: ready is not permission to resume a
+    // paused/blocked/waiting-human task, reset budgets, or replay an attempt.
+    await gate.open({ resumeTasks: false });
+    await save('connected', 'complete');
+    return snapshot();
+  };
+  return {
+    snapshot,
+    acceptsNewWork: () => state === 'connected',
+    async initialize() {
+      if (!available) return snapshot();
+      if (operation) throw new Error('An update connection operation is already in progress.');
+      // Fence admission synchronously and reserve the operation before reading
+      // disk: startup participates in the same exclusion as detach/reconnect.
+      state = 'reconciling'; phase = 'startup';
+      return exclusive(async () => {
+        try {
+          const record = await store.read();
+          if (preserveConnectedOnStartup && record?.connectionState === 'connected') { state = 'connected'; phase = 'complete'; return snapshot(); }
+          await gate.close();
+          // Missing state may mean a process died before its first checkpoint.
+          state = record?.connectionState || 'recovery_required';
+          phase = record?.phase || 'startup';
+          if (state !== 'connected') { await recover('interrupted_update'); return snapshot(); }
+          return await reconcileConnection();
+        } catch (error) { await recover('startup_failed'); throw error; }
+      });
+    },
+    async detachUpdate(update) {
+      requireAvailable();
+      if (state !== 'connected') return Promise.reject(new Error('Reconnect the original conversation before updating.'));
+      if (operation) throw new Error('An update connection operation is already in progress.');
+      // Synchronous local admission closure precedes the first asynchronous IO.
+      state = 'detaching'; phase = 'closing_admission'; cancelled = false;
+      return exclusive(async () => {
+        try {
+          await gate.close();
+          await save('detaching', 'draining');
+          const deadline = now() + timeoutMs;
+          while (true) {
+            const remaining = deadline - now();
+            if (remaining <= 0) throw new Error('Safe update boundary timed out.');
+            let timeout;
+            const proof = await Promise.race([
+              Promise.resolve().then(boundary),
+              new Promise((_, reject) => { timeout = setTimeout(() => reject(new Error('Safe update boundary timed out.')), remaining); }),
+            ]).finally(() => clearTimeout(timeout));
+            if (cancelled) { await recover('cancelled'); return snapshot(); }
+            if (now() >= deadline) throw new Error('Safe update boundary timed out.');
+            if (proof?.safe === true && proof.pendingWrites === 0 && proof.unsettledPermissions === 0 &&
+                (proof.liveExecutions === 0 || proof.workerHandoffVerified === true)) break;
+            await sleep(pollMs);
+          }
+          await save('detached', 'checkpoint_committed');
+          if (cancelled) { await recover('cancelled'); return snapshot(); }
+          // The updater returns only after installation and candidate health
+          // verification; it owns rollback. An ambiguous outcome stays fenced.
+          await save('detached', 'updating');
+          const result = await update();
+          if (result?.connectionTransferred === true && result?.healthy === true) { state = 'connected'; phase = 'complete'; return snapshot(); }
+          if (result?.healthy !== true) throw new Error('Updated runtime health was not verified.');
+          return await reconcileConnection();
+        } catch (error) {
+          try { await recover('update_failed'); } catch { error.recoveryFailed = true; }
+          throw error;
+        }
+      });
+    },
+    async reconnect() {
+      requireAvailable();
+      if (operation) throw new Error('An update connection operation is already in progress.');
+      state = 'reconciling'; phase = 'closing_admission';
+      return exclusive(async () => {
+      try { await gate.close(); return await reconcileConnection(); }
+      catch (error) { await recover('reconnect_failed'); throw error; }
+    }); },
+    cancel() {
+      if (state !== 'detaching') throw new Error('Cancellation is only available before detachment.');
+      cancelled = true;
+      return snapshot();
+    },
+  };
+}

package/src/update-detachment/dispatch-gate.js

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

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

@@ -0,0 +1,62 @@
+import { join } from 'node:path';
+import { acquireLock } from './state-store.js';
+import { detachmentRoot, readDispatchGate, transitionConnection, prepareUpgradeFence, DISPATCH_PROTOCOL, readTaskAdmission, setTaskAdmissionFence } from './dispatch-gate.js';
+
+// Adapt the published PR1 root barrier without creating a competing ledger.
+// Identity/result verification and safe-boundary proof are mandatory PR2/host
+// dependencies; this module never fabricates either from a task status label.
+export function createLedgerCoordinatorAdapters({ root = detachmentRoot(), boundary, reconcile, readWriters } = {}) {
+  let releaseOwner = null;
+  const release = () => { releaseOwner?.(); releaseOwner = null; };
+  const transition = connection => {
+    const current = readDispatchGate(root);
+    if (current.connection !== connection) transitionConnection({ root, expectedRevision: current.revision, connection });
+  };
+  const recovery = () => {
+    const current = readDispatchGate(root).connection;
+    if (current === 'recovery_required') return;
+    if (['connected', 'ready'].includes(current)) transition('detaching');
+    if (readDispatchGate(root).connection === 'detached') transition('reconciling');
+    transition('recovery_required');
+  };
+  return {
+    store: {
+      read: async () => { const ledger = readDispatchGate(root); return { ...ledger, connectionState: ledger.connection }; },
+      write: async patch => {
+        const next = patch.connectionState;
+        // Reconnect is a verification path, not an assertion that an active
+        // owner drained. Move through recovery instead of claiming detached.
+        if (next === 'reconciling' && readDispatchGate(root).connection === 'detaching') recovery();
+        if (next === 'recovery_required') recovery();
+        else transition(next);
+        if (['connected', 'recovery_required'].includes(next)) release();
+      },
+    },
+    gate: {
+      close: async () => {
+        // Hold ownership across async drain, update and identity verification.
+        // A second process cannot replace a newer barrier using stale proof.
+        releaseOwner ||= acquireLock(join(root, 'update-detachment', 'coordinator')); 
+        if (['connected', 'ready'].includes(readDispatchGate(root).connection)) {
+          if(readWriters) { const writers=await readWriters(),current=readDispatchGate(root);prepareUpgradeFence({root,expectedRevision:current.revision,writers}); }
+          else transition('detaching');
+        }
+      },
+      open: async ({ resumeTasks }) => {
+        if (resumeTasks !== false || readDispatchGate(root).connection !== 'ready') throw new Error('Verified ready ledger required.');
+        transition('connected');
+      },
+      fenceTask: async ({identity,taskId,reason}) => {
+        if(!releaseOwner || !['detaching','reconciling'].includes(readDispatchGate(root).connection)) throw new Error('Coordinator ownership and closed admission required.');
+        const writers=await readWriters(),current=readTaskAdmission({root,identity,taskId});
+        // This is the explicit coordinator authority while its exclusive
+        // lease is held, never a refresh of an old execution dispatch owner.
+        return setTaskAdmissionFence({owner:{root,generation:current.generation,protocol:DISPATCH_PROTOCOL},identity,taskId,
+          expectedRevision:current.revision,expectedFenceRevision:current.record?.revision ?? null,reason,writers});
+      },
+    },
+    handoff: release,
+    boundary,
+    reconcile,
+  };
+}

package/src/update-detachment/ledger-reader.js

@@ -0,0 +1,42 @@
+import { createStateStore, digest } from './state-store.js';
+import { readDispatchGate } from './dispatch-gate.js';
+import { normalizeDispatchIdentity, listDispatchRegistrations } from './provenance.js';
+
+// PR1 stores references, not copied task authority. Read the original record
+// and include all three revisions in the sample; never synthesize missing state.
+export function ledgerSnapshotReader({ identity, taskId, readTaskSnapshot, readGate = readDispatchGate }) {
+  identity = Object.freeze(structuredClone(identity));
+  const exactIdentity = normalizeDispatchIdentity(identity);
+  const exactHashes = new Set([digest(identity), digest(exactIdentity)]);
+  const store = createStateStore(identity);
+  return async () => {
+    const scope = store.read();
+    const registration = scope.tasks[digest(taskId)];
+    if (!registration?.recordRef) throw new Error('Task not registered in exact scope');
+    const task = await readTaskSnapshot(registration.recordRef);
+    if (!task || !Number.isSafeInteger(task.revision) || task.revision < 0 ||
+        !Object.keys(identity).every(key => task.identity?.[key] === identity[key])) throw new Error('Task identity unavailable');
+    const gate = readGate(identity.root);
+    const knownScopes = new Set(listDispatchRegistrations(identity.root, { taskId, retained: true }).map(item=>digest(item.identity)));
+    const attempts = Object.values(gate.attempts).filter(attempt => {
+      if(attempt.taskHash!==digest(taskId))return false;
+      if(exactHashes.has(attempt.identityHash))return true;
+      if(attempt.identityHash && knownScopes.has(attempt.identityHash))return false;
+      // Unbound and unregistered evidence is still ambiguous, never silently
+      // attributed to another provider or discarded as someone else's work.
+      throw new Error('Attempt identity mismatch');
+    }).map(attempt => {
+      if (!exactHashes.has(attempt.identityHash)) throw new Error('Attempt identity mismatch');
+      const receipts = Object.values(gate.receipts).filter(receipt => receipt.attemptId === attempt.id);
+      if (receipts.some(receipt => receipt.generation !== attempt.generation)) throw new Error('Receipt generation mismatch');
+      const ids = [...new Set(receipts.map(receipt => receipt.providerExecutionId).filter(value => value != null))];
+      const refs = [...new Set(receipts.map(receipt => receipt.resultRef).filter(value => value != null))];
+      if (ids.length > 1 || refs.length > 1) throw new Error('Conflicting attempt receipts');
+      const state = attempt.phase === 'provider_identified' ? 'sent' : attempt.phase;
+      return { id: attempt.id, state, generation: attempt.generation,
+        ...(ids.length ? { providerExecutionId: ids[0] } : {}), ...(refs.length ? { resultRef: refs[0] } : {}) };
+    });
+    return { ...structuredClone(task), revision: digest([scope.revision, gate.revision, task]),
+      generation: gate.generation, identity: structuredClone(identity), attempts };
+  };
+}

package/src/update-detachment/provenance.js

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

package/src/update-detachment/provider-adapters.js

@@ -0,0 +1,33 @@
+import { readCodexSession } from '../session-supervision/codex-app-server.js';
+import { readClaudeSession } from '../session-supervision/claude-sessions.js';
+import { processIdentity } from '../codex-plugins/simy/hooks/delivery-loop.mjs';
+
+// The existing owner supplies account/origin, policy, history, artifact and
+// execution evidence as one revisioned observation. No new process is opened.
+// Codex thread/read alone does not establish account, permissions or writer.
+export function codexReconciliationAdapter({ client, readObservation, readSession = readCodexSession }) {
+  return { async observe(snapshot) {
+    if (snapshot.identity.provider !== 'codex') throw new Error('Wrong adapter');
+    const metadata = await readSession(client, snapshot.identity.session);
+    const observed = await readObservation(snapshot);
+    if (metadata?.session !== snapshot.identity.session || metadata.cwd !== snapshot.identity.worktree ||
+        metadata.model !== observed?.policy?.model || observed?.writer?.source !== 'existing_owner') throw new Error('Unverified Codex owner');
+    return observed;
+  } };
+}
+
+export function claudeReconciliationAdapter({ readObservation, readSession = readClaudeSession, inspectProcess = processIdentity }) {
+  return { async observe(snapshot) {
+    if (snapshot.identity.provider !== 'claude') throw new Error('Wrong adapter');
+    const metadata = await readSession({ session: snapshot.identity.session, cwd: snapshot.identity.worktree });
+    const observed = await readObservation(snapshot);
+    const hook = snapshot.liveHook;
+    if (metadata?.session !== snapshot.identity.session || metadata.cwd !== snapshot.identity.worktree ||
+        metadata.observation?.source !== 'claude_local_index' || !hook?.identity ||
+        !Number.isSafeInteger(hook.pid) || hook.pid < 2 ||
+        observed?.liveHook?.source !== 'original_live_hook' ||
+        observed.liveHook.startedAt !== hook.startedAt || observed.liveHook.pid !== hook.pid || observed.liveHook.identity !== hook.identity ||
+        await inspectProcess(hook.pid) !== hook.identity) throw new Error('Original Claude process unavailable');
+    return { ...observed, liveHook: { ...observed.liveHook, verified: true } };
+  } };
+}