throughline 0.16.31 → 0.16.33

package/src/claude-auto-handoff.mjs

@@ -43,6 +43,7 @@ import { sameProjectPath } from './project-path.mjs';
 import { runWithPty } from './os/pty-run.mjs';
 import { spawnPortable, spawnPortableSync } from './os/portable-spawn-sync.mjs';
 import { composeAutoHandoffTitle } from './auto-handoff-title.mjs';
+import { acquireClaudeWakeClaim, claudeForwardKind, claudeForwardWaiterAlive, enqueueClaudeForward, ensureClaudeForwardInbox, holdClaudeForward, logClaudeForward, readClaudeForwardStatus, removeStaleClaudeForwards } from './claude-forward.mjs';
 
 export const CLAUDE_AUTO_HANDOFF_SCHEMA = 'throughline.claude-auto-handoff.v2';
 const CLI_PATH = resolve(dirname(fileURLToPath(import.meta.url)), '../bin/throughline.mjs');
@@ -140,10 +141,13 @@ export function listClaudeAutoHandoffs({ dir = claudeAutoHandoffDir() } = {}) {
 }
 
 /** 外へ見せる項目だけ。依頼の本文・発言・道具の対象と、受け口は含めない。 */
-export function publicClaudeAutoHandoff(record) {
+export function publicClaudeAutoHandoff(record, { dir = claudeAutoHandoffDir() } = {}) {
   const { handoff_id, source_session_id, project_path, state, error_code, requested_at, updated_at, successor } = record;
+  // 後継の置き場の数（ADR 0063）。pending は届けるのを待つ入力、unknown は届いたか分からなくなった入力。
+  const forward = validSessionId(successor?.session_id) ? readClaudeForwardStatus(successor.session_id, { dir }) : null;
   return { handoff_id, source_session_id, project_path, state, error_code: error_code ?? null,
     successor_session_id: successor?.session_id ?? null, successor_short_id: successor?.short_id ?? null,
+    forward_pending: forward ? forward.pending : null, forward_unknown: forward ? forward.unknown : null,
     // 止めたターンを DB へ取り込めたか。false の時、後継は `throughline detail` でそのターンの入出力を取れない。
     in_flight_captured: Boolean(record.in_flight?.turn),
     // 後継を Claude Desktop で開く引き継ぎか、開けたか（null は対象外）。
@@ -219,6 +223,12 @@ function removeStale(dir, now) {
       rmSync(path, { force: true });
     }
   }
+  // 後継の置き場（ADR 0063）。後継として指されている会話の置き場は、空でも残す（待つ hook が、フォルダの有無で待つかを決める）。
+  try {
+    const keepSessionIds = new Set(listClaudeAutoHandoffs({ dir })
+      .map(record => record.successor?.session_id).filter(validSessionId));
+    removeStaleClaudeForwards({ dir, now, keepSessionIds });
+  } catch { /* 置き場の片付けの失敗で、引き継ぎを止めない */ }
 }
 
 /**
@@ -727,6 +737,204 @@ function handedOffReason(record, dir) {
     (sessionId ? `（一覧に無い時は claude --resume ${sessionId}）` : '');
 }
 
+/**
+ * 引き継ぎ済みの会話へ届いた入力を、後継の置き場へ置けた時に見せる文 (ADR 0063)。
+ * 後継で待つ hook が生きていれば、後継は動いている。生きていなければ、後継は止まっているか、待つ hook が登録される前に
+ * 立った会話で、入力は後継が次に動く時まで置き場で待つ。どちらかを、打った人へ返す。
+ */
+function openSuccessorCommand(record, dir) {
+  const { shortId, sessionId } = currentSuccessor(record, dir);
+  return `claude attach ${shortId}` + (sessionId ? `（一覧に無い時は claude --resume ${sessionId}）` : '');
+}
+
+function forwardedReason(record, dir, successorSessionId, { running = false, waking = false } = {}) {
+  const open = openSuccessorCommand(record, dir);
+  return `この会話はThroughlineが新しい会話へ引き継ぎ済みです（引き継ぎID: ${record.handoff_id}）。` +
+    '届いた入力は、後継の会話へ渡しました。' +
+    (waking
+      ? '後継は、先に届いた入力で起きている所です。起きた後継が、次の道具の前か番の終わりに読みます。' +
+        `後継のモデルが、運ばれた入力を利用者の依頼として扱わない事があります。答えは後継で確かめてください: ${open}`
+      : running || claudeForwardWaiterAlive(successorSessionId, dir)
+        ? '後継は動いています。手すきならすぐ、作業中なら次の道具の前か番の終わりに届きます。' +
+          `後継のモデルが、運ばれた入力を利用者の依頼として扱わない事があります。答えは後継で確かめてください: ${open}`
+        : `後継は今、入力を待ち受けていません（止まっているか、この版より前に立った会話です）。後継を開いて何か入力した時に届きます: ${open}`);
+}
+
+/** 止まっていた後継を起こして、入力を最初の入力として渡せた時に見せる文 (ADR 0064)。 */
+function wokenReason(record, dir) {
+  return `この会話はThroughlineが新しい会話へ引き継ぎ済みです（引き継ぎID: ${record.handoff_id}）。` +
+    '後継の会話が止まっていたので、Throughlineが起こして、この入力を後継の最初の入力として渡しました。' +
+    `後継は裏で作業を続けます: ${openSuccessorCommand(record, dir)}`;
+}
+
+/** 起こす命令を流したが、起きたか確かめられなかった時に見せる文 (ADR 0064)。入力は入れ直さない。 */
+function wakeUnknownReason(record, dir) {
+  return `この会話はThroughlineが新しい会話へ引き継ぎ済みです（引き継ぎID: ${record.handoff_id}）。` +
+    '後継の会話が止まっていたので起こそうとしましたが、起きて入力を受け取ったか確かめられませんでした。' +
+    `二重に届かないよう、この入力は入れ直していません。後継を開いて確かめてください: ${openSuccessorCommand(record, dir)}`;
+}
+
+// ---- 止まっている後継を、人が旧い会話へ打った文で起こす (ADR 0064) ----
+
+// 起こす命令で渡す文の上限（UTF-16 の長さ）。Windows の命令行は全体で 32,767 字まで。引用で増える分を見込む。
+export const CLAUDE_WAKE_TEXT_MAX_CHARS = 12_000;
+// 起こしてよい、裏の会話の state（一覧の項目に `pid` も `status` も無い時だけ）。手すきで止めた・片付けられた会話は
+// `done`、作業の途中で止めた会話は `stopped`。立ち上げ中の会話は `working` で、`pid` がまだ無い事がある。
+const STOPPED_BACKGROUND_STATES = new Set(['done', 'stopped']);
+// 後継の transcript がこれより新しく書かれていたら、動いていると見なして起こさない。
+const RECENTLY_WRITTEN_MS = 5_000;
+// 止まっていない会話へ起こす命令を流すと、Claude Code は写しを立てて、こう書く（2.1.296）。
+const WAKE_COPY_PATTERN = /started a copy as ([0-9a-f]{8})\b/;
+// 起こす仕組みを止める上書き（`off`）。
+const WAKE_OVERRIDE_ENV = 'THROUGHLINE_AUTO_HANDOFF_WAKE';
+
+// 起こす命令に渡さない、旧い会話の環境変数（hook は旧い会話の中で走る）。後継は、保存された自分の設定で起きる。
+const WAKE_STRIPPED_ENV = ['CLAUDE_CODE_SESSION_ID', 'CLAUDE_PID', 'CLAUDE_CODE_CHILD_SESSION', 'CLAUDE_CODE_SESSION_ATTENDED',
+  'CLAUDE_EFFORT', 'CLAUDE_CODE_EXECPATH'];
+
+function wakeCommandEnv(env) {
+  const next = successorEnv(env);
+  for (const key of WAKE_STRIPPED_ENV) delete next[key];
+  return next;
+}
+
+/** 起こす命令で渡せる文か。長すぎる文と、命令の引数に入らない文字（NUL）を含む文は渡さない。 */
+export function claudeWakeTextAllowed(text) {
+  return typeof text === 'string' && text.trim() !== '' && text.length <= CLAUDE_WAKE_TEXT_MAX_CHARS && !text.includes('\0');
+}
+
+/**
+ * `claude agents --json --all` で、その会話が止まっていると確かめられるか。
+ * 同じ会話 ID の項目が1つでも `pid` か `status` を持てば動いている（裏の会話を端末で開いた時と、`claude -p --resume` が
+ * 走っている時は、裏の項目とは別に `interactive` の項目が出る）。裏の項目が無い・一覧を読めない時は、確かめられない。
+ *
+ * @returns {{stopped: boolean, reason: string}}
+ */
+export function readClaudeSessionStopped(sessionId, { spawn = spawnPortableSync, env = process.env } = {}) {
+  const listed = spawn('claude', ['agents', '--json', '--all'], { env, encoding: 'utf8', timeout: 10_000, stdio: ['ignore', 'pipe', 'pipe'] });
+  if (listed.error || listed.status !== 0) return { stopped: false, reason: 'list_failed' };
+  let entries;
+  try { entries = JSON.parse(`${listed.stdout ?? ''}`); }
+  catch { return { stopped: false, reason: 'list_failed' }; }
+  if (!Array.isArray(entries)) return { stopped: false, reason: 'list_failed' };
+  const same = entries.filter(entry => entry?.sessionId === sessionId);
+  if (!same.length) return { stopped: false, reason: 'not_listed' };
+  if (same.some(entry => entry.pid || Object.hasOwn(entry, 'status'))) return { stopped: false, reason: 'running' };
+  const background = same.find(entry => entry.kind === 'background');
+  if (!background) return { stopped: false, reason: 'not_background' };
+  if (!STOPPED_BACKGROUND_STATES.has(background.state)) return { stopped: false, reason: 'not_stopped' };
+  return { stopped: true, reason: 'stopped' };
+}
+
+/** 後継の transcript の場所（旧い会話の transcript と同じ projects の下を探す）。見つからなければ null。 */
+function findSessionTranscript(record, sessionId) {
+  if (typeof record?.transcript_path !== 'string' || !validSessionId(sessionId)) return null;
+  const own = dirname(record.transcript_path);
+  const direct = join(own, `${sessionId}.jsonl`);
+  if (existsSync(direct)) return direct;
+  let folders;
+  try { folders = readdirSync(dirname(own), { withFileTypes: true }); }
+  catch { return null; }
+  for (const entry of folders) {
+    const path = entry.isDirectory() ? join(dirname(own), entry.name, `${sessionId}.jsonl`) : null;
+    if (path && existsSync(path)) return path;
+  }
+  return null;
+}
+
+/**
+ * 起こす命令を流す。option は付けない。裏の会話は、立てた時の option（モデル・effort・権限の mode・名前・リモート
+ * コントロール）を持っていて、option なしの時だけ、同じ会話のままそれで起きる。option を付けると、止まっている
+ * 会話でも写しが立つ。文は `--` の後に置く（頭が `-` の文を option として読ませない）。
+ *
+ * @returns {{outcome: 'woken'|'copy'|'failed'|'unknown', copyShortId?: string}}
+ */
+function runClaudeWake({ sessionId, text, cwd, env, spawn }) {
+  const result = spawn('claude', ['--bg', '--resume', sessionId, '--', text], {
+    cwd, env, encoding: 'utf8', timeout: 15_000, stdio: ['ignore', 'pipe', 'pipe'],
+  });
+  if (result.error) {
+    // 立ち上がる前の失敗（命令が無い・実行できない）は届いていない。時間切れは、命令が途中まで進んだかもしれない。
+    return { outcome: result.error.code === 'ETIMEDOUT' ? 'unknown' : 'failed' };
+  }
+  const out = normalizeTerminalText(`${result.stdout ?? ''}${result.stderr ?? ''}`);
+  const copy = WAKE_COPY_PATTERN.exec(out)?.[1];
+  if (copy) return { outcome: 'copy', copyShortId: copy };
+  const shortId = BACKGROUNDED_PATTERN.exec(out)?.[1];
+  if (result.status === 0 && shortId === sessionId.slice(0, 8)) return { outcome: 'woken' };
+  if (result.status === 0 && shortId) return { outcome: 'copy', copyShortId: shortId };
+  if (result.status !== 0 && !shortId) return { outcome: 'failed' };
+  return { outcome: 'unknown' };
+}
+
+/**
+ * 後継が止まっていて、人が旧い会話へ文を打った時に、後継を起こしてその文を最初の入力として渡す (ADR 0064)。
+ * 利用者の決め（K-9UHCLQ、2026-10-14）は「人が打った文の時だけ起こす。完了通知では起こさない」。
+ *
+ * 止まっていると確かめられない時は何もしない（`skipped`。入力は呼んだ側が置き場へ置く）。写しが立った時は、写しを
+ * 止めて一覧から消し、入力を置き場へ戻す（`queued`）。起こす命令が失敗した時も置き場へ戻す。起きたか分からない時は
+ * 入れ直さない（`unknown`）。
+ *
+ * @returns {{outcome: 'woken'|'queued'|'unknown'|'skipped', reason: string, running?: boolean, waking?: boolean}}
+ */
+export function wakeStoppedClaudeSuccessor({ record, successorSessionId, sourceSessionId, text, now = Date.now(),
+  dir = claudeAutoHandoffDir(), env = process.env, spawn = spawnPortableSync }) {
+  const skip = (reason, extra = {}) => {
+    logClaudeForward({ event: 'wake-skipped', reason, session_id: successorSessionId }, dir);
+    return { outcome: 'skipped', reason, ...extra };
+  };
+  if (`${env[WAKE_OVERRIDE_ENV] ?? ''}`.trim().toLowerCase() === 'off') return { outcome: 'skipped', reason: 'disabled' };
+  if (claudeForwardWaiterAlive(successorSessionId, dir)) return { outcome: 'skipped', reason: 'waiter_alive', running: true };
+  if (!claudeWakeTextAllowed(text)) return skip('text_not_allowed');
+  // Claude Desktop へ移した後継は、Desktop が開いている。裏で起こすと、同じ会話を2か所で動かす事になる。
+  if (record.desktop?.state === 'opened') return skip('desktop');
+  try {
+    if (resolveClaudeAutoHandoffSuccessor(successorSessionId, { dir }).pending) return skip('handoff_pending');
+  } catch { return skip('handoff_pending'); }
+  const transcript = findSessionTranscript(record, successorSessionId);
+  if (!transcript) return skip('transcript_missing'); // 無い会話 ID へ流すと、その ID で新しい会話が立つ
+  try {
+    if (Date.now() - statSync(transcript).mtimeMs < RECENTLY_WRITTEN_MS) return skip('recently_written', { running: true });
+  } catch { return skip('transcript_missing'); }
+  const release = acquireClaudeWakeClaim(successorSessionId, { dir, now });
+  if (!release) return skip('waking', { waking: true });
+  const wakeEnv = wakeCommandEnv(env);
+  const state = readClaudeSessionStopped(successorSessionId, { spawn, env: wakeEnv });
+  if (!state.stopped) {
+    release();
+    return skip(state.reason, { running: state.reason === 'running' });
+  }
+  const held = holdClaudeForward({ successorSessionId, sourceSessionId, handoffId: record.handoff_id, kind: 'prompt', text, now, dir });
+  if (!held) { release(); return skip('store_failed'); }
+  const cwd = typeof record.project_path === 'string' && existsSync(record.project_path) ? record.project_path : undefined;
+  const woke = runClaudeWake({ sessionId: successorSessionId, text, cwd, env: wakeEnv, spawn });
+  const base = { session_id: successorSessionId, source_session_id: sourceSessionId, chars: text.length };
+  if (woke.outcome === 'woken') {
+    held.settle();
+    logClaudeForward({ event: 'woken', ...base }, dir);
+    return { outcome: 'woken', reason: 'woken' }; // 番の印は残す（期限で切れる）
+  }
+  if (woke.outcome === 'copy') {
+    // 写しは、渡した文で動き出す。後継と同じ作業を2か所でしないよう、すぐ止めて一覧から消す。入力は置き場へ戻す
+    // （後継は動いているので、後継の hook が受け取る）。
+    for (const verb of ['stop', 'rm']) {
+      spawn('claude', [verb, woke.copyShortId], { env: wakeEnv, encoding: 'utf8', timeout: 10_000, stdio: ['ignore', 'pipe', 'pipe'] });
+    }
+    const queued = held.release();
+    release();
+    logClaudeForward({ event: 'wake-copy', ...base, copy_short_id: woke.copyShortId, queued }, dir);
+    return queued ? { outcome: 'queued', reason: 'copy', running: true } : { outcome: 'unknown', reason: 'copy' };
+  }
+  if (woke.outcome === 'failed') {
+    const queued = held.release();
+    release();
+    logClaudeForward({ event: 'wake-failed', ...base, queued }, dir);
+    return queued ? { outcome: 'queued', reason: 'failed' } : { outcome: 'unknown', reason: 'failed' };
+  }
+  logClaudeForward({ event: 'wake-unknown', ...base }, dir);
+  return { outcome: 'unknown', reason: 'unknown' };
+}
+
 function stopOutput(record, dir) {
   const reason = record.successor?.short_id
     ? handedOffReason(record, dir)
@@ -761,18 +969,39 @@ function recordClaudeRedirect(entry, dir) {
  * 何もしない（null）。Aiterm が起こした席の会話（ADR 0057）も止めない。席を外す前の版が引き継いだ席が残っていても、
  * 呼び手は席の番の終わりを待っている。止めると番が始まらず、呼び手は答えを受け取れない。
  *
- * @returns {{output: {decision: 'block', reason: string}, kind: 'prompt'|'task-notification', handoffId: string, successorShortId: string|null}|null}
+ * 止めた入力は、今の続きの会話の置き場へ置く (ADR 0063)。後継の hook が受け取って、モデルへ渡す。後継の会話 ID を
+ * 引けない時、置き場へ書けなかった時、入力が slash command の時は、置かずに「後継で打ち直す」文を返す。
+ *
+ * @returns {{output: {decision: 'block', reason: string}, kind: 'prompt'|'task-notification', handoffId: string, successorShortId: string|null, forwarded: boolean}|null}
  */
-export function redirectClaudeHandedOffPrompt({ payload, now = Date.now(), dir = claudeAutoHandoffDir(), env = process.env }) {
+export function redirectClaudeHandedOffPrompt({ payload, now = Date.now(), dir = claudeAutoHandoffDir(), env = process.env, spawn = spawnPortableSync }) {
   const sessionId = payload?.session_id;
   if (!validSessionId(sessionId) || payload.agent_id || isAitermSeatConversation(env, sessionId)) return null;
   const record = readClaudeAutoHandoff(sessionId, dir);
   if (!record || !successorRemains(record)) return null;
-  const successorShortId = currentSuccessor(record, dir).shortId;
+  const successor = currentSuccessor(record, dir);
+  const successorShortId = successor.shortId;
   const kind = typeof payload.prompt === 'string' && /^\s*<task-notification>/.test(payload.prompt) ? 'task-notification' : 'prompt';
+  const successorSessionId = successor.sessionId ?? findSuccessorSessionId(record);
+  // slash command は、その会話への命令なので運ばない。ほかの会話から届いた文は、利用者の入力と分けて運ぶ。
+  const forwardKind = claudeForwardKind(payload.prompt);
+  const canForward = forwardKind !== null && validSessionId(successorSessionId) && successorSessionId !== sessionId;
+  // 人が打った文で、後継が止まっていれば、後継を起こしてその文を渡す (ADR 0064)。完了通知とほかの会話からの文では起こさない。
+  const wake = canForward && forwardKind === 'prompt'
+    ? wakeStoppedClaudeSuccessor({ record, successorSessionId, sourceSessionId: sessionId, text: payload.prompt, now, dir, env, spawn })
+    : null;
+  const forwarded = canForward && (wake?.outcome === 'woken' || wake?.outcome === 'queued' ||
+    (wake?.outcome !== 'unknown' && enqueueClaudeForward({ successorSessionId, sourceSessionId: sessionId, handoffId: record.handoff_id,
+      kind: forwardKind, text: payload.prompt, now, dir })));
   recordClaudeRedirect({ at: new Date(now).toISOString(), source_session_id: sessionId, handoff_id: record.handoff_id,
-    successor_short_id: successorShortId, kind }, dir);
-  return { output: { decision: 'block', reason: handedOffReason(record, dir) }, kind, handoffId: record.handoff_id, successorShortId };
+    successor_short_id: successorShortId, kind, forwarded,
+    ...(wake && wake.reason !== 'disabled' ? { wake: wake.outcome === 'skipped' ? `skipped:${wake.reason}` : wake.outcome } : {}) }, dir);
+  const reason = wake?.outcome === 'woken' ? wokenReason(record, dir)
+    : wake?.outcome === 'unknown' ? wakeUnknownReason(record, dir)
+      : forwarded ? forwardedReason(record, dir, successorSessionId, { running: Boolean(wake?.running), waking: Boolean(wake?.waking) })
+        : handedOffReason(record, dir);
+  return { output: { decision: 'block', reason }, kind, handoffId: record.handoff_id, successorShortId, forwarded,
+    ...(wake ? { wake: wake.outcome } : {}) };
 }
 
 /**
@@ -893,6 +1122,8 @@ export function acceptClaudeAutoContinuation({ predecessorId, successorSessionId
   if (carriesInstruction && !record.accepted_at && !existsSync(acceptancePath(predecessorId, dir))) {
     writeJsonPrivate(acceptancePath(predecessorId, dir),
       { handoff_id: record.handoff_id, successor_session_id: successorSessionId, accepted_at: now });
+    // 後継の置き場を作る（ADR 0063）。番の終わりの待つ hook は、このフォルダが在る会話でだけ待つ。
+    if (validSessionId(successorSessionId)) ensureClaudeForwardInbox(successorSessionId, dir);
   }
   return { handoffId: record.handoff_id, projectPath: record.project_path, inFlight: record.in_flight ?? null,
     transcriptPath: record.transcript_path ?? null };

package/src/claude-auto-handoff.test.mjs

@@ -1230,15 +1230,16 @@ function fakeClaudePath(home) {
   return { [pathKey]: `${bin}${delimiter}${process.env[pathKey] ?? ''}` };
 }
 
-test('公開CLI: enable は2つの hook と設定を書き、disable は自分の hook だけを外す。Codex の設定には触らない', () => withDir(home => {
+test('公開CLI: enable は3つの hook と設定を書き、disable は自分の hook だけを外す。Codex の設定には触らない', () => withDir(home => {
   const settingsPath = join(home, '.claude', 'settings.json');
   mkdirSync(dirname(settingsPath), { recursive: true });
   // 他製品の hook と、0.13.0 が置いた PreCompact がある状態から始める
   const others = { PreCompact: [{ hooks: [{ type: 'command', command: 'other-product pre-compact' }] }],
-    PreToolUse: [{ matcher: 'Bash', hooks: [{ type: 'command', command: 'rtk hook claude' }] }] };
+    PreToolUse: [{ matcher: 'Bash', hooks: [{ type: 'command', command: 'rtk hook claude' }] }],
+    Stop: [{ hooks: [{ type: 'command', command: 'throughline process-turn', async: true }] }] };
   writeFileSync(settingsPath, JSON.stringify({ model: 'sonnet', hooks: {
     PreCompact: [{ hooks: [{ type: 'command', command: 'throughline pre-compact' }] }, ...others.PreCompact],
-    PreToolUse: others.PreToolUse } }));
+    PreToolUse: others.PreToolUse, Stop: others.Stop } }));
 
   const before = JSON.parse(cli(home, ['auto-handoff', 'status', '--host', 'claude', '--json']).stdout);
   assert.deepEqual(before, { host: 'claude', config: { schema: 'throughline.claude-auto-handoff.v1', enabled: false, projects: [] },
@@ -1250,22 +1251,35 @@ test('公開CLI: enable は2つの hook と設定を書き、disable は自分
   assert.equal(JSON.parse(enabled.stdout).status, 'enabled');
   const settings = JSON.parse(readFileSync(settingsPath, 'utf8'));
   assert.equal(settings.model, 'sonnet');
+  // 今の形で登録済みの PreCompact は、並びを動かさない。足りない hook だけを後ろへ足す（ADR 0063）
+  const forwardWait = { hooks: [{ type: 'command', command: 'throughline claude-forward-wait', asyncRewake: true, timeout: 86400 }] };
   assert.deepEqual(settings.hooks, {
-    PreCompact: [...others.PreCompact, { hooks: [{ type: 'command', command: 'throughline pre-compact' }] }],
+    PreCompact: [{ hooks: [{ type: 'command', command: 'throughline pre-compact' }] }, ...others.PreCompact],
     PreToolUse: [...others.PreToolUse, { hooks: [{ type: 'command', command: 'throughline pre-tool-use', timeout: 15 }] }],
+    Stop: [...others.Stop, forwardWait],
   });
   const again = cli(home, ['auto-handoff', 'enable', '--host', 'claude', '--json']);
   assert.equal(again.status, 0, again.stderr);
   assert.equal(readFileSync(settingsPath, 'utf8'), JSON.stringify(settings, null, 2) + '\n', '2回目は書き換えない');
 
   assert.equal(cli(home, ['auto-handoff', 'status', '--host', 'claude']).stdout,
-    '自動継続: 有効（Claude Code）\nhook（PreCompact・PreToolUse）: 登録済み\n');
+    '自動継続: 有効（Claude Code）\nhook（PreCompact・PreToolUse・Stop）: 登録済み\n');
   assert.equal(existsSync(join(home, '.throughline', 'codex-auto-handoff.json')), false);
   assert.equal(JSON.parse(cli(home, ['auto-handoff', 'status', '--json']).stdout).config.enabled, false, 'Codex は無効のまま');
 
+  // 前の版が登録した2つだけの端末（自分の hook の後ろに他製品の hook がある）で、版を上げた時の install の形:
+  // 前からある2つの並びは動かさず、Stop の待つ hook だけを足す
+  const later = { hooks: [{ type: 'command', command: 'later-product pre-tool-use' }] };
+  writeFileSync(settingsPath, JSON.stringify({ ...settings, hooks: { ...settings.hooks,
+    PreToolUse: [...settings.hooks.PreToolUse, later], Stop: others.Stop } }, null, 2) + '\n');
+  assert.equal(JSON.parse(cli(home, ['auto-handoff', 'status', '--host', 'claude', '--json']).stdout).hooks.registered, false);
+  assert.equal(cli(home, ['auto-handoff', 'enable', '--host', 'claude', '--json']).status, 0);
+  assert.deepEqual(JSON.parse(readFileSync(settingsPath, 'utf8')).hooks, { ...settings.hooks,
+    PreToolUse: [...settings.hooks.PreToolUse, later], Stop: [...others.Stop, forwardWait] });
+
   const disabled = JSON.parse(cli(home, ['auto-handoff', 'disable', '--host', 'claude', '--json']).stdout);
   assert.equal(disabled.config.enabled, false);
-  assert.deepEqual(JSON.parse(readFileSync(settingsPath, 'utf8')).hooks, others);
+  assert.deepEqual(JSON.parse(readFileSync(settingsPath, 'utf8')).hooks, { ...others, PreToolUse: [...others.PreToolUse, later] });
   const unsupported = cli(home, ['auto-handoff', 'resume', '--host', 'claude', '--operation', 'x', '--json']);
   assert.equal(unsupported.status, 1);
   assert.deepEqual(JSON.parse(unsupported.stdout), { status: 'failed', code: 'auto_handoff_action_unsupported' });
@@ -1597,7 +1611,9 @@ test('引き継ぎ済みの会話へ届いた入力: 後継が残っている時
   const record = (id, fields) => writeFileSync(join(dir, `${id}.json`), JSON.stringify({ schema: 'throughline.claude-auto-handoff.v2',
     handoff_id: `h-${id.slice(0, 8)}`, source_session_id: id, project_path: '/work/app', transcript_path: join(projects, `${id}.jsonl`),
     requested_at: 1_000, updated_at: 2_000, error_code: null, ...fields }));
-  const submit = (id, prompt, extra = {}, env = {}) => redirectClaudeHandedOffPrompt({ payload: { session_id: id, prompt, ...extra }, now: 5_000, dir, env });
+  const noClaude = () => ({ error: Object.assign(new Error('spawn claude ENOENT'), { code: 'ENOENT' }) });
+  const submit = (id, prompt, extra = {}, env = {}) => redirectClaudeHandedOffPrompt({ payload: { session_id: id, prompt, ...extra }, now: 5_000, dir, env, spawn: noClaude });
+  const settled = path => { const past = new Date(Date.now() - 60_000); utimesSync(path, past, past); };
   const redirects = () => existsSync(join(dir, 'redirects.jsonl'))
     ? readFileSync(join(dir, 'redirects.jsonl'), 'utf8').trim().split('\n').map(line => JSON.parse(line)) : [];
 
@@ -1611,24 +1627,28 @@ test('引き継ぎ済みの会話へ届いた入力: 後継が残っている時
   assert.deepEqual(redirects(), []);
 
   writeFileSync(join(projects, `${b}.jsonl`), '');
+  settled(join(projects, `${b}.jsonl`));
   const human = submit(a, '旧い会話へ打った文');
   assert.deepEqual(human, { output: { decision: 'block',
-    reason: 'この会話はThroughlineが新しい会話へ引き継ぎ済みです（引き継ぎID: h-aaaaaaaa）。続きは後継の会話で行ってください: claude attach bbbbbbbb（一覧に無い時は claude --resume ' + b + '）' },
-    kind: 'prompt', handoffId: 'h-aaaaaaaa', successorShortId: 'bbbbbbbb' });
+    reason: 'この会話はThroughlineが新しい会話へ引き継ぎ済みです（引き継ぎID: h-aaaaaaaa）。届いた入力は、後継の会話へ渡しました。' +
+      '後継は今、入力を待ち受けていません（止まっているか、この版より前に立った会話です）。後継を開いて何か入力した時に届きます: ' +
+      'claude attach bbbbbbbb（一覧に無い時は claude --resume ' + b + '）' },
+    kind: 'prompt', handoffId: 'h-aaaaaaaa', successorShortId: 'bbbbbbbb', forwarded: true, wake: 'skipped' });
   assert.equal(submit(a, '<task-notification>\n<task-id>b1</task-id>\n<status>completed</status>\n</task-notification>').kind, 'task-notification');
   assert.equal(submit(a, '依頼', { agent_id: 'agent-1' }), null, 'subagent の中の入力');
   assert.equal(submit('../escape', '依頼'), null);
   assert.equal(submit(a, '依頼', {}, { AITERM_AGENT_LAUNCH_ID: 'abc', AITERM_AGENT_VENDOR_SESSION_ID: a }), null, 'Aiterm の席の会話は止めない');
   assert.equal(submit(a, '依頼', {}, { AITERM_AGENT_LAUNCH_ID: 'abc', AITERM_AGENT_VENDOR_SESSION_ID: b }).kind, 'prompt', '席の印だけを継いだ会話は止める');
   assert.deepEqual(redirects(), [
-    { at: '1970-01-01T00:00:05.000Z', source_session_id: a, handoff_id: 'h-aaaaaaaa', successor_short_id: 'bbbbbbbb', kind: 'prompt' },
-    { at: '1970-01-01T00:00:05.000Z', source_session_id: a, handoff_id: 'h-aaaaaaaa', successor_short_id: 'bbbbbbbb', kind: 'task-notification' },
-    { at: '1970-01-01T00:00:05.000Z', source_session_id: a, handoff_id: 'h-aaaaaaaa', successor_short_id: 'bbbbbbbb', kind: 'prompt' },
+    { at: '1970-01-01T00:00:05.000Z', source_session_id: a, handoff_id: 'h-aaaaaaaa', successor_short_id: 'bbbbbbbb', kind: 'prompt', forwarded: true, wake: 'skipped:list_failed' },
+    { at: '1970-01-01T00:00:05.000Z', source_session_id: a, handoff_id: 'h-aaaaaaaa', successor_short_id: 'bbbbbbbb', kind: 'task-notification', forwarded: true },
+    { at: '1970-01-01T00:00:05.000Z', source_session_id: a, handoff_id: 'h-aaaaaaaa', successor_short_id: 'bbbbbbbb', kind: 'prompt', forwarded: true, wake: 'skipped:list_failed' },
   ], '止めた記録に入力の本文は書かない');
 
   // 後継がさらに引き継がれている時は、その先を示す。道具を断る時の文も同じ
   record(b, { state: 'unknown', successor: { short_id: 'cccccccc', session_id: null } });
   writeFileSync(join(projects, `${c}.jsonl`), '');
+  settled(join(projects, `${c}.jsonl`));
   assert.match(submit(a, '依頼').output.reason, /claude attach cccccccc（一覧に無い時は claude --resume cccccccc-0000-4000-8000-000000000033）$/);
   assert.match(submit(b, '依頼').output.reason, /引き継ぎID: h-bbbbbbbb.*claude attach cccccccc（一覧に無い時は claude --resume cccccccc-0000-4000-8000-000000000033）$/);
   const denied = await stopClaudeTurnForHandoff({ payload: { session_id: a, cwd: '/work/app' }, dir,
@@ -1643,6 +1663,7 @@ test('公開CLI: prompt-submit は、引き継ぎ済みの会話の入力を止
   const projects = join(home, '.claude', 'projects', '-work-app');
   mkdirSync(dir, { recursive: true }); mkdirSync(projects, { recursive: true });
   writeFileSync(join(projects, `${SUCCESSOR}.jsonl`), '');
+  utimesSync(join(projects, `${SUCCESSOR}.jsonl`), new Date(Date.now() - 60_000), new Date(Date.now() - 60_000));
   writeFileSync(join(dir, `${SESSION}.json`), JSON.stringify({ schema: 'throughline.claude-auto-handoff.v2', handoff_id: 'h-1',
     source_session_id: SESSION, project_path: '/work/app', transcript_path: join(projects, `${SESSION}.jsonl`), state: 'sent',
     requested_at: 1_000, updated_at: 2_000, error_code: null, successor: { short_id: SUCCESSOR.slice(0, 8), session_id: SUCCESSOR } }));
@@ -1652,16 +1673,22 @@ test('公開CLI: prompt-submit は、引き継ぎ済みの会話の入力を止
   const blocked = submit(SESSION, '旧い会話へ打った文');
   assert.equal(blocked.status, 0, blocked.stderr);
   assert.deepEqual(JSON.parse(blocked.stdout), { decision: 'block',
-    reason: `この会話はThroughlineが新しい会話へ引き継ぎ済みです（引き継ぎID: h-1）。続きは後継の会話で行ってください: claude attach ${SUCCESSOR.slice(0, 8)}（一覧に無い時は claude --resume ${SUCCESSOR}）` });
+    reason: 'この会話はThroughlineが新しい会話へ引き継ぎ済みです（引き継ぎID: h-1）。届いた入力は、後継の会話へ渡しました。' +
+      '後継は今、入力を待ち受けていません（止まっているか、この版より前に立った会話です）。後継を開いて何か入力した時に届きます: ' +
+      `claude attach ${SUCCESSOR.slice(0, 8)}（一覧に無い時は claude --resume ${SUCCESSOR}）` });
   assert.equal(existsSync(join(home, '.throughline', 'throughline.db')), false, '止める時は DB を開かない');
   const logged = readFileSync(join(home, '.throughline', 'logs', 'inheritance-decision.log'), 'utf8').trim().split('\n').map(line => JSON.parse(line));
   assert.deepEqual(logged.map(row => [row.phase, row.session_id, row.handoff_id, row.successor_short_id, row.input_kind]),
     [['prompt-redirect', SESSION, 'h-1', SUCCESSOR.slice(0, 8), 'prompt']]);
   assert.equal(JSON.stringify(logged).includes('旧い会話へ打った文'), false, '判定の記録に本文は書かない');
 
+  // 止めた入力は後継の置き場で待ち、後継の次の入力で文脈として届く（ADR 0063）。届けた後は残らない
   const passed = submit(SUCCESSOR, '後継へ打った文');
   assert.equal(passed.status, 0, passed.stderr);
-  assert.equal(passed.stdout, '', '記録が無い会話の入力は、今までどおり通す');
+  assert.match(passed.stdout, /^【Throughline 転送】引き継ぎ前の会話（0f3a6c1e）へ届いた入力を、Throughlineがこの会話へ運びました（利用者の入力 1 通）。/);
+  assert.match(passed.stdout, /\n--- 利用者の入力（[^）]*利用者がこの会話へ打った入力として扱ってください）---\n旧い会話へ打った文\n$/);
+  assert.equal(submit(SUCCESSOR, '後継へ打った次の文').stdout, '', '同じ入力を2回は届けない');
+  assert.equal(submit('eeeeeeee-0000-4000-8000-000000000099', '関係の無い会話').stdout, '', '置き場が無い会話の入力は、今までどおり通す');
 }));
 
 test('裏で動いている作業: 起こした道具から、終わった通知が届いた物を除く（user 行でも、途中の入力でも）', () => withDir(dir => {

package/src/claude-forward-wait.mjs

@@ -0,0 +1,145 @@
+#!/usr/bin/env node
+/**
+ * Stop hook（`asyncRewake: true`）— 引き継ぎ前の会話へ届いた入力を、手すきの後継へ届ける (ADR 0063)
+ *
+ * stdin: { session_id, hook_event_name: "Stop", stop_hook_active, ... }
+ *
+ * `auto-handoff enable --host claude` が登録する。番の終わりのたびに走るので、自分の置き場のフォルダが無い会話
+ * （後継でない会話。ほとんどの会話）では、フォルダの有無だけを見て終わる。
+ *
+ * 置き場のフォルダが在る会話では、入力が届くまで待つ。届いたら stderr へ出して exit code 2 で終わる。Claude Code は、
+ * `asyncRewake` の hook が exit code 2 で終わると、stderr の文を持たせて会話を起こす。
+ *
+ * script から起動した Claude（`claude -p`、Agent SDK）では待たない。待つと、呼び出し元の命令が返らない。
+ *
+ * 待っている hook は、会話が次の番へ進んでも Claude Code に止められない（実測）。次の番の終わりに立つ新しい hook が
+ * 置き場に印を書き、前の hook はそれを見て退く。待っている間に次の番が始まって入力が届いた時は、前の hook が出した文を
+ * Claude Code が順番待ちへ入れ、次の道具の合間に届ける（実測）。
+ */
+
+import { existsSync } from 'node:fs';
+import { homedir } from 'node:os';
+import { join } from 'node:path';
+import { pathToFileURL } from 'node:url';
+import { setTimeout as delay } from 'node:timers/promises';
+
+// claude-forward.mjs と同じ置き場と形。速い道を保つために、ここでは import しない。
+const SESSION_ID_PATTERN = /^[A-Za-z0-9_-]{1,128}$/;
+/** 登録する hook の timeout（秒）。install.mjs の値と合わせる。自分からは、その少し手前で終わる。 */
+export const CLAUDE_FORWARD_WAIT_TIMEOUT_SECONDS = 86_400;
+const POLL_MS = 1000;
+
+/**
+ * 待つ本体。試験から呼べる様に、終わり方を値で返す（process は終わらせない）。
+ *
+ * @returns {Promise<{code: 0|2, reason: string, text?: string, count?: number}>}
+ */
+export async function waitForClaudeForwards({
+  sessionId,
+  dir = join(homedir(), '.throughline', 'claude-auto-handoff'),
+  maxWaitMs = (CLAUDE_FORWARD_WAIT_TIMEOUT_SECONDS - 300) * 1000,
+  pollMs = POLL_MS,
+  isOrphaned = () => process.platform !== 'win32' && process.ppid === 1,
+  sleep = delay,
+  now = () => Date.now(),
+  token = `${process.pid}-${Date.now()}-${Math.random().toString(36).slice(2, 10)}`,
+}) {
+  const forward = await import('./claude-forward.mjs');
+  const startedAt = now();
+  // 前の番の終わりから待っている hook は、Claude Code が止めない。自分の印を書いて、前の hook を退かせる。
+  const registered = forward.registerClaudeForwardWaiter(sessionId, token, dir);
+  const end = (code, reason, extra = {}) => {
+    forward.logClaudeForward({ event: 'wait-end', session_id: sessionId, reason,
+      waited_s: Math.round((now() - startedAt) / 1000), ...(extra.count ? { count: extra.count } : {}) }, dir);
+    return { code, reason, ...extra };
+  };
+  for (;;) {
+    // 同じ会話で新しい待つ hook が立ったら、退く（待つのは1つだけ）。
+    if (registered && forward.currentClaudeForwardWaiter(sessionId, dir) !== token) return end(0, 'superseded');
+    // 自分の会話がさらに引き継がれて後継が立ったら、残った入力を今の続きの会話へ移して終わる。旧い会話は起こさない。
+    if (existsSync(join(dir, `${sessionId}.json`))) {
+      const { resolveClaudeAutoHandoffSuccessor } = await import('./claude-auto-handoff.mjs');
+      let current = null;
+      try {
+        const resolved = resolveClaudeAutoHandoffSuccessor(sessionId, { dir });
+        if (resolved.handed_off && resolved.current_session_id !== sessionId) current = resolved.current_session_id;
+      } catch { /* 記録を読めない時は、自分の会話で受け取る */ }
+      if (current) {
+        const moved = forward.moveClaudeForwards({ fromSessionId: sessionId, toSessionId: current, dir });
+        return end(0, 'handed-off', { count: moved });
+      }
+    }
+    if (forward.hasPendingClaudeForwards(sessionId, dir)) {
+      const claim = forward.claimClaudeForwards({ sessionId, dir });
+      if (claim) {
+        return { ...end(2, 'delivered', { count: claim.count }), text: claim.text, claim };
+      }
+    }
+    if (isOrphaned()) return end(0, 'orphaned');
+    if (now() - startedAt >= maxWaitMs) return end(0, 'deadline');
+    await sleep(pollMs);
+  }
+}
+
+export async function run() {
+  let raw = '';
+  await new Promise((resolve) => {
+    process.stdin.setEncoding('utf8');
+    process.stdin.on('data', (chunk) => {
+      raw += chunk;
+    });
+    process.stdin.on('end', resolve);
+  });
+
+  const payload = JSON.parse(raw.replace(/^/, ''));
+  const sessionId = payload?.session_id;
+  const dir = join(homedir(), '.throughline', 'claude-auto-handoff');
+  if (typeof sessionId !== 'string' || !SESSION_ID_PATTERN.test(sessionId) || payload.agent_id ||
+      !existsSync(join(dir, 'inbox', sessionId))) {
+    process.exit(0);
+  }
+  const entrypoint = process.env.CLAUDE_CODE_ENTRYPOINT;
+  if (typeof entrypoint === 'string' && entrypoint.startsWith('sdk-')) process.exit(0);
+
+  const forward = await import('./claude-forward.mjs');
+  const startedAt = Date.now();
+  // 期限や `claude stop` で止められた時の跡（POSIX だけ。Windows は跡を残せずに止まる）。
+  process.on('SIGTERM', () => {
+    forward.logClaudeForward({ event: 'wait-end', session_id: sessionId, reason: 'sigterm',
+      waited_s: Math.round((Date.now() - startedAt) / 1000) }, dir);
+    process.exit(143);
+  });
+  forward.logClaudeForward({ event: 'wait-start', session_id: sessionId }, dir);
+  // 会話の process が居なくなったら終わる。居ない会話へ出力すると、入力が届かないまま消える。
+  const claudePid = Number(process.env.CLAUDE_PID);
+  const claudeGone = () => {
+    if (!Number.isSafeInteger(claudePid) || claudePid <= 0) return false;
+    try { process.kill(claudePid, 0); return false; }
+    catch (error) { return error.code === 'ESRCH'; }
+  };
+  const result = await waitForClaudeForwards({ sessionId, dir,
+    isOrphaned: () => claudeGone() || (process.platform !== 'win32' && process.ppid === 1) });
+  if (result.code !== 2) process.exit(0);
+  // 出力を書き切ってから、受け取った入力を消して終わる。
+  process.stderr.write(result.text, () => {
+    forward.settleClaudeForwards(result.claim);
+    forward.logClaudeForward({ event: 'delivered', via: 'stop', session_id: sessionId, count: result.claim.count,
+      humans: result.claim.humans, notifications: result.claim.notifications, chars: result.claim.chars }, dir);
+    process.exit(2);
+  });
+}
+
+async function reportFailure(err) {
+  const { recordRuntimeErrorBestEffort } = await import('./runtime-error-store.mjs');
+  const { logHookFailure } = await import('./hook-failure-log.mjs');
+  recordRuntimeErrorBestEffort('HOOK_CLAUDE_FORWARD_WAIT_FAILED');
+  logHookFailure('HOOK_CLAUDE_FORWARD_WAIT_FAILED', err);
+}
+
+if (process.argv[1] && import.meta.url === pathToFileURL(process.argv[1]).href) {
+  run().catch(async (err) => {
+    await reportFailure(err);
+    process.stderr.write(`[claude-forward-wait] error: ${err.message}\n`);
+    process.exit(1);
+  });
+}