@awak-app/simy-cli 0.7.25 → 0.7.27

package/src/remote-connection-guide.js

@@ -0,0 +1,222 @@
+import { execFile, spawn } from 'node:child_process';
+import { readFile, readdir } from 'node:fs/promises';
+import { homedir, hostname, userInfo } from 'node:os';
+import { dirname, isAbsolute, join, resolve } from 'node:path';
+import { promisify } from 'node:util';
+import { friendlyCheck } from './connection-presentation.js';
+
+const execute = promisify(execFile);
+const aliasPattern = /^[a-zA-Z0-9][a-zA-Z0-9._@-]{0,127}$/;
+const quote = value => "'" + String(value).replaceAll("'", "'\\''") + "'";
+const safeText = value => String(value).replace(/[\x00-\x1f\x7f-\x9f]/g, '');
+const SSH_OPTIONS = ['-o', 'StrictHostKeyChecking=yes', '-o', 'ConnectTimeout=8'];
+
+export function assertRemoteAlias(alias) {
+  if (typeof alias !== 'string' || !aliasPattern.test(alias)) throw new Error('一覧に表示された接続先名を指定してください。一覧を見るには simy connections を実行してください。');
+  return alias;
+}
+
+// Discovery reads local configuration only. It never probes hosts, executes
+// Match/ProxyCommand directives, imports credentials, or changes registrations.
+export async function discoverRemoteConnections({ home = homedir(), root = process.env.SIMY_HOME?.trim() || join(home, '.simy') } = {}) {
+  const hosts = new Map(), warnings = [], visited = new Set();
+  const add = (alias, source, label = alias, enabled = true) => {
+    if (!aliasPattern.test(alias) || hosts.size >= 128) return;
+    const current = hosts.get(alias);
+    if (current) { if (!current.sources.includes(source)) current.sources.push(source); return; }
+    hosts.set(alias, { alias, label: safeText(label).slice(0, 80), enabled, sources: [source] });
+  };
+  try {
+    const saved = JSON.parse(await readFile(join(root, 'remote-hosts.json'), 'utf8'));
+    if (saved.schemaVersion !== 1 || !Array.isArray(saved.hosts) || saved.hosts.length > 128) throw new Error('invalid');
+    for (const host of saved.hosts) {
+      if (!host || typeof host.alias !== 'string' || !aliasPattern.test(host.alias) ||
+          (host.enabled !== undefined && typeof host.enabled !== 'boolean')) throw new Error('invalid');
+      add(host.alias, 'SIMY', typeof host.label === 'string' ? host.label : host.alias, host.enabled !== false);
+    }
+  } catch (error) { if (error.code !== 'ENOENT') warnings.push('SIMYの端末設定を読み取れません。設定を確認してください。'); }
+  async function scan(file) {
+    const location = resolve(file);
+    if (visited.has(location)) return;
+    if (visited.size >= 32) { warnings.push('接続設定が多いため、一部のパソコンを省略しました。見つからない場合は設定を手伝う人に確認してください。'); return; }
+    visited.add(location);
+    let content;
+    try { content = await readFile(location, 'utf8'); }
+    catch (error) { if (error.code !== 'ENOENT') warnings.push('パソコンへの接続設定の一部を読み取れません。'); return; }
+    if (Buffer.byteLength(content) > 256 * 1024) { warnings.push('接続設定のファイルが大きすぎるため、一部のパソコンを省略しました。'); return; }
+    for (const line of content.split(/\r?\n/)) {
+      const tokens = sshTokens(line);
+      const key = tokens.shift()?.toLowerCase();
+      if (key === 'host') for (const alias of tokens) add(alias, 'SSH');
+      if (key === 'include') {
+        for (const token of tokens) {
+          const expanded = token.startsWith('~/') ? join(home, token.slice(2)) : isAbsolute(token) ? token : join(home, '.ssh', token);
+          for (const included of await expandIncludes(expanded)) await scan(included);
+        }
+      }
+    }
+  }
+  await scan(join(home, '.ssh', 'config'));
+  return { hosts: [...hosts.values()], warnings: [...new Set(warnings)] };
+}
+
+function sshTokens(line) {
+  const result = []; let token = '', quoted = false, escaped = false;
+  for (const character of line) {
+    if (escaped) { token += character; escaped = false; continue; }
+    if (character === '\\') { escaped = true; continue; }
+    if (character === '"') { quoted = !quoted; continue; }
+    if (!quoted && character === '#') break;
+    if (!quoted && (/\s/.test(character) || (character === '=' && result.length === 0))) {
+      if (token) { result.push(token); token = ''; }
+    } else token += character;
+  }
+  if (token) result.push(token);
+  return result;
+}
+
+async function expandIncludes(pattern) {
+  if (!/[?*\[]/.test(pattern)) return [pattern];
+  const parent = dirname(pattern);
+  const parents = /[?*\[]/.test(parent) ? await expandIncludes(parent) : [parent];
+  const name = pattern.slice(parent.length + 1);
+  // OpenSSH commonly uses Include config.d/*.conf. Unsupported bracket globs
+  // are not interpreted as literal host names or executed by a shell.
+  if (name.includes('[')) return [];
+  const matcher = new RegExp('^' + name.split('').map(c => c === '*' ? '.*' : c === '?' ? '.' : c.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')).join('') + '$');
+  const found = [];
+  for (const directory of parents.slice(0, 32)) {
+    try {
+      for (const entry of (await readdir(directory)).sort()) {
+        if (matcher.test(entry)) found.push(join(directory, entry));
+        if (found.length >= 32) return found;
+      }
+    } catch { /* An unmatched Include contributes no candidates. */ }
+  }
+  return found;
+}
+
+export function connectionStartupHint(discovery) {
+  if (!discovery.hosts.length && !discovery.warnings.length) return '';
+  return `保存されているパソコン: ${discovery.hosts.length}件（まだ接続できるかは未確認）。SIMYの入力欄で /connections、または別のターミナルで simy connections を入力してください。`;
+}
+
+export function connectionGuideLines(alias) {
+  assertRemoteAlias(alias);
+  return [
+    `接続先のパソコン: ${alias}`,
+    'このパソコンでターミナルをもう1つ開き、次の1行をコピーして実行してください。',
+    `simy connections check ${alias}`,
+    '「相手のパソコンにつながりました」と表示されたら、次の1行で相手のSIMYを開けます。',
+    `simy connections connect ${alias}`,
+    '相手側のSIMY画面が表示されたら接続完了です。相手のSIMYを終了すると、このパソコンに戻ります。',
+    'つながらない場合は、このパソコンで次の1行を実行してください。順番に対処方法をご案内します。',
+    `simy connections recover ${alias}`,
+    '相手からこちらへ接続する方法もあります。上の案内で「相手のパソコンからつなぐ方法を見る」を選んでください。',
+    'その方法では、相手側で simy connections tunnel 接続先名 を使います。「接続先名」には相手側の一覧でこのパソコンを指す名前を入れます。',
+    '接続中は相手側のターミナルを開いたままにします。詳しい手順は上の対処方法で確認できます。',
+    '接続先の住所（IPアドレス）が変わった場合は、接続設定をした人に設定の更新を依頼してください。',
+    '設定に名前を使っている場合は、接続のたびに現在の住所を調べます。'
+  ];
+}
+
+export function reverseCliCommand(port, { name = hostname(), user = userInfo().username } = {}) {
+  if (!Number.isInteger(port) || port < 1 || port > 65535) throw new Error('Invalid tunnel port.');
+  return `ssh -t -o ${quote(`HostKeyAlias=${name}`)} -p ${port} -l ${quote(user)} 127.0.0.1 "exec sh -lc 'exec simy'"`;
+}
+
+export async function runRemoteConnectionsCommand(argv, { discovery, output = console.log, errorOutput = console.error,
+  executeImpl = execute, spawnImpl = spawn, home, root, webOrigin, identity = { name: hostname(), user: userInfo().username } } = {}) {
+  if (['diagnose', 'recover'].includes(argv[0])) {
+    const { runConnectionRecovery } = await import('./connection-recovery.js');
+    return runConnectionRecovery(argv, { output, root, webOrigin });
+  }
+  const [action, alias, ...extra] = argv;
+  const localPort = extra.length === 2 && extra[0] === '--local-port' && /^\d+$/.test(extra[1]) ? Number(extra[1]) : 22;
+  if ((extra.length && !(action === 'tunnel' && extra.length === 2 && extra[0] === '--local-port' && /^\d+$/.test(extra[1]) && localPort >= 1 && localPort <= 65535)) || (['guide', 'check', 'connect', 'tunnel'].includes(action) && !alias) ||
+      (action && !['guide', 'check', 'connect', 'tunnel', '--help', '-h'].includes(action)) ||
+      (['--help', '-h'].includes(action) && alias)) throw new Error('入力内容を確認してください。simy connections を実行すると接続先の一覧と使い方が表示されます。');
+  if (!action || ['--help', '-h'].includes(action)) {
+    const candidates = discovery || await discoverRemoteConnections({ home, root });
+    output('別のパソコンのSIMYにつなぐ');
+    output('保存されている接続先です。まだ接続できるかは確認していません。');
+    for (const host of candidates.hosts) output(`  ${host.alias} — ${host.label}${host.enabled ? '' : '（SIMYとの接続解除済み）'}`);
+    for (const warning of candidates.warnings) output(warning);
+    if (!candidates.hosts.length) output('保存されているパソコンがありません。接続先を用意した人に、接続設定と接続先名を確認してください。');
+    else {
+      output('このパソコンのターミナルで、次の1行をコピーして実行すると手順が表示されます。');
+      output(`simy connections guide ${candidates.hosts[0].alias}`);
+      output('別のパソコンを選ぶ場合は、最後の名前を上の一覧の接続先名に置き換えてください。');
+    }
+    output('SIMYがつながらないとき: simy connections recover');
+    output('Codexのログインや連携を確認: simy connections recover provider:codex');
+    output('Claudeのログインや連携を確認: simy connections recover provider:claude');
+    output('Webサービスを確認: simy connections recover に続けて、半角スペースと確認したいWebアドレスを入力してください。');
+    output('確認だけをする場合は recover を diagnose に置き換えてください。');
+    output('設定を手伝う人向け: diagnose / recover に --details で技術情報、--json で機械向けの結果を表示できます。');
+    output('外部サービスの接続キーは --token-env 環境変数名 で指定できます。設定方法はサービスの担当者に確認してください。');
+    return 0;
+  }
+  assertRemoteAlias(alias);
+  if (action === 'guide') { connectionGuideLines(alias).forEach(line => output(line)); return 0; }
+  if (action === 'check') {
+    try {
+      const result = await executeImpl('ssh', ['-T', ...SSH_OPTIONS, '-o', 'BatchMode=yes', '--', alias, "sh -lc 'command -v simy'"],
+        { timeout: 15_000, maxBuffer: 64 * 1024, windowsHide: true });
+      if (!result.stdout?.trim()) throw new Error('CLI not found');
+      output(`${alias}: 相手のパソコンにつながりました。SIMYも見つかりました。相手側のSIMYへのログインは、開いてから確認してください。`);
+      output(`接続: simy connections connect ${alias}`);
+      return 0;
+    } catch (error) {
+      const { classifySshFailure, issueFor } = await import('./connection-health.js');
+      const issue = friendlyCheck(issueFor(classifySshFailure(error)));
+      errorOutput(`${alias}: ${issue.message}`);
+      issue.steps.forEach((step, i) => output(`${i + 1}. ${step}`));
+      output('このパソコンのターミナルで、次の1行をコピーして実行してください。順番に対処方法をご案内します。');
+      output(`simy connections recover ${alias}`);
+      return 1;
+    }
+  }
+  if (action === 'connect') {
+    output(`${alias} のSIMYを開きます。相手側のSIMY画面が表示されたら接続完了です。相手のSIMYを終了すると、このパソコンに戻ります。`);
+    return await waitForSsh(spawnImpl('ssh', ['-t', ...SSH_OPTIONS, '--', alias, "exec sh -lc 'exec simy'"], { stdio: 'inherit', shell: false }), errorOutput);
+  }
+  output(`${alias} からこのパソコンへつなぐための、一時的な接続経路を作ります。このターミナルは開いたままにしてください。`);
+  output('次のコマンドが表示されるまでお待ちください。中止するにはCtrlキーを押しながらCキーを押してください。');
+  const child = spawnImpl('ssh', ['-v', '-N', ...SSH_OPTIONS, '-o', 'ExitOnForwardFailure=yes',
+    '-o', 'ServerAliveInterval=15', '-o', 'ServerAliveCountMax=3', '-R', `127.0.0.1:0:127.0.0.1:${localPort}`, '--', alias],
+    { stdio: ['inherit', 'inherit', 'pipe'], shell: false });
+  let buffer = '', announced = false;
+  child.stderr.on('data', data => {
+    // Keep verbose SSH output private; show a plain-language remedy on failure.
+    buffer = (buffer + data.toString('utf8')).slice(-8192);
+    const match = buffer.match(/Allocated port (\d+) for remote forward/);
+    if (!announced && match) {
+      const port = Number(match[1]);
+      if (port < 1 || port > 65535) return;
+      announced = true;
+      output(`接続経路ができました。${alias} のパソコンでターミナルを開き、下の1行をコピーして実行してください:`);
+      output(reverseCliCommand(port, identity));
+      output('相手の身元を確認する英語の質問が出たら、分からないまま許可せず、接続設定をした人に確認してください。担当者は、今この経路を作ったパソコンで次を実行して確認情報を照合できます:');
+      output('ssh-keygen -lf /etc/ssh/ssh_host_ed25519_key.pub');
+      output('相手からこのパソコンのSIMYが開けば接続完了です。接続中はこのターミナルを開いたままにしてください。閉じると接続も切れます。');
+    }
+  });
+  const result = await waitForSsh(child, errorOutput);
+  if (!announced) {
+    const { classifySshFailure } = await import('./connection-health.js');
+    const plain = friendlyCheck({ code: classifySshFailure({ stderr: buffer }) });
+    errorOutput('接続経路を作れたか確認できませんでした。' + plain.message);
+    plain.steps.forEach(step => output(step));
+    output(`このパソコンで次を実行すると、順番に対処方法をご案内します: simy connections recover ${alias}`);
+    return result || 1;
+  }
+  return result;
+}
+
+function waitForSsh(child, errorOutput) {
+  return new Promise(resolve => {
+    child.once('error', () => { errorOutput('パソコンへの接続を始められませんでした。設定を手伝う人に、OpenSSHという接続用ソフトが使えるか確認してもらってください。'); resolve(1); });
+    child.once('close', (code, signal) => resolve(Number.isInteger(code) ? code : signal === 'SIGINT' ? 130 : 1));
+  });
+}

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

@@ -6,6 +6,7 @@ import { providerGoalEvidence } from './conversation-context.js';
 
 const BACKFILL_LIMIT = 10;
 const MAX_CACHE_ENTRIES = 2000;
+const MAX_CACHE_BYTES = 4 * 1024 * 1024;
 const AUTH_RECOVERY_COOLDOWN_MS = 60_000;
 const RESULT_STATES = new Set(['continue', 'no_action', 'needs_user', 'waiting', 'uncertain']);
 const keyOf = candidate => `${candidate.provider}:${candidate.session}`;
@@ -23,7 +24,10 @@ export const continuationAnalysisRevision = candidate => createHash('sha256')
   .update(JSON.stringify([candidate.provider, candidate.session, candidate.cwd, turnOf(candidate) ? ['turn', turnOf(candidate)] : activityOf(candidate),
     ...(candidate.isRunning === true ? ['running'] : []), ...(goalOf(candidate) === null ? [] : ['goal', goalOf(candidate)])]))
   .digest('hex');
-const eligible = candidate => candidate.capabilities?.canAnalyze === true &&
+// Route analysis is read-only for bound loops too; execution remains owned by
+// their existing controller. Never admit them through requireRecommendation().
+const eligible = candidate => candidate.capabilities?.canAnalyze === true;
+const canDispatchRecommendation = candidate => eligible(candidate) &&
   ['unmanaged', 'monitor'].includes(candidate.binding?.mode || 'unmanaged');
 
 // Recommendations are metadata only. This worker never enrolls a conversation
@@ -38,7 +42,7 @@ export async function createContinuationAnalysisManager({ root, analyze = analyz
   let document, cacheInfo;
   try {
     cacheInfo = await lstat(path);
-    if (!cacheInfo.isFile() || cacheInfo.isSymbolicLink() || cacheInfo.size > 4 * 1024 * 1024) throw new Error('Invalid session analysis cache.');
+    if (!cacheInfo.isFile() || cacheInfo.isSymbolicLink() || cacheInfo.size > MAX_CACHE_BYTES) throw new Error('Invalid session analysis cache.');
     document = JSON.parse(await readFile(path, 'utf8'));
     const pairs = list => Array.isArray(list) && list.every(pair => Array.isArray(pair) && pair.length === 2 && typeof pair[0] === 'string' && pair[1] && typeof pair[1] === 'object');
     if (document.schemaVersion !== 1 || typeof document.initialized !== 'boolean' || !pairs(document.known) || !pairs(document.entries) ||
@@ -78,9 +82,25 @@ export async function createContinuationAnalysisManager({ root, analyze = analyz
   };
   const persist = async () => {
     for (const map of [known, entries]) while (map.size > MAX_CACHE_ENTRIES) map.delete(map.keys().next().value);
+    // Bound the serialized snapshot too: a count limit alone can produce a
+    // cache that this same reader rejects after restart. Keep in-flight jobs
+    // in memory; dropping optional cached recommendations must not cancel them.
+    const snapshot = { ...document, known: [...known], entries: [...entries] };
+    const encode = () => JSON.stringify(snapshot) + '\n';
+    let bytes = Buffer.byteLength(encode());
+    for (const list of [snapshot.entries, snapshot.known]) {
+      let remove = 0;
+      while (bytes > MAX_CACHE_BYTES && remove < list.length) {
+        bytes -= Buffer.byteLength(JSON.stringify(list[remove])) + (list.length - remove > 1 ? 1 : 0);
+        remove++;
+      }
+      list.splice(0, remove);
+    }
+    const payload = encode();
+    if (Buffer.byteLength(payload) > MAX_CACHE_BYTES) throw new Error('Session analysis metadata exceeds cache capacity.');
     const temporary = `${path}.${randomUUID()}.tmp`;
     try {
-      await writeFile(temporary, JSON.stringify({ ...document, known: [...known], entries: [...entries] }) + '\n', { mode: 0o600 });
+      await writeFile(temporary, payload, { mode: 0o600 });
       await rename(temporary, path);
     } finally { await rm(temporary, { force: true }); }
   };
@@ -345,7 +365,7 @@ export async function createContinuationAnalysisManager({ root, analyze = analyz
     requireRecommendation(candidate, { allowDiagnosis = false } = {}) {
       if (closed || suspended) throw new Error('Session analysis is unavailable.');
       const analysis = this.project(candidate).analysis;
-      if (!eligible(candidate) || candidate.isRunning === true || analysis.awaitingTurn === true || !(analysis.state === 'continue' || allowDiagnosis && candidate.provider === 'codex' && candidate.autoContinue === true && !analysis.incomplete && analysis.contextDigest && ['needs_user', 'uncertain', 'waiting'].includes(analysis.state))) throw new Error('Analyze this conversation before continuing; it needs a current recommendation.');
+      if (!canDispatchRecommendation(candidate) || candidate.isRunning === true || analysis.awaitingTurn === true || !(analysis.state === 'continue' || allowDiagnosis && candidate.provider === 'codex' && candidate.autoContinue === true && !analysis.incomplete && analysis.contextDigest && ['needs_user', 'uncertain', 'waiting'].includes(analysis.state))) throw new Error('Analyze this conversation before continuing; it needs a current recommendation.');
       return analysis;
     },
     async whenIdle() {

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

@@ -12,7 +12,7 @@ function continuationFailureReason(error) {
     unsupported: 'Update the original AI provider to a compatible version, then retry auto-continue.',
     process_exited: 'The original Claude process has exited. Return to the original conversation, then refresh.',
     session_ended: 'This Claude session has ended. Return to the original conversation, then refresh.',
-    hook_missing: 'SIMY has not observed the original Claude session-start hook. Check the plugin and hook execution, then refresh.',
+    hook_missing: 'Waiting for the original Claude hook. SIMY recovers automatically when the next verified prompt or response-end hook arrives. If no notifications arrive, check the SIMY plugin in the original Claude window.',
   };
   return Object.hasOwn(reasons, error?.code) ? reasons[error.code] : 'Could not start auto-continue. Check the original conversation and retry.';
 }
@@ -38,12 +38,24 @@ export async function continueAnalyzedSession({ candidate, manager, root, settin
   return enroll({ root, provider: candidate.provider, session: candidate.session, ...settings, expectedProviderEpoch: link.epoch });
 }
 
-// One pending enrollment per identity. A failed attempt is retried only after
-// context/opt-in changes; an existing (including terminal) run is never reset.
+const transientStartFailure = code => ['ETIMEDOUT', 'ECONNRESET', 'ECONNREFUSED', 'EAI_AGAIN',
+  'timeout', 'unavailable', 'closed'].includes(code);
+
+function startingPresentation(candidate, status, reason) {
+  const work = candidate.workState;
+  const canPresent = work && !work.needsAttention && !['running', 'stopped', 'archived', 'approval', 'question'].includes(work.state);
+  return { ...candidate, autoContinueStatus: status, autoContinueReason: reason,
+    ...(canPresent ? { workState: { ...work, state: status,
+      label: status === 'starting' ? '自動継続を準備中' : '自動復旧中', reason,
+      nextAction: null, needsAttention: false } } : {}) };
+}
+
+// One pending start per identity. Only known transient failures may retry the
+// same context, with backoff and fresh consent/task checks before each attempt.
 export function createAutomaticContinuation({ root, getManager, selectCandidate,
   readSetting = readSessionAutoContinue, readContext = readContinuationContext, enroll = continueSession,
-  beforeEnroll = async () => {}, onChange = () => {} }) {
-  const pending = new Map(), attempted = new Map(), errors = new Map();
+  beforeEnroll = async () => {}, onChange = () => {}, now = Date.now }) {
+  const pending = new Map(), attempted = new Map(), errors = new Map(), retries = new Map();
   let closed = false;
   const tick = candidates => {
     if (closed) return;
@@ -53,59 +65,98 @@ export function createAutomaticContinuation({ root, getManager, selectCandidate,
     for (const candidate of candidates) {
       const key = `${candidate.provider}:${candidate.session}`;
       const attempt = attempted.get(key);
-      const bound = ['managed', 'pending_takeover', 'standard_loop'].includes(candidate.binding?.mode);
+      const bound = ['managed', 'pending_takeover'].includes(candidate.binding?.mode);
       if (candidate.autoContinue !== true || bound ||
           attempt && !attempt.startsWith(`${candidate.autoContinueEpoch}:`)) {
-        attempted.delete(key); errors.delete(key);
+        attempted.delete(key); errors.delete(key); retries.delete(key);
       }
     }
     for (const candidate of candidates) {
       if (pending.size >= 3) break;
+      const upgradeRunId = candidate.binding?.mode === 'standard_loop' ? candidate.binding.upgradeRunId : null;
       if (candidate.autoContinue !== true || !candidate.autoContinueEpoch || candidate.isRunning ||
-          candidate.capabilities?.canAutoContinue !== true || candidate.capabilities?.canContinue !== true) continue;
+          upgradeRunId && candidate.isRunning !== false ||
+          ['managed', 'pending_takeover'].includes(candidate.binding?.mode) ||
+          candidate.capabilities?.canAutoContinue !== true || !upgradeRunId && candidate.capabilities?.canContinue !== true) continue;
       const key = `${candidate.provider}:${candidate.session}`;
       if (pending.has(key)) continue;
       let recommendation;
       const manager = getManager();
-      try { recommendation = manager.requireRecommendation(candidate, { allowDiagnosis: candidate.provider === 'codex' && candidate.autoContinue === true }); } catch { continue; }
+      if (upgradeRunId) recommendation = { contextDigest: `upgrade:${upgradeRunId}` };
+      else try { recommendation = manager.requireRecommendation(candidate, { allowDiagnosis: candidate.provider === 'codex' && candidate.autoContinue === true }); } catch { continue; }
       const attempt = `${candidate.autoContinueEpoch}:${recommendation.contextDigest}`;
-      if (attempted.get(key) === attempt) continue;
+      const retry = retries.get(key);
+      if (attempted.get(key) === attempt && (!retry || retry.attempt !== attempt || now() < retry.at)) continue;
+      if (retry?.attempt !== attempt) retries.delete(key);
       attempted.set(key, attempt);
       errors.delete(key);
       const controller = new AbortController();
       const guard = async () => {
-        await requireProviderLink({ root, provider: candidate.provider });
+        const link = await requireProviderLink({ root, provider: candidate.provider });
         const setting = await readSetting({ root, provider: candidate.provider, session: candidate.session });
-        if (closed || controller.signal.aborted || !setting.enabled || setting.epoch !== candidate.autoContinueEpoch || setting.hasRun) throw new Error('Automatic continuation was disabled or already enrolled.');
-        return setting;
+        if (closed || controller.signal.aborted || !setting.enabled || setting.epoch !== candidate.autoContinueEpoch ||
+            (upgradeRunId ? setting.upgradeRunId !== upgradeRunId : setting.hasRun)) throw new Error('Automatic continuation was disabled or already enrolled.');
+        return { ...setting, expectedProviderEpoch: link.epoch };
       };
       const job = Promise.resolve().then(async () => {
         const setting = await guard();
         const fresh = await selectCandidate(candidate);
         if (!fresh.autoContinue || fresh.autoContinueEpoch !== candidate.autoContinueEpoch) throw new Error('Automatic continuation setting changed.');
+        if (upgradeRunId) {
+          if (fresh.isRunning !== false || fresh.binding?.upgradeRunId !== upgradeRunId || fresh.capabilities?.canAutoContinue !== true) {
+            attempted.delete(key);
+            return;
+          }
+          await beforeEnroll(fresh);
+          await guard();
+          await requireProviderLink({ root, provider: candidate.provider, expectedEpoch: setting.expectedProviderEpoch });
+          await enroll({ root, provider: fresh.provider, session: fresh.session, ...setting.settings,
+            ...(fresh.provider === 'codex' ? { purposeDriven: true } : {}),
+            upgradeRunId, autoContinueEpoch: candidate.autoContinueEpoch, expectedProviderEpoch: setting.expectedProviderEpoch });
+          return;
+        }
         await continueAnalyzedSession({ root, candidate: fresh, manager, signal: controller.signal,
           readContext, enroll, beforeEnroll: async selected => { await guard(); await beforeEnroll(selected); },
           settings: { ...setting.settings, ...(fresh.provider === 'codex' ? { purposeDriven: true } : {}), autoContinueEpoch: candidate.autoContinueEpoch } });
       }).catch(error => {
         if (!closed && !controller.signal.aborted && !/disabled|already enrolled|setting changed|conversation changed; wait|needs a current recommendation/i.test(error?.message || '')) {
-          errors.set(key, { epoch: candidate.autoContinueEpoch, reason: continuationFailureReason(error) });
+          const recoverable = transientStartFailure(error?.code);
+          if (recoverable) {
+            const count = (retries.get(key)?.count || 0) + 1;
+            retries.set(key, { attempt, count, at: now() + Math.min(60_000, 1000 * 2 ** Math.min(count - 1, 6)) });
+          } else retries.delete(key);
+          errors.set(key, { epoch: candidate.autoContinueEpoch, recoverable,
+            reason: recoverable ? 'The AI connection is temporarily unavailable. Automatic continuation will retry when the connection is available.' : continuationFailureReason(error) });
         }
-      }).finally(() => { pending.delete(key); if (!closed) onChange(); });
+      }).finally(() => {
+        if (controller.signal.aborted) { attempted.delete(key); retries.delete(key); }
+        pending.delete(key); if (!closed) onChange();
+      });
       pending.set(key, { job, controller });
     }
   };
   return { tick,
     retry(provider, session) {
       const key = `${provider}:${session}`;
-      if (!closed && !pending.has(key)) { attempted.delete(key); errors.delete(key); }
+      if (!closed && !pending.has(key)) { attempted.delete(key); errors.delete(key); retries.delete(key); }
     },
     project(candidate) {
+      const key = `${candidate.provider}:${candidate.session}`;
+      if (candidate.autoContinue === true && candidate.capabilities?.canAutoContinue === true &&
+          !['managed', 'pending_takeover'].includes(candidate.binding?.mode)) {
+        if (pending.has(key)) return startingPresentation(candidate, 'starting',
+          'Auto-continue is saved. Preparing to continue this conversation in the background.');
+        const failure = errors.get(key);
+        if (failure?.recoverable && failure.epoch === candidate.autoContinueEpoch)
+          return startingPresentation(candidate, 'recovering', failure.reason);
+      }
       if (candidate.autoContinue === true && candidate.isRunning !== true &&
           ['unmanaged', 'monitor'].includes(candidate.binding?.mode || 'unmanaged') && candidate.analysis?.state === 'needs_user') return {
         ...candidate, autoContinueStatus: 'needs_user', autoContinueReason: candidate.analysis.reason || 'Your decision is needed before automatic continuation can proceed.',
       };
       const error = errors.get(`${candidate.provider}:${candidate.session}`);
-      if (candidate.autoContinue === true && candidate.autoContinueEpoch === error?.epoch && candidate.capabilities?.canContinue === true &&
+      if (error && candidate.autoContinue === true && candidate.autoContinueEpoch === error.epoch &&
+          (candidate.capabilities?.canContinue === true || candidate.binding?.upgradeRunId) &&
           !['no_action', 'needs_user', 'waiting', 'uncertain'].includes(candidate.analysis?.state)) return {
         ...candidate, autoContinueStatus: 'error', autoContinueReason: error.reason,
       };
@@ -122,7 +173,7 @@ export function createAutomaticContinuation({ root, getManager, selectCandidate,
       closed = true;
       for (const entry of pending.values()) entry.controller.abort();
       await Promise.allSettled([...pending.values()].map(entry => entry.job));
-      attempted.clear(); errors.clear();
+      attempted.clear(); errors.clear(); retries.clear();
     },
   };
 }

package/src/session-supervision/codex-app-server.js

@@ -2,7 +2,7 @@ import { agentRole } from '../codex-plugins/simy/hooks/loop-kernel.mjs';
 import { captureAcceptanceReads } from './acceptance-reads.js';
 import { providerFailureDiagnostic } from './provider-failure.js';
 import { captureDispatchProvenance } from '../update-detachment/provenance.js';
-import { captureDispatchOwner, assertTaskAdmission, dispatchWithFence, queueDispatchReceipt, rootFromDelivery } from '../update-detachment/dispatch-gate.js';
+import { captureDispatchOwner, assertTaskAdmission, dispatchWithFence, queueDispatchReceipt, queueProviderTerminalReceipt, rootFromDelivery } from '../update-detachment/dispatch-gate.js';
 import { normalizePullRequests } from './pull-requests.js';
 import { delegatedNativeSandbox, canWriteWorkspace, authorizedWorktreeGitRoots } from './native-delegation.js';
 import { flexibleReasoning } from '../codex-plugins/simy/hooks/purpose-cycle.mjs';
@@ -541,7 +541,16 @@ export async function readCodexConversation(candidate, { openClient = openCodexA
     let cursor = null;
     do {
       if (signal?.aborted) throw new CodexAppServerError('cancelled', 'Conversation analysis was cancelled.');
-      const page = await readPage(cursor, ANALYSIS_MAX_TURNS - turns.filter(terminal).length);
+      let page;
+      try { page = await readPage(cursor, ANALYSIS_MAX_TURNS - turns.filter(terminal).length); }
+      catch (error) {
+        // An oversized older turn (often attachments) must not discard an
+        // already complete recent exchange. This is omitted history, not a
+        // fabricated turn. Latest-page overflow still fails closed, and the
+        // classifier must judge whether the bounded context is sufficient.
+        if (cursor && turns.some(terminal) && error?.code === 'response_too_large') break;
+        throw error;
+      }
       for (const turn of page.data) {
         if (typeof turn?.id !== 'string' || !turn.id || turnIds.has(turn.id)) throw new CodexAppServerError('context_unavailable', 'Codex returned ambiguous conversation pagination.');
         turnIds.add(turn.id); turns.push(turn);
@@ -654,9 +663,10 @@ async function frozenNativeSandbox(record, root, signal) {
   return policy;
 }
 
-export async function executeCodexAppServer(record, { webOrigin, openClient = openCodexAppServer, signal, authorizePreparation = async () => {}, beforeDispatch = async () => {}, onStarted = async () => {}, onActivity = () => {}, onUsage = () => {}, onEvidence = async () => {}, observeExternal = collectPurposeObservations, root, auditOnly = false, opinionOnly = false, peerAction, runPeerReview = runCodexPeerOpinion } = {}) {
+export async function executeCodexAppServer(record, { webOrigin, openClient = openCodexAppServer, signal, authorizePreparation = async () => {}, beforeDispatch = async () => {}, onStarted = async () => {}, onActivity = () => {}, onUsage = () => {}, onEvidence = async () => {}, observeExternal = collectPurposeObservations, root, auditOnly = false, opinionOnly = false, peerAction, dispatchAttemptId: requestedAttemptId, runPeerReview = runCodexPeerOpinion } = {}) {
   const dispatchOwner = captureDispatchOwner(root ? rootFromDelivery(root) : undefined);
   let dispatchAttemptId;
+  if (requestedAttemptId && (!auditOnly || record.run?.managed?.outcomeAudit?.lease?.id !== requestedAttemptId)) throw new CodexAppServerError('identity', 'Independent audit dispatch must use its original lease.');
   const provenance = captureDispatchProvenance({ root: dispatchOwner.root, provider: record.provider, providerSession: record.session, worktree: taskDirectory(record), taskId: record.run.managed.taskId, recordRef: recordPath(root || rootDirectory(), record.provider, record.session) });
   assertTaskAdmission(dispatchOwner, { taskId: provenance.taskId, provenance });
   const run = record.run, decision = run.managed?.decision;
@@ -697,13 +707,29 @@ export async function executeCodexAppServer(record, { webOrigin, openClient = op
       output_schema: { type: 'object', properties: { opinion: { type: 'string' } }, required: ['opinion'], additionalProperties: false },
     }, { signal, readOnlyAnalysis: true, allowAutomaticRetry: false,
       model: run.managed.resumeModel, cwd: taskDirectory(record), openClient, readAuthentication: readCodexAuthentication,
-      dispatchTransport: initiate => dispatchWithFence(dispatchOwner, { taskId: run.managed.taskId || record.session, attemptId: run.managed.resumeLease?.id, provenance }, attemptId => {
+      dispatchTransport: initiate => dispatchWithFence(dispatchOwner, { taskId: run.managed.taskId || record.session, attemptId: requestedAttemptId || run.managed.resumeLease?.id,
+        provenance: captureDispatchProvenance({ root: dispatchOwner.root, provider: record.provider, providerSession: peerSession,
+          worktree: taskDirectory(record), taskId: run.managed.taskId || record.session, recordRef: recordPath(root || rootDirectory(), record.provider, record.session) }) }, attemptId => {
+        assertTaskAdmission(dispatchOwner, { taskId: provenance.taskId, provenance });
         if (root && hasPendingUserStop(root, record)) throw new CodexAppServerError('cancelled', 'User stopped this provider task.');
         dispatchAttemptId = attemptId;
         return initiate();
       }),
       beforeDispatch: async () => { await authorizePreparation(); await beforeDispatch({ type: 'readOnly', networkAccess: false }); },
-      onContext: session => { if (peerSession && peerSession !== session) ambiguousContext = true; peerSession = session; },
+      onContext: async session => {
+        if (!session || session === record.session || peerSession && peerSession !== session) { ambiguousContext = true; throw new CodexAppServerError('identity', 'Independent peer context changed.'); }
+        peerSession = session;
+        await onEvidence({ source: 'adapter_capture', actionId: decision.id, workerContext: { session, originalSession: record.session, cwd: taskDirectory(record), model: run.managed.resumeModel, ephemeralRequested: true } });
+      },
+      onStarted: ({ session, turnId }) => {
+        if (!dispatchAttemptId || session !== peerSession) throw new CodexAppServerError('identity', 'Independent peer identity changed.');
+        queueDispatchReceipt({ root: dispatchOwner.root, attemptId: dispatchAttemptId, receiptId: `provider:${dispatchAttemptId}:${turnId}`, providerExecutionId: turnId });
+        onActivity();
+      },
+      onTerminal: ({ session, turnId, status, response }) => {
+        if (!dispatchAttemptId || session !== peerSession || session === record.session) throw new CodexAppServerError('identity', 'Independent peer identity changed.');
+        queueProviderTerminalReceipt({ root: dispatchOwner.root, attemptId: dispatchAttemptId, providerSession: session, providerExecutionId: turnId, status, response });
+      },
       onUsage: observed => { usage = observed; onUsage(observed); } });
     if (!peerSession || peerSession === record.session || ambiguousContext || typeof reply.output?.opinion !== 'string' || !reply.output.opinion.trim()) throw new CodexAppServerError('identity', 'Independent peer context or opinion unavailable.');
     return { code: 0, dispatchAttemptId, opinion: { text: evidenceExcerpt(reply.output.opinion, 2000).text, source: 'independent_codex_session', session: peerSession, model: reply.model }, usage, toolEvidence: [] };
@@ -722,6 +748,8 @@ export async function executeCodexAppServer(record, { webOrigin, openClient = op
   const beforeEvidence = searchEnabled(run.managed) && !reviewing ? await captureWorkspace() : null;
   let evidenceQueue = Promise.resolve(), evidenceFailure = null;
   let activeTurnId = null, turnCompleted = false, turnStart = null, startReceipt = null;
+  let releaseTurnNotifications, terminalResolve;
+  const terminalObserved = new Promise(resolve => { terminalResolve = resolve; });
   let usage = null, lastTotal = null;
   try {
     // An unavailable login is a connection dependency, not an action approval.
@@ -870,13 +898,18 @@ export async function executeCodexAppServer(record, { webOrigin, openClient = op
         lastTotal = Math.max(lastTotal ?? 0, total);
         onUsage({ ...usage });
       };
-      const cleanup = () => { unsubscribe(); signal?.removeEventListener('abort', cancelled); client.child.removeListener('close', closed); };
+      const cleanup = () => { releaseTurnNotifications = unsubscribe; signal?.removeEventListener('abort', cancelled); client.child.removeListener('close', closed); };
       const finish = (error, value) => { if (settled) return; settled = true; cleanup(); if (error) reject(error); else resolve(value); };
       const cancelled = () => finish(new CodexAppServerError('cancelled', 'Codex turn was cancelled.'));
       const closed = () => finish(new CodexAppServerError('closed', 'Codex app-server closed before turn completion.'));
       const complete = () => {
         if (!completion || !turnId || !startRecorded || completion.turn?.id !== turnId) return;
         turnCompleted = true;
+        try { queueProviderTerminalReceipt({ root: dispatchOwner.root, attemptId: dispatchAttemptId, providerSession: targetSession,
+          providerExecutionId: turnId, status: completion.turn.status, response: messages.get(turnId) || '' }); }
+        catch (error) { terminalResolve(); return finish(error); }
+        terminalResolve();
+        if (settled) return;
         if (completion.turn.status !== 'completed') return finish(new CodexAppServerError('turn_failed', 'Codex turn did not complete.'));
         const message = messages.get(turnId);
         if (!message || Buffer.byteLength(message) > (run.managed.purpose?.enabled ? 128 : 16) * 1024) return finish(new CodexAppServerError('checkpoint', 'Codex did not return a bounded checkpoint.'));
@@ -887,6 +920,13 @@ export async function executeCodexAppServer(record, { webOrigin, openClient = op
         }
       };
       const unsubscribe = client.onNotification((method, params, requestId) => {
+        if (settled) {
+          if (requestId === undefined && params.threadId === targetSession) {
+            if (method === 'item/completed' && params.turnId === turnId && params.item?.type === 'agentMessage') messages.set(turnId, params.item.text);
+            if (method === 'turn/completed' && params.turn?.id === turnId) { completion = params; complete(); }
+          }
+          return;
+        }
         if (requestId !== undefined && params.threadId === targetSession && /requestApproval|requestPermissions/i.test(method)) return finish(Object.assign(new CodexAppServerError('provider_approval', 'Codex requires provider approval or user input.'), { providerTurnId: params.turnId || turnId }));
         if (requestId !== undefined && params.threadId === targetSession && /requestUserInput/i.test(method)) return finish(Object.assign(new CodexAppServerError(searchEnabled(run.managed) ? 'provider_question' : 'provider_approval', 'Provider asked a question; investigate before requesting a human decision.'), { providerTurnId: params.turnId || turnId, question: evidenceExcerpt(params.questions || [], 2000).text }));
         if (params.threadId !== targetSession) return;
@@ -905,7 +945,7 @@ export async function executeCodexAppServer(record, { webOrigin, openClient = op
       signal?.addEventListener('abort', cancelled, { once: true });
       client.child.once('close', closed);
       const targetProvenance = captureDispatchProvenance({ root: dispatchOwner.root, provider: record.provider, providerSession: targetSession, worktree: isolated ? executionCwd : record.cwd, taskId: run.managed.taskId || record.session, recordRef: recordPath(root || rootDirectory(), record.provider, record.session) });
-      turnStart = dispatchWithFence(dispatchOwner, { taskId: run.managed.taskId || record.session, attemptId: run.managed.resumeLease?.id, provenance: targetProvenance }, attemptId => { assertTaskAdmission(dispatchOwner, { taskId: provenance.taskId, provenance }); if (root && hasPendingUserStop(root, record)) throw new CodexAppServerError('cancelled', 'User stopped this provider task.'); dispatchAttemptId = attemptId; return client.request('turn/start', { threadId: targetSession, input: [{ type: 'text', text: `${prompt}\n${purposeInstruction}` }], cwd: isolated ? executionCwd : record.cwd,
+      turnStart = dispatchWithFence(dispatchOwner, { taskId: run.managed.taskId || record.session, attemptId: requestedAttemptId || run.managed.resumeLease?.id, provenance: targetProvenance }, attemptId => { assertTaskAdmission(dispatchOwner, { taskId: provenance.taskId, provenance }); if (root && hasPendingUserStop(root, record)) throw new CodexAppServerError('cancelled', 'User stopped this provider task.'); dispatchAttemptId = attemptId; return client.request('turn/start', { threadId: targetSession, input: [{ type: 'text', text: `${prompt}\n${purposeInstruction}` }], cwd: isolated ? executionCwd : record.cwd,
         model: run.managed.resumeModel, ...(isolated ? {sandboxPolicy} : {}) }); })
         .then(async response => { turnId = response?.turn?.id; activeTurnId = turnId; if (turnId) queueDispatchReceipt({ root: dispatchOwner.root, attemptId: dispatchAttemptId, receiptId: `provider:${dispatchAttemptId}:${turnId}`, providerExecutionId: turnId }); if (!turnId) finish(new CodexAppServerError('turn_failed', 'Codex did not start a turn.')); else {
           startReceipt = Promise.resolve().then(() => onStarted({ turnId, session: targetSession }));
@@ -991,6 +1031,11 @@ export async function executeCodexAppServer(record, { webOrigin, openClient = op
       if (turnStart && !activeTurnId) await Promise.race([turnStart, new Promise(resolve => setTimeout(resolve, 2_000))]).catch(() => {});
       if (!turnCompleted && activeTurnId) await client.request('turn/interrupt', { threadId: targetSession, turnId: activeTurnId }, 2_000).catch(() => {});
     }
+    if (activeTurnId && !turnCompleted && !client.closed) await new Promise(resolve => {
+      const timer = setTimeout(resolve, 2_000);
+      terminalObserved.then(() => { clearTimeout(timer); resolve(); });
+    });
+    releaseTurnNotifications?.();
     await client.close();
 
   }