throughline 0.13.0 → 0.14.1

package/src/claude-pre-compact.mjs

@@ -1,23 +1,27 @@
 #!/usr/bin/env node
 /**
- * PreCompact hook — Claude Code の自動継続の第一段 (ADR 0032)
+ * PreCompact hook — Claude Code の自動継続の第一段 (ADR 0033)
  *
  * stdin: { session_id, transcript_path, cwd, hook_event_name, trigger, custom_instructions }
  *
- * 自動圧縮（trigger=auto）で、自動継続が有効な project の時だけ、その会話に印を残す。
- * 記憶の注入は圧縮の後の SessionStart(source=compact) が行う。
+ * 自動圧縮（trigger=auto）で、自動継続が有効な project の時だけ、/tl と同じ印と引き継ぎの記録を残し、
+ * 圧縮を止める。Claude Code は PreCompact の exit code 2 を「圧縮を止める」と解釈する。
+ * 止めた後の会話は圧縮されないまま続き、次の道具の hook（PreToolUse）が作業を止める。
  *
- * この hook は圧縮を止めない。Claude Code は PreCompact の exit code 2 と `decision: "block"` を
- * 「圧縮を止める」と解釈するので、stdout には何も書かず、失敗した時も exit code 1 で終わる。
+ * 手動の /compact、無効な project、subagent の中の圧縮では、何も止めずに exit code 0 で終わる。
+ * この hook 自身が失敗した時は exit code 1 で終わり、圧縮は止めない。
  */
 
 import { pathToFileURL } from 'node:url';
 import { parseHookPayload } from './hosts/index.mjs';
-import { recordClaudeCompactRequest } from './claude-auto-handoff.mjs';
+import { requestClaudeAutoHandoff } from './claude-auto-handoff.mjs';
+import { getDb } from './db.mjs';
 import { logDecision } from './decision-log.mjs';
 import { recordRuntimeErrorBestEffort } from './runtime-error-store.mjs';
 import { logHookFailure } from './hook-failure-log.mjs';
 
+export const PRE_COMPACT_BLOCK_EXIT_CODE = 2;
+
 export async function run() {
   let raw = '';
   await new Promise((resolve) => {
@@ -30,7 +34,12 @@ export async function run() {
 
   const payload = parseHookPayload(raw, { env: process.env });
   const now = Date.now();
-  const result = recordClaudeCompactRequest({ payload, env: process.env, now });
+  const result = requestClaudeAutoHandoff({
+    payload,
+    env: process.env,
+    now,
+    openDb: getDb,
+  });
 
   logDecision({
     ts: new Date(now).toISOString(),
@@ -39,9 +48,14 @@ export async function run() {
     project_path: result.projectPath ?? null,
     trigger: payload.trigger ?? null,
     auto_continuation: result.status,
+    handoff_id: result.handoffId ?? null,
     skip_reason: result.reason ?? null,
   });
 
+  if (result.block) {
+    process.stderr.write(`Throughlineが自動圧縮を止めました。新しい会話へ引き継ぎます（引き継ぎID: ${result.handoffId}）。\n`);
+    process.exit(PRE_COMPACT_BLOCK_EXIT_CODE);
+  }
   process.exit(0);
 }
 

package/src/claude-pre-tool-use.mjs

@@ -0,0 +1,67 @@
+#!/usr/bin/env node
+/**
+ * PreToolUse hook — Claude Code の自動継続の第二段 (ADR 0033)
+ *
+ * stdin: { session_id, transcript_path, cwd, permission_mode, effort, tool_name, tool_input, ... }
+ *
+ * `auto-handoff enable --host claude` が登録する。道具の呼び出しのたびに走るので、引き継ぎの記録が無い
+ * 会話では、記録のファイルの有無だけを見て終わる（DB も他の module も読み込まない）。
+ *
+ * 記録がある会話では、その道具を実行させずにターンを止め、後継を立てる worker を起動する。
+ * この hook 自身が失敗した時は exit code 1 で終わる。道具は止まらず、作業は続く。
+ */
+
+import { existsSync } from 'node:fs';
+import { homedir } from 'node:os';
+import { join } from 'node:path';
+import { pathToFileURL } from 'node:url';
+
+// claude-auto-handoff.mjs と同じ置き場と形。速い道を保つために、ここでは import しない。
+const SESSION_ID_PATTERN = /^[A-Za-z0-9_-]{1,128}$/;
+
+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;
+  if (typeof sessionId !== 'string' || !SESSION_ID_PATTERN.test(sessionId) || payload.agent_id ||
+      !existsSync(join(homedir(), '.throughline', 'claude-auto-handoff', `${sessionId}.json`))) {
+    process.exit(0);
+  }
+
+  const { stopClaudeTurnForHandoff } = await import('./claude-auto-handoff.mjs');
+  const { logDecision } = await import('./decision-log.mjs');
+  const now = Date.now();
+  const output = await stopClaudeTurnForHandoff({ payload, now });
+  if (!output) process.exit(0);
+  logDecision({
+    ts: new Date(now).toISOString(),
+    phase: 'pre-tool-use-stop',
+    session_id: sessionId,
+    tool_name: payload.tool_name ?? null,
+  });
+  process.stdout.write(`${JSON.stringify(output)}\n`);
+  process.exit(0);
+}
+
+async function reportFailure(err) {
+  const { recordRuntimeErrorBestEffort } = await import('./runtime-error-store.mjs');
+  const { logHookFailure } = await import('./hook-failure-log.mjs');
+  recordRuntimeErrorBestEffort('HOOK_PRE_TOOL_USE_FAILED');
+  logHookFailure('HOOK_PRE_TOOL_USE_FAILED', err);
+}
+
+if (process.argv[1] && import.meta.url === pathToFileURL(process.argv[1]).href) {
+  run().catch(async (err) => {
+    await reportFailure(err);
+    process.stderr.write(`[pre-tool-use] error: ${err.message}\n`);
+    process.exit(1);
+  });
+}

package/src/cli/auto-handoff.mjs

@@ -1,19 +1,20 @@
 import { isAbsolute, resolve } from 'node:path';
 import { existsSync } from 'node:fs';
 import { withCodexReceiver, platformDesktopFinder, realCodexHome } from 'aiterm-steer-delivery';
-import { openReadOnlyDb, DB_PATH, CURRENT_VERSION } from '../db.mjs';
+import { getDb, openReadOnlyDb, DB_PATH, CURRENT_VERSION } from '../db.mjs';
 import { listAutoHandoffs, getAutoHandoff } from '../codex-auto-handoff-store.mjs';
 import { renderFrozenDetail } from '../codex-auto-handoff-memory.mjs';
 import { readAutoHandoffConfig, writeAutoHandoffConfig } from '../codex-auto-handoff-config.mjs';
 import { autoHandoffDeliveryProfile, runAutoHandoffWorker } from '../codex-auto-handoff.mjs';
-import { installCodexAutoHandoffHook, installClaudeAutoHandoffHook, claudeAutoHandoffHookRegistered } from './install.mjs';
+import { installCodexAutoHandoffHook, installClaudeAutoHandoffHooks, removeClaudeAutoHandoffHooks,
+  claudeAutoHandoffHooksRegistered } from './install.mjs';
 import { sameProjectPath } from '../project-path.mjs';
 import { readClaudeAutoHandoffConfig, writeClaudeAutoHandoffConfig } from '../claude-auto-handoff-config.mjs';
-import { listClaudeCompactRequests } from '../claude-auto-handoff.mjs';
+import { listClaudeAutoHandoffs, publicClaudeAutoHandoff, runClaudeAutoHandoffWorker } from '../claude-auto-handoff.mjs';
 
-// Claude の自動継続は圧縮後の同じ会話へ記憶を注入する (ADR 0032)。引き継ぎ操作の記録を持たないので、
-// 使える action は有効化・無効化・状態だけ。
-const CLAUDE_ACTIONS = ['enable', 'disable', 'status'];
+// Claude の自動継続 (ADR 0033)。引き継ぎの記録は旧い会話の session id で持つ。結果が不明な配送は
+// 再送しないので、resume は持たない。記憶の取得は通常の recall / detail を使うので、detail も持たない。
+const CLAUDE_ACTIONS = ['enable', 'disable', 'status', 'worker'];
 
 export function parseAutoHandoffArgs(args) {
   const out = { action: args[0] ?? 'status', host: 'codex', operation: null, project: null, origin: null, turn: null, database: null, json: false };
@@ -30,7 +31,7 @@ export function parseAutoHandoffArgs(args) {
     out[key] = args[++i];
   }
   if (!['codex', 'claude'].includes(out.host)) throw Error('auto_handoff_host_invalid');
-  if (out.host === 'claude' && (!CLAUDE_ACTIONS.includes(out.action) || out.operation)) throw Error('auto_handoff_action_unsupported');
+  if (out.host === 'claude' && !CLAUDE_ACTIONS.includes(out.action)) throw Error('auto_handoff_action_unsupported');
   if (out.project && !isAbsolute(out.project)) out.project = resolve(out.project);
   if (out.project && out.operation) throw Error('auto_handoff_argument_invalid');
   if (['worker', 'resume', 'detail'].includes(out.action) && !out.operation) throw Error('auto_handoff_operation_required');
@@ -67,24 +68,29 @@ export async function enableAutoHandoff({ project = null, codexHome = realCodexH
   return { status: 'enabled', config, hookKeys, host: 'desktop' };
 }
 
-export function enableClaudeAutoHandoff({ project = null, register = installClaudeAutoHandoffHook } = {}) {
+export function enableClaudeAutoHandoff({ project = null, register = installClaudeAutoHandoffHooks } = {}) {
   const registration = register();
   const current = readClaudeAutoHandoffConfig();
   const projects = project ? [...new Set([...(current.enabled ? current.projects : []), project])] : [];
   const config = writeClaudeAutoHandoffConfig({ enabled: true, projects });
-  return { status: 'enabled', config, hook: { ...registration, registered: true }, host: 'claude' };
+  return { status: 'enabled', config, hooks: { ...registration, registered: true }, host: 'claude' };
 }
 
-function runClaude(parsed) {
+async function runClaude(parsed) {
   if (parsed.action === 'enable') return enableClaudeAutoHandoff({ project: parsed.project });
   if (parsed.action === 'disable') {
-    return { status: 'disabled', host: 'claude',
-      config: writeClaudeAutoHandoffConfig({ ...readClaudeAutoHandoffConfig(), enabled: false }) };
+    const config = writeClaudeAutoHandoffConfig({ ...readClaudeAutoHandoffConfig(), enabled: false });
+    // PreToolUse は道具の呼び出しのたびに走る。使わない間は置いたままにしない。
+    removeClaudeAutoHandoffHooks();
+    return { status: 'disabled', host: 'claude', config };
   }
-  const pending = listClaudeCompactRequests()
-    .filter(request => !parsed.project || sameProjectPath(request.project_path, parsed.project));
+  if (parsed.action === 'worker') return publicClaudeAutoHandoff(await runClaudeAutoHandoffWorker(parsed.operation, { openDb: getDb }));
+  const handoffs = listClaudeAutoHandoffs()
+    .filter(record => !parsed.project || sameProjectPath(record.project_path, parsed.project))
+    .filter(record => !parsed.operation || record.handoff_id === parsed.operation || record.source_session_id === parsed.operation)
+    .map(publicClaudeAutoHandoff);
   return { host: 'claude', config: readClaudeAutoHandoffConfig(),
-    hook: { registered: claudeAutoHandoffHookRegistered() }, pending };
+    hooks: { registered: claudeAutoHandoffHooksRegistered() }, handoffs };
 }
 
 export function publicOperation(operation) {
@@ -102,14 +108,14 @@ export async function run(args = []) {
     const parsed = parseAutoHandoffArgs(args);
     let result;
     if (parsed.host === 'claude') {
-      result = runClaude(parsed);
+      result = await runClaude(parsed);
       if (parsed.json) process.stdout.write(JSON.stringify(result) + '\n');
       else if (parsed.action === 'status') {
         process.stdout.write(`自動継続: ${result.config.enabled ? '有効' : '無効'}（Claude Code）\n`);
-        process.stdout.write(`PreCompact hook: ${result.hook.registered ? '登録済み' : '未登録'}\n`);
-        for (const item of result.pending) process.stdout.write(`${item.session_id}  圧縮待ち  ${new Date(item.requested_at).toISOString()}\n`);
+        process.stdout.write(`hook（PreCompact・PreToolUse）: ${result.hooks.registered ? '登録済み' : '未登録'}\n`);
+        for (const item of result.handoffs) process.stdout.write(`${item.handoff_id}  ${item.state}  ${item.error_code ?? ''}\n`);
       } else process.stdout.write(JSON.stringify(result, null, 2) + '\n');
-      return 0;
+      return result.state === 'failed' || result.state === 'unknown' ? 1 : 0;
     }
     if (parsed.action === 'enable') result = await enableAutoHandoff({ project: parsed.project });
     else if (parsed.action === 'disable') result = { status: 'disabled', config: writeAutoHandoffConfig({ ...readAutoHandoffConfig(), enabled: false }) };

package/src/cli/install.mjs

@@ -19,6 +19,7 @@ import { join, dirname, resolve, delimiter } from 'node:path';
 import { fileURLToPath } from 'node:url';
 import { homedir } from 'node:os';
 import { ensureMonitorTaskFile, shouldRecommendGitignore } from '../vscode-task.mjs';
+import { readClaudeAutoHandoffConfig } from '../claude-auto-handoff-config.mjs';
 
 const PACKAGE_ROOT = resolve(dirname(fileURLToPath(import.meta.url)), '..', '..');
 const SLASH_COMMANDS_SRC = join(PACKAGE_ROOT, '.claude', 'commands');
@@ -37,6 +38,7 @@ const SC_COMMANDS = [
   'throughline session-start',
   'throughline prompt-submit',
   'throughline pre-compact',
+  'throughline pre-tool-use',
   // 旧コマンド（アンインストール時に除去する）
   'throughline inject-context',
   'throughline capture-tool',
@@ -56,14 +58,22 @@ const SC_HOOKS = {
   UserPromptSubmit: {
     hooks: [{ type: 'command', command: 'throughline prompt-submit' }],
   },
-  // 自動継続の第一段 (ADR 0032)。matcher は付けない: 手動の /compact でも呼ばれ、古い印を消す。
-  // 自動継続が無効な時は何も残さずに抜ける。
+};
+
+// Claude の自動継続 (ADR 0033) の hook。install は登録しない。`auto-handoff enable --host claude` が登録し、
+// `disable` が外す。PreToolUse は道具の呼び出しのたびに走るので、使わない端末には置かない。
+// PreCompact に matcher は付けない: 手動の /compact でも呼ばれ、止める前の記録を取り下げる。
+const CLAUDE_AUTO_HANDOFF_HOOKS = {
   PreCompact: {
     hooks: [{ type: 'command', command: 'throughline pre-compact' }],
   },
+  PreToolUse: {
+    hooks: [{ type: 'command', command: 'throughline pre-tool-use', timeout: 15 }],
+  },
 };
-
-const CLAUDE_PRE_COMPACT_COMMAND = SC_HOOKS.PreCompact.hooks[0].command;
+const CLAUDE_AUTO_HANDOFF_COMMANDS = new Set(
+  Object.values(CLAUDE_AUTO_HANDOFF_HOOKS).map(entry => entry.hooks[0].command),
+);
 
 const CODEX_COMMANDS = [
   'throughline codex-hook stop',
@@ -637,23 +647,57 @@ function installCodexHooks() {
   return { hooksPath, configPath };
 }
 
-export function claudeAutoHandoffHookRegistered(settingsPath = join(homedir(), '.claude', 'settings.json')) {
-  const groups = readSettings(settingsPath).hooks?.PreCompact ?? [];
-  // matcher 付きの登録は手動の /compact で呼ばれず、古い印が残る。matcher 無しだけを登録済みとする。
-  return groups.some(group => !group.matcher && (group.hooks ?? []).some(hook => hook.command === CLAUDE_PRE_COMPACT_COMMAND));
+const defaultClaudeSettingsPath = () => join(homedir(), '.claude', 'settings.json');
+
+function isClaudeAutoHandoffEntry(group, event) {
+  const entry = CLAUDE_AUTO_HANDOFF_HOOKS[event];
+  return !group.matcher && (group.hooks ?? []).length === 1 &&
+    group.hooks[0].command === entry.hooks[0].command && group.hooks[0].timeout === entry.hooks[0].timeout;
+}
+
+/** 自動継続の hook が、今の形で2つとも登録されているか。 */
+export function claudeAutoHandoffHooksRegistered(settingsPath = defaultClaudeSettingsPath()) {
+  const hooks = readSettings(settingsPath).hooks ?? {};
+  return Object.keys(CLAUDE_AUTO_HANDOFF_HOOKS).every(event =>
+    (hooks[event] ?? []).filter(group => isClaudeAutoHandoffEntry(group, event)).length === 1 &&
+    (hooks[event] ?? []).flatMap(group => group.hooks ?? [])
+      .filter(hook => CLAUDE_AUTO_HANDOFF_COMMANDS.has(hook.command)).length === 1);
 }
 
-/** `auto-handoff enable --host claude` 用。古い版で install した端末にも PreCompact hook を足す。 */
-export function installClaudeAutoHandoffHook(settingsPath = join(homedir(), '.claude', 'settings.json')) {
-  if (!claudeAutoHandoffHookRegistered(settingsPath)) {
+function withoutClaudeAutoHandoffHooks(hooks) {
+  const next = {};
+  for (const [event, groups] of Object.entries(hooks)) {
+    const kept = groups.map(group => ({ ...group,
+      hooks: (group.hooks ?? []).filter(hook => !CLAUDE_AUTO_HANDOFF_COMMANDS.has(hook.command)) }))
+      .filter(group => group.hooks.length);
+    if (kept.length) next[event] = kept;
+  }
+  return next;
+}
+
+/** `auto-handoff enable --host claude` 用。他製品の hook とその並びは保ち、自分の2つを今の形で置く。 */
+export function installClaudeAutoHandoffHooks(settingsPath = defaultClaudeSettingsPath()) {
+  if (!claudeAutoHandoffHooksRegistered(settingsPath)) {
     const current = readSettings(settingsPath);
-    current.hooks ??= {};
-    const preserved = (current.hooks.PreCompact ?? []).map(group => ({ ...group,
-      hooks: (group.hooks ?? []).filter(hook => hook.command !== CLAUDE_PRE_COMPACT_COMMAND) })).filter(group => group.hooks.length);
-    current.hooks.PreCompact = [SC_HOOKS.PreCompact, ...preserved];
-    writeSettings(settingsPath, current);
+    const hooks = withoutClaudeAutoHandoffHooks(current.hooks ?? {});
+    for (const [event, entry] of Object.entries(CLAUDE_AUTO_HANDOFF_HOOKS)) hooks[event] = [...(hooks[event] ?? []), entry];
+    writeSettings(settingsPath, { ...current, hooks });
   }
-  return { settingsPath, command: CLAUDE_PRE_COMPACT_COMMAND };
+  return { settingsPath, commands: [...CLAUDE_AUTO_HANDOFF_COMMANDS] };
+}
+
+/** `auto-handoff disable --host claude` と、無効な端末の install 用。自分の2つだけを外す。 */
+export function removeClaudeAutoHandoffHooks(settingsPath = defaultClaudeSettingsPath()) {
+  if (!existsSync(settingsPath)) return { settingsPath, removed: false };
+  const current = readSettings(settingsPath);
+  const before = current.hooks ?? {};
+  const hooks = withoutClaudeAutoHandoffHooks(before);
+  if (JSON.stringify(hooks) === JSON.stringify(before)) return { settingsPath, removed: false };
+  const next = { ...current };
+  if (Object.keys(hooks).length) next.hooks = hooks;
+  else delete next.hooks;
+  writeSettings(settingsPath, next);
+  return { settingsPath, removed: true };
 }
 
 export function installCodexAutoHandoffHook(codexHome = join(homedir(), '.codex')) {
@@ -773,6 +817,12 @@ export async function run(args = []) {
 
   current.hooks = existingHooks;
   writeSettings(settingsPath, current);
+  // Claude の自動継続の hook は、有効にした端末にだけ置く (ADR 0033)。0.13.0 の install が置いた
+  // PreCompact も、無効な端末からは外す。project の install では触らない。
+  if (!args.includes('--project')) {
+    if (readClaudeAutoHandoffConfig().enabled) installClaudeAutoHandoffHooks(settingsPath);
+    else removeClaudeAutoHandoffHooks(settingsPath);
+  }
   const { installed: installedCommands, skipped } = installSlashCommands(commandsDir);
   const codex = args.includes('--project') ? null : installCodexHooks();
   const grok = args.includes('--project') ? null : installGrokHooks();
@@ -804,7 +854,6 @@ export async function run(args = []) {
   console.log('  SessionStart     → throughline session-start  (セッション記録・バトン消費・引き継ぎ注入)');
   console.log('  Stop             → throughline process-turn   (L1 要約 + L2 本文保存 + L3 詳細保存)');
   console.log('  UserPromptSubmit → throughline prompt-submit  (/tl & /clear バトン書き込み)');
-  console.log('  PreCompact       → throughline pre-compact    (自動継続の印。既定は無効: auto-handoff enable --host claude)');
   if (codex) {
     console.log(`  Codex UserPromptSubmit → ${buildCodexUserPromptSubmitHookCommand()} (capture / monitor state only; auto refresh disabled)`);
     console.log(`  Codex PostToolUse      → ${buildCodexPostToolUseHookCommand()} (capture / monitor state only; auto refresh disabled)`);

package/src/cli/install.test.mjs

@@ -667,12 +667,30 @@ test('Claude Stop hook is registered with async:true so it does not block ター
       .flatMap(g => g.hooks ?? [])
       .find(h => h.command === 'throughline prompt-submit');
     assert.notEqual(promptSubmitHook.async, true, 'UserPromptSubmit stays synchronous (needs baton write committed before turn)');
-    // 自動継続の印 (ADR 0032)。matcher 無し = 手動の /compact でも呼ばれて古い印を消す。
-    assert.deepEqual(settings.hooks.PreCompact, [{ hooks: [{ type: 'command', command: 'throughline pre-compact' }] }]);
+    // Claude の自動継続の hook (ADR 0033) は install では置かない。有効にした端末にだけ置く。
+    assert.equal(settings.hooks.PreCompact, undefined);
+    assert.equal(settings.hooks.PreToolUse, undefined);
+
+    // 0.13.0 の install が置いた PreCompact は、無効な端末の install で外す。他製品の hook は残す。
+    const settingsPath = join(home.dir, '.claude', 'settings.json');
+    const other = { hooks: [{ type: 'command', command: 'other-product pre-compact' }] };
+    writeFileSync(settingsPath, JSON.stringify({ ...settings, hooks: { ...settings.hooks,
+      PreCompact: [{ hooks: [{ type: 'command', command: 'throughline pre-compact' }] }, other] } }));
+    await run([]);
+    assert.deepEqual(JSON.parse(readFileSync(settingsPath, 'utf8')).hooks.PreCompact, [other]);
+
+    // 有効な端末の install は、2つの hook を今の形で保つ
+    mkdirSync(join(home.dir, '.throughline'), { recursive: true });
+    writeFileSync(join(home.dir, '.throughline', 'claude-auto-handoff.json'),
+      JSON.stringify({ schema: 'throughline.claude-auto-handoff.v1', enabled: true, projects: [] }));
+    await run([]);
+    const enabled = JSON.parse(readFileSync(settingsPath, 'utf8')).hooks;
+    assert.deepEqual(enabled.PreCompact, [other, { hooks: [{ type: 'command', command: 'throughline pre-compact' }] }]);
+    assert.deepEqual(enabled.PreToolUse, [{ hooks: [{ type: 'command', command: 'throughline pre-tool-use', timeout: 15 }] }]);
 
     await run(['--uninstall']);
-    const removed = JSON.parse(readFileSync(join(home.dir, '.claude', 'settings.json'), 'utf8'));
-    assert.equal(removed.hooks, undefined, 'uninstall removes every Throughline Claude hook including PreCompact');
+    assert.deepEqual(JSON.parse(readFileSync(settingsPath, 'utf8')).hooks, { PreCompact: [other] },
+      'uninstall removes every Throughline Claude hook and keeps the others');
   } finally {
     unsilence();
     home.restore();

package/src/handoff-executor.mjs

@@ -15,12 +15,14 @@ import { consumeBaton } from './baton.mjs';
 import { consumePendingHandoff } from './pending-handoff.mjs';
 import { mergeSpecificPredecessor, resolveMergeTarget } from './session-merger.mjs';
 import { backfillBodies, deriveTranscriptPath, logBackfill } from './turn-backfill.mjs';
-import { buildBudgetedResumeContext } from './resume-context.mjs';
+import { buildBudgetedResumeContext, buildAutoContinuationContext } from './resume-context.mjs';
+import { acceptClaudeAutoContinuation } from './claude-auto-handoff.mjs';
 import { readAllSessionStates } from './state-file.mjs';
 
 /**
  * @param {import('node:sqlite').DatabaseSync} db
- * @param {{ sessionId: string, projectPath: string, now?: number }} params
+ * @param {{ sessionId: string, projectPath: string, now?: number, prompt?: string|null }} params
+ *   prompt は届いた指示の本文。前任が自動継続で引き継いだ会話の時に、配送の受領を照合する (ADR 0033)。
  * @returns {{
  *   attempted: boolean,            // pending 行が存在した (= newborn の初回プロンプト)
  *   triggeredPath: 'baton' | 'auto' | null,
@@ -31,7 +33,7 @@ import { readAllSessionStates } from './state-file.mjs';
  *   injectionStats: object | null, // dropped counts 等 (ログ用)
  * }}
  */
-export function executeFirstPromptHandoff(db, { sessionId, projectPath, now = Date.now() }) {
+export function executeFirstPromptHandoff(db, { sessionId, projectPath, now = Date.now(), prompt = null }) {
   const pending = consumePendingHandoff(db, { sessionId });
   if (!pending) {
     return {
@@ -82,11 +84,14 @@ export function executeFirstPromptHandoff(db, { sessionId, projectPath, now = Da
     const stateTranscriptPath = readAllSessionStates().find(
       (state) => state.sessionId === predecessorId,
     )?.transcriptPath;
-    const predecessorTranscriptPath = existsSync(derivedTranscriptPath)
-      ? derivedTranscriptPath
-      : stateTranscriptPath && existsSync(stateTranscriptPath)
-        ? stateTranscriptPath
-        : null;
+    // 前任が自動継続でこの会話へ引き継いだなら、止めた時点の依頼を現在地に載せる (ADR 0033)。
+    // 止めたターンは Stop を通っていないので、state ファイルが無いことがある。hook が記録した
+    // transcript の場所を、回収元の候補に足す。
+    const autoContinuation = triggeredPath === 'baton'
+      ? acceptClaudeAutoContinuation({ predecessorId: baton.sessionId, successorSessionId: sessionId, prompt, now })
+      : null;
+    const predecessorTranscriptPath = [derivedTranscriptPath, stateTranscriptPath, autoContinuation?.transcriptPath]
+      .find((candidate) => candidate && existsSync(candidate)) ?? null;
 
     if (predecessorTranscriptPath) {
       try {
@@ -132,10 +137,16 @@ export function executeFirstPromptHandoff(db, { sessionId, projectPath, now = Da
       });
     }
 
-    const budgeted = buildBudgetedResumeContext(db, {
-      sessionId,
-      isInheritance: true,
-    });
+    const budgeted = autoContinuation
+      ? buildAutoContinuationContext(db, {
+        sessionId,
+        inFlight: autoContinuation.inFlight,
+        projectPath: autoContinuation.projectPath,
+      })
+      : buildBudgetedResumeContext(db, {
+        sessionId,
+        isInheritance: true,
+      });
     if (budgeted) {
       injectionText = budgeted.text;
       injectionStats = {
@@ -145,6 +156,7 @@ export function executeFirstPromptHandoff(db, { sessionId, projectPath, now = Da
         older_turns: budgeted.olderTurns,
         older_summarized: budgeted.olderSummarized,
         truncated_newest_l2: budgeted.truncatedNewestL2,
+        ...(autoContinuation ? { auto_handoff_id: autoContinuation.handoffId } : {}),
       };
     }
   }

package/src/hosts/claude.mjs

@@ -26,6 +26,16 @@ export function compactClaudeTaskNotification(text) {
   return kept ? `${block}\n${kept}` : block;
 }
 
+// 別の会話から届いた発言（cross-session messaging、Throughline の自動継続の指示）には、Claude Code が
+// 毎回同じ注意書きを後ろに付ける。記憶には送り主の行と本文だけを残す。
+const PEER_MESSAGE_PREFIX = 'Another Claude session sent a message:';
+const PEER_MESSAGE_NOTE = '\n\nThis came from another Claude session';
+export function compactClaudePeerMessage(text) {
+  if (typeof text !== 'string' || !text.startsWith(PEER_MESSAGE_PREFIX)) return text;
+  const note = text.lastIndexOf(PEER_MESSAGE_NOTE);
+  return note < 0 ? text : text.slice(0, note);
+}
+
 export const claudeHostAdapter = Object.freeze({
   host: CLAUDE_HOST,
   matchesSessionId: (sessionId) => hostOfSessionId(sessionId) === CLAUDE_HOST,

package/src/prompt-submit.mjs

@@ -180,6 +180,7 @@ export async function run() {
       sessionId: session_id,
       projectPath,
       now,
+      prompt: typeof prompt === 'string' ? prompt : null,
     });
     if (handoff.attempted) {
       if (handoff.injectionText) {