throughline 0.16.30 → 0.16.32

package/src/claude-auto-handoff.mjs

@@ -21,7 +21,7 @@
  * 状態は ~/.throughline/claude-auto-handoff/ のファイルに持つ（schema は変えない）。
  */
 
-import { closeSync, existsSync, fstatSync, mkdirSync, openSync, readFileSync, readSync, readdirSync, renameSync, rmSync, statSync, writeFileSync } from 'node:fs';
+import { appendFileSync, closeSync, existsSync, fstatSync, mkdirSync, openSync, readFileSync, readSync, readdirSync, renameSync, rmSync, statSync, writeFileSync } from 'node:fs';
 import { homedir } from 'node:os';
 import { dirname, join, posix, resolve, win32 } from 'node:path';
 import { randomUUID } from 'node:crypto';
@@ -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 { claudeForwardKind, claudeForwardWaiterAlive, enqueueClaudeForward, ensureClaudeForwardInbox, 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 { /* 置き場の片付けの失敗で、引き継ぎを止めない */ }
 }
 
 /**
@@ -575,6 +585,60 @@ function readInFlightSteps(transcriptPath, stoppedToolUseId, projectPath) {
   };
 }
 
+const BACKGROUND_TASKS_KEPT = 10;
+const TASK_NOTIFICATION_HEAD = /^\s*<task-notification>/;
+const BACKGROUND_OUTPUT_FILE = /Output is being written to: (.+?)(?:\. |\.$|$)/m;
+
+/**
+ * 会話が裏で起こして、終わった通知がまだ来ていない作業（新しい順）(ADR 0062)。
+ *
+ * 裏で起こした道具は、結果の行に host が `toolUseResult.backgroundTaskId` を書く。終わると、完了通知
+ * （`<task-notification>` に `<task-id>` と `<status>`）が、user 行か、ターンの途中なら `queued_command` で届く。
+ * 引き継いだ後は、その通知が旧い会話へ届く。後継は、出力のファイルを読めば結果を確かめられる。
+ *
+ * @returns {{tasks: Array<{task_id: string, name: string, target: string, output_file: string|null}>, total: number}}
+ */
+export function readRunningBackgroundTasks(transcriptPath, projectPath = null) {
+  const toolById = new Map();
+  const started = new Map();
+  const finished = new Set();
+  const noteFinished = (text) => {
+    if (typeof text !== 'string' || !TASK_NOTIFICATION_HEAD.test(text) || !/<status>[^<]+<\/status>/.test(text)) return;
+    const id = /<task-id>([^<]+)<\/task-id>/.exec(text)?.[1];
+    if (id) finished.add(id.trim());
+  };
+  for (const entry of readRawEntries(transcriptPath)) {
+    if (entry?.isSidechain === true) continue;
+    if (entry?.type === 'attachment') {
+      if (entry.attachment?.type === 'queued_command') noteFinished(entry.attachment.prompt);
+      continue;
+    }
+    const content = entry?.message?.content;
+    if (entry?.type === 'assistant' && Array.isArray(content)) {
+      for (const block of content) {
+        if (block?.type === 'tool_use' && typeof block.id === 'string') {
+          toolById.set(block.id, { name: block.name ?? 'unknown', target: toolTarget(block.input, projectPath) });
+        }
+      }
+    } else if (entry?.type === 'user') {
+      if (typeof content === 'string') { noteFinished(content); continue; }
+      if (!Array.isArray(content)) continue;
+      const taskId = entry.toolUseResult?.backgroundTaskId;
+      for (const block of content) {
+        if (block?.type === 'text') noteFinished(block.text);
+        if (block?.type !== 'tool_result' || typeof taskId !== 'string' || !taskId) continue;
+        const text = typeof block.content === 'string' ? block.content
+          : Array.isArray(block.content) ? block.content.map(part => (typeof part?.text === 'string' ? part.text : '')).join('') : '';
+        const tool = toolById.get(block.tool_use_id) ?? { name: 'unknown', target: '' };
+        started.set(taskId, { task_id: taskId, name: tool.name, target: tool.target,
+          output_file: BACKGROUND_OUTPUT_FILE.exec(text)?.[1]?.trim() || null });
+      }
+    }
+  }
+  const running = [...started.values()].filter(task => !finished.has(task.task_id)).reverse();
+  return { tasks: running.slice(0, BACKGROUND_TASKS_KEPT), total: running.length };
+}
+
 /**
  * 止めた時点の作業途中のターン。後継の会話が止められた時は、最後の user 発言が前の引き継ぎの
  * 継続の指示になっている。その時は、前の引き継ぎが運んだ元の依頼を引き続き運ぶ。
@@ -592,6 +656,7 @@ function snapshotInFlight(record, dir) {
     user: carried ?? { content: latest.user.content, timestamp: latest.user.timestamp },
     last_fragment: lastFragment ? { content: lastFragment.content, timestamp: lastFragment.timestamp } : null,
     ...readInFlightSteps(record.transcript_path, record.stopped_tool_use_id, record.project_path),
+    background: readRunningBackgroundTasks(record.transcript_path, record.project_path),
     turn: null,
   };
 }
@@ -644,9 +709,53 @@ function withdrawRecord(sessionId, dir) {
   rmSync(join(dir, `${sessionId}.claim`), { force: true });
 }
 
-function stopOutput(record) {
+/**
+ * 引き継ぎ済みの会話から見た、今の続きの会話。後継がさらに引き継がれていれば、その先を返す。
+ * たどれない時は、記録にある直接の後継。
+ *
+ * @returns {{shortId: string|null, sessionId: string|null}}
+ */
+function currentSuccessor(record, dir) {
+  try {
+    const resolved = resolveClaudeAutoHandoffSuccessor(record.source_session_id, { dir });
+    if (resolved.handed_off && resolved.current_session_id !== record.source_session_id) {
+      return { shortId: resolved.current_session_id.slice(0, 8), sessionId: resolved.current_session_id };
+    }
+  } catch { /* 記録を読めない時は、直接の後継を示す */ }
+  return { shortId: record.successor?.short_id ?? null,
+    sessionId: validSessionId(record.successor?.session_id) ? record.successor.session_id : null };
+}
+
+/**
+ * 引き継ぎ済みの会話で、道具を断る時と入力を止める時に見せる文。
+ * `claude rm` で一覧から消した後継は `claude attach` では開けない（記録は残る）。その時に開ける命令も添える。
+ */
+function handedOffReason(record, dir) {
+  const { shortId, sessionId } = currentSuccessor(record, dir);
+  return `この会話はThroughlineが新しい会話へ引き継ぎ済みです（引き継ぎID: ${record.handoff_id}）。` +
+    `続きは後継の会話で行ってください: claude attach ${shortId}` +
+    (sessionId ? `（一覧に無い時は claude --resume ${sessionId}）` : '');
+}
+
+/**
+ * 引き継ぎ済みの会話へ届いた入力を、後継の置き場へ置けた時に見せる文 (ADR 0063)。
+ * 後継で待つ hook が生きていれば、後継は動いている。生きていなければ、後継は止まっているか、待つ hook が登録される前に
+ * 立った会話で、入力は後継が次に動く時まで置き場で待つ。どちらかを、打った人へ返す。
+ */
+function forwardedReason(record, dir, successorSessionId) {
+  const { shortId, sessionId } = currentSuccessor(record, dir);
+  const open = `claude attach ${shortId}` + (sessionId ? `（一覧に無い時は claude --resume ${sessionId}）` : '');
+  return `この会話はThroughlineが新しい会話へ引き継ぎ済みです（引き継ぎID: ${record.handoff_id}）。` +
+    '届いた入力は、後継の会話へ渡しました。' +
+    (claudeForwardWaiterAlive(successorSessionId, dir)
+      ? '後継は動いています。手すきならすぐ、作業中なら次の道具の前か番の終わりに届きます。' +
+        `後継のモデルが、運ばれた入力を利用者の依頼として扱わない事があります。答えは後継で確かめてください: ${open}`
+      : `後継は今、入力を待ち受けていません（止まっているか、この版より前に立った会話です）。後継を開いて何か入力した時に届きます: ${open}`);
+}
+
+function stopOutput(record, dir) {
   const reason = record.successor?.short_id
-    ? `この会話はThroughlineが新しい会話へ引き継ぎ済みです（引き継ぎID: ${record.handoff_id}）。続きは後継の会話で行ってください: claude attach ${record.successor.short_id}`
+    ? handedOffReason(record, dir)
     : `Throughlineが、自動圧縮の代わりに新しい会話へ引き継ぎます（引き継ぎID: ${record.handoff_id}）。` +
       (record.desktop?.wanted
         ? '後継の会話は裏で作業を続け、そのターンを終えた時にClaude Desktopへ開きます。途中の様子は `claude agents` の一覧で見られます。'
@@ -659,6 +768,50 @@ function stopOutput(record) {
   };
 }
 
+/** 引き継ぎ済みの会話へ届いた入力を止めた記録。入力の本文は書かない。 */
+function recordClaudeRedirect(entry, dir) {
+  try {
+    mkdirSync(dir, { recursive: true, mode: 0o700 });
+    appendFileSync(join(dir, 'redirects.jsonl'), JSON.stringify(entry) + '\n', { mode: 0o600 });
+  } catch { /* 記録を書けなくても、入力は止める */ }
+}
+
+/**
+ * UserPromptSubmit hook から呼ぶ (ADR 0062)。引き継ぎ済みで、後継が残っている会話へ届いた入力を、モデルを動かさずに止める。
+ *
+ * 作業は後継が持っている。旧い会話は道具を使えないので、届いた入力に文で答える事しかできない。人が打った文は、
+ * 後継の場所と一緒に打った人へ返す（Claude Code が、止めた理由と元の文を見せる）。裏の作業の完了通知も、ここで止める。
+ * 止めないと、文脈がほぼ一杯の旧い会話で、通知のたびにモデルが1回動く。
+ *
+ * 記録が無い会話、後継がまだ立っていない会話（予約・立ち上げ中・失敗）、後継が無くなった会話、subagent の中の入力には
+ * 何もしない（null）。Aiterm が起こした席の会話（ADR 0057）も止めない。席を外す前の版が引き継いだ席が残っていても、
+ * 呼び手は席の番の終わりを待っている。止めると番が始まらず、呼び手は答えを受け取れない。
+ *
+ * 止めた入力は、今の続きの会話の置き場へ置く (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 }) {
+  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 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 forwarded = forwardKind !== null && validSessionId(successorSessionId) && successorSessionId !== sessionId &&
+    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, forwarded }, dir);
+  return { output: { decision: 'block', reason: forwarded ? forwardedReason(record, dir, successorSessionId) : handedOffReason(record, dir) },
+    kind, handoffId: record.handoff_id, successorShortId, forwarded };
+}
+
 /**
  * PreToolUse hook の本体。引き継ぎの記録がある会話の道具を、実行させずに止める。
  * 最初に止めた hook だけが、止めた時点の依頼と設定を記録へ写し、後継を立てる worker を起動する。
@@ -712,7 +865,7 @@ export async function stopClaudeTurnForHandoff({
       }
     }
   }
-  return stopOutput(record);
+  return stopOutput(record, dir);
 }
 
 /**
@@ -777,6 +930,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

@@ -22,6 +22,8 @@ import {
   findClaudeAutoContinuationSource,
   resolveClaudeAutoHandoffSuccessor,
   isAitermSeatConversation,
+  redirectClaudeHandedOffPrompt,
+  readRunningBackgroundTasks,
 } from './claude-auto-handoff.mjs';
 import { parseAutoHandoffArgs } from './cli/auto-handoff.mjs';
 
@@ -583,6 +585,7 @@ test('worker: 止めた時点の依頼とモデルを transcript から写し、
     earlier_steps: null,
     stopped_tools: [{ name: 'Read', target: '' }],
     stopped_tools_total: 1,
+    background: { tasks: [], total: 0 },
     turn: null,
   }, '止めた道具の直前の発言まで出そろってから写す');
 
@@ -603,6 +606,7 @@ test('worker: 止めた時点の依頼とモデルを transcript から写し、
     earlier_steps: null,
     stopped_tools: [{ name: 'Read', target: '' }],
     stopped_tools_total: 1,
+    background: { tasks: [], total: 0 },
     turn: null,
   });
   assert.equal(second.calls[0][1], first.calls[0][1], '引き継ぎを重ねても、project 名と印は積み重ならない');
@@ -1226,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: [] },
@@ -1246,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' });
@@ -1583,3 +1601,113 @@ test('hook: 自分の失敗では圧縮も道具も止めず（exit code 1）、
   assert.match(log, /Missing session_id in PreCompact payload/);
   assert.match(log, /HOOK_PRE_TOOL_USE_FAILED/);
 }));
+
+// ---- 引き継ぎ済みの会話へ届いた入力 (ADR 0062) ----
+
+test('引き継ぎ済みの会話へ届いた入力: 後継が残っている時だけ、モデルを動かさずに止めて、今の続きの場所を返す', () => withDir(async dir => {
+  const projects = join(dir, 'claude', 'projects', '-work-app');
+  mkdirSync(projects, { recursive: true });
+  const a = 'aaaaaaaa-0000-4000-8000-000000000031', b = 'bbbbbbbb-0000-4000-8000-000000000032', c = 'cccccccc-0000-4000-8000-000000000033';
+  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 redirects = () => existsSync(join(dir, 'redirects.jsonl'))
+    ? readFileSync(join(dir, 'redirects.jsonl'), 'utf8').trim().split('\n').map(line => JSON.parse(line)) : [];
+
+  assert.equal(submit(a, '依頼'), null, '記録が無い会話');
+  for (const state of ['requested', 'stopped', 'launching', 'failed']) {
+    record(a, { state, successor: null });
+    assert.equal(submit(a, '依頼'), null, `後継がまだ立っていない（${state}）`);
+  }
+  record(a, { state: 'sent', successor: { short_id: 'bbbbbbbb', session_id: b } });
+  assert.equal(submit(a, '依頼'), null, '後継の transcript が無い（後継が消された）会話は止めない');
+  assert.deepEqual(redirects(), []);
+
+  writeFileSync(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', forwarded: true });
+  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', forwarded: true },
+    { 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 },
+  ], '止めた記録に入力の本文は書かない');
+
+  // 後継がさらに引き継がれている時は、その先を示す。道具を断る時の文も同じ
+  record(b, { state: 'unknown', successor: { short_id: 'cccccccc', session_id: null } });
+  writeFileSync(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,
+    launchWorker: async () => { throw new Error('must not launch'); } });
+  assert.match(denied.stopReason, /引き継ぎID: h-aaaaaaaa.*claude attach cccccccc（一覧に無い時は claude --resume cccccccc-0000-4000-8000-000000000033）$/);
+  // 今の続きの会話（記録が無い）は止めない
+  assert.equal(submit(c, '依頼'), null);
+}));
+
+test('公開CLI: prompt-submit は、引き継ぎ済みの会話の入力を止める出力を返す。ほかの会話には何も返さない', () => withDir(home => {
+  const dir = join(home, '.throughline', 'claude-auto-handoff');
+  const projects = join(home, '.claude', 'projects', '-work-app');
+  mkdirSync(dir, { recursive: true }); mkdirSync(projects, { recursive: true });
+  writeFileSync(join(projects, `${SUCCESSOR}.jsonl`), '');
+  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 } }));
+  const submit = (sessionId, prompt) => cli(home, ['prompt-submit'], JSON.stringify({ session_id: sessionId, cwd: home,
+    hook_event_name: 'UserPromptSubmit', prompt, transcript_path: join(projects, `${sessionId}.jsonl`) }), fakeClaudePath(home));
+
+  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}）` });
+  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.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 => {
+  const transcript = join(dir, 't.jsonl');
+  const started = (toolUseId, taskId, output) => ({ type: 'user', toolUseResult: { stdout: '', stderr: '', backgroundTaskId: taskId },
+    message: { role: 'user', content: [{ type: 'tool_result', tool_use_id: toolUseId,
+      content: `Command running in background with ID: ${taskId}. Output is being written to: ${output}. You will be notified when it completes.` }] } });
+  const notice = (taskId, status) => `<task-notification>\n<task-id>${taskId}</task-id>\n<tool-use-id>x</tool-use-id>\n<output-file>/o</output-file>\n` +
+    (status ? `<status>${status}</status>\n` : '<event>tick</event>\n') + '<summary>s</summary>\n</task-notification>';
+  writeFileSync(transcript, jsonl([
+    user('依頼', '2026-10-14T00:00:00.000Z', { origin: { kind: 'human' } }),
+    toolUse('t1', 'Bash', { command: 'npm run build', run_in_background: true }), started('t1', 'b1', '/tmp/tasks/b1.output'),
+    toolUse('t2', 'Bash', { command: 'npm test', run_in_background: true }), started('t2', 'b2', 'C:\\Users\\k\\AppData\\Local\\Temp\\claude tasks\\b2.output'),
+    toolUse('t3', 'Bash', { command: 'sleep 600', run_in_background: true }), started('t3', 'b3', '/tmp/tasks/b3.output'),
+    toolUse('t4', 'Monitor', { description: 'CI を見る' }), started('t4', 'b4', '/tmp/tasks/b4.output'),
+    toolUse('t5', 'Read', { file_path: '/work/app/a.mjs' }), toolResult('t5', 'ok'),
+    user(notice('b1', 'completed'), '2026-10-14T00:01:00.000Z', { origin: { kind: 'task-notification' } }),
+    { type: 'attachment', attachment: { type: 'queued_command', prompt: notice('b3', 'failed'), origin: { kind: 'task-notification' } } },
+    user(notice('b4', null), '2026-10-14T00:02:00.000Z', { origin: { kind: 'task-notification' } }),
+    { ...started('t9', 'b9', '/tmp/tasks/b9.output'), isSidechain: true },
+  ]));
+  assert.deepEqual(readRunningBackgroundTasks(transcript, '/work/app'), { total: 2, tasks: [
+    { task_id: 'b4', name: 'Monitor', target: 'CI を見る', output_file: '/tmp/tasks/b4.output' },
+    { task_id: 'b2', name: 'Bash', target: 'npm test', output_file: 'C:\\Users\\k\\AppData\\Local\\Temp\\claude tasks\\b2.output' },
+  ] }, '途中の知らせ（status なし）が来ただけの作業は、まだ動いている');
+  assert.deepEqual(readRunningBackgroundTasks(join(dir, 'none.jsonl')), { tasks: [], total: 0 });
+}));

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