throughline 0.12.9 → 0.14.0

package/src/claude-pre-compact.mjs

@@ -0,0 +1,69 @@
+#!/usr/bin/env node
+/**
+ * PreCompact hook — Claude Code の自動継続の第一段 (ADR 0033)
+ *
+ * stdin: { session_id, transcript_path, cwd, hook_event_name, trigger, custom_instructions }
+ *
+ * 自動圧縮（trigger=auto）で、自動継続が有効な project の時だけ、/tl と同じ印と引き継ぎの記録を残し、
+ * 圧縮を止める。Claude Code は PreCompact の exit code 2 を「圧縮を止める」と解釈する。
+ * 止めた後の会話は圧縮されないまま続き、次の道具の hook（PreToolUse）が作業を止める。
+ *
+ * 手動の /compact、無効な project、subagent の中の圧縮では、何も止めずに exit code 0 で終わる。
+ * この hook 自身が失敗した時は exit code 1 で終わり、圧縮は止めない。
+ */
+
+import { pathToFileURL } from 'node:url';
+import { parseHookPayload } from './hosts/index.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) => {
+    process.stdin.setEncoding('utf8');
+    process.stdin.on('data', (chunk) => {
+      raw += chunk;
+    });
+    process.stdin.on('end', resolve);
+  });
+
+  const payload = parseHookPayload(raw, { env: process.env });
+  const now = Date.now();
+  const result = requestClaudeAutoHandoff({
+    payload,
+    env: process.env,
+    now,
+    openDb: getDb,
+  });
+
+  logDecision({
+    ts: new Date(now).toISOString(),
+    phase: 'pre-compact',
+    session_id: result.sessionId,
+    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);
+}
+
+if (process.argv[1] && import.meta.url === pathToFileURL(process.argv[1]).href) {
+  run().catch((err) => {
+    recordRuntimeErrorBestEffort('HOOK_PRE_COMPACT_FAILED');
+    logHookFailure('HOOK_PRE_COMPACT_FAILED', err);
+    process.stderr.write(`[pre-compact] error: ${err.message}\n`);
+    process.exit(1);
+  });
+}

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

@@ -6,23 +6,32 @@ import { listAutoHandoffs, getAutoHandoff } from '../codex-auto-handoff-store.mj
 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 } 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 { listClaudeAutoHandoffs, publicClaudeAutoHandoff, runClaudeAutoHandoffWorker } from '../claude-auto-handoff.mjs';
+
+// 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', operation: null, project: null, origin: null, turn: null, database: null, json: false };
+  const out = { action: args[0] ?? 'status', host: 'codex', operation: null, project: null, origin: null, turn: null, database: null, json: false };
   if (!['enable', 'disable', 'status', 'resume', 'detail', 'worker'].includes(out.action)) throw Error('auto_handoff_action_invalid');
-  const allowed = { enable: ['project'], disable: [], status: ['project', 'operation'],
-    resume: ['operation'], worker: ['operation'], detail: ['operation', 'origin', 'turn', 'database'] }[out.action];
+  const allowed = ['host', ...{ enable: ['project'], disable: [], status: ['project', 'operation'],
+    resume: ['operation'], worker: ['operation'], detail: ['operation', 'origin', 'turn', 'database'] }[out.action]];
   const seen = new Set();
   for (let i = 1; i < args.length; i++) {
     if (seen.has(args[i])) throw Error('auto_handoff_argument_invalid');
     seen.add(args[i]);
     if (args[i] === '--json') { out.json = true; continue; }
-    const key = { '--operation': 'operation', '--project': 'project', '--origin': 'origin', '--turn': 'turn', '--database': 'database' }[args[i]];
+    const key = { '--host': 'host', '--operation': 'operation', '--project': 'project', '--origin': 'origin', '--turn': 'turn', '--database': 'database' }[args[i]];
     if (!key || !allowed.includes(key) || !args[i + 1] || args[i + 1].startsWith('--')) throw Error('auto_handoff_argument_invalid');
     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)) 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');
@@ -59,6 +68,31 @@ export async function enableAutoHandoff({ project = null, codexHome = realCodexH
   return { status: 'enabled', config, hookKeys, host: 'desktop' };
 }
 
+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, hooks: { ...registration, registered: true }, host: 'claude' };
+}
+
+async function runClaude(parsed) {
+  if (parsed.action === 'enable') return enableClaudeAutoHandoff({ project: parsed.project });
+  if (parsed.action === 'disable') {
+    const config = writeClaudeAutoHandoffConfig({ ...readClaudeAutoHandoffConfig(), enabled: false });
+    // PreToolUse は道具の呼び出しのたびに走る。使わない間は置いたままにしない。
+    removeClaudeAutoHandoffHooks();
+    return { status: 'disabled', host: 'claude', config };
+  }
+  if (parsed.action === 'worker') return publicClaudeAutoHandoff(await runClaudeAutoHandoffWorker(parsed.operation));
+  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(),
+    hooks: { registered: claudeAutoHandoffHooksRegistered() }, handoffs };
+}
+
 export function publicOperation(operation) {
   if (!operation) return null;
   const { handoff_id, source_thread_id, source_turn_id, target_thread_id, delivery_id,
@@ -73,6 +107,16 @@ export async function run(args = []) {
   try {
     const parsed = parseAutoHandoffArgs(args);
     let result;
+    if (parsed.host === 'claude') {
+      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(`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 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 }) };
     else if (parsed.action === 'detail') {

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');
@@ -36,6 +37,8 @@ const SC_COMMANDS = [
   'throughline process-turn',
   'throughline session-start',
   'throughline prompt-submit',
+  'throughline pre-compact',
+  'throughline pre-tool-use',
   // 旧コマンド（アンインストール時に除去する）
   'throughline inject-context',
   'throughline capture-tool',
@@ -57,6 +60,21 @@ const SC_HOOKS = {
   },
 };
 
+// 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_AUTO_HANDOFF_COMMANDS = new Set(
+  Object.values(CLAUDE_AUTO_HANDOFF_HOOKS).map(entry => entry.hooks[0].command),
+);
+
 const CODEX_COMMANDS = [
   'throughline codex-hook stop',
   'throughline codex-hook user-prompt-submit',
@@ -629,6 +647,59 @@ function installCodexHooks() {
   return { hooksPath, configPath };
 }
 
+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);
+}
+
+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);
+    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, 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')) {
   const hooksPath = join(codexHome, 'hooks.json');
   const configPath = join(codexHome, 'config.toml');
@@ -746,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();

package/src/cli/install.test.mjs

@@ -667,6 +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)');
+    // 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']);
+    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) {

package/src/resume-context.mjs

@@ -3,6 +3,7 @@
  *
  * 呼び出し元:
  *   - handoff-executor.mjs（最初のUserPromptSubmitでauto path / baton path共通注入）
+ *   - handoff-executor.mjs（前任が自動継続で引き継いだ会話の、最初のUserPromptSubmit。ADR 0033）
  *
  * 設計 (docs/02_clear_auto_handoff_plan.md):
  *   - 予算付き注入: ヘッダ + 現在地アンカー + pull案内を固定部とし、残りへ
@@ -55,6 +56,29 @@ const RESUME_HEADER_TEMPLATE = (turnCount, handoffDisclosure) =>
 
 const NORMAL_HEADER = '## Throughline: セッション記憶';
 
+const DEFAULT_ANCHOR_TITLE = '### 現在地 (直前のやりとり)';
+
+// 自動継続で立てた新しい会話へ注入する時のヘッダ (ADR 0033)。/clear の引き継ぎと違い、
+// 前の会話は作業の途中で止めてあり、次のユーザー入力は来ない。宣言はさせず、そのまま続けさせる。
+const AUTO_CONTINUATION_HEADER = (projectPath) =>
+  `## Throughline: 自動継続の文脈\n` +
+  (projectPath ? `作業ディレクトリ: ${projectPath}\n` : '') +
+  `\n` +
+  `**読み方 (重要):**\n` +
+  `- 前の会話は文脈の上限に近づいたため、Throughline が自動圧縮の前に止めて、この新しい会話へ引き継ぎました。` +
+  `下記は、前の会話で **あなた自身とユーザーが交わした会話の原文** です。\n` +
+  `- 「現在地」のターンは **作業の途中で止めたもの** です。ユーザーの追加入力を待たず、未完了の作業をそのまま続けてください。\n` +
+  `- 完了済みの操作を繰り返さないでください。止める直前に呼ぼうとした道具は実行されていません。` +
+  `直前の実行結果が分からない時は、作業ツリーや記録を確かめてから続けてください。\n` +
+  '- **完了したターンの詳細**: **`Bash` ツールで `throughline detail HH:MM:SS` を実行** ' +
+  `(該当ターンの本文＋詳細を stdout に返します)`;
+
+const AUTO_CONTINUATION_ANCHOR_TITLE = '### 現在地 (作業の途中で止めたターン)';
+// 途中で止めたターンは、本文の断片が無ければ bodies に入らない。依頼の原文を必ず渡せる場所は
+// ここだけなので、/clear のアンカー (600 字) より厚く取る。
+const IN_FLIGHT_USER_MAX_CHARS = 4_000;
+const IN_FLIGHT_ASSISTANT_MAX_CHARS = 1_500;
+
 // v0.10.12以前にThroughline自身がassistantへ付与させていた宣言行。
 // 製品由来のメタ情報だけを引き継ぎ材料から除き、会話本文への模倣連鎖を止める。
 // userが同じ文を引用した場合は会話内容なので保持する。
@@ -193,14 +217,14 @@ function buildResumeSections(
     });
   }
 
-  return { header, anchorLines, l1Lines, l2Lines };
+  return { header, anchorTitle: DEFAULT_ANCHOR_TITLE, anchorLines, l1Lines, l2Lines };
 }
 
-function joinSections({ header, anchorLines, l1Lines, l2Lines }, { l1Note = null, l2Note = null } = {}) {
+function joinSections({ header, anchorTitle, anchorLines, l1Lines, l2Lines }, { l1Note = null, l2Note = null } = {}) {
   const lines = [header];
   if (anchorLines.length > 0) {
     lines.push('');
-    lines.push('### 現在地 (直前のやりとり)');
+    lines.push(anchorTitle);
     lines.push(...anchorLines);
   }
   if (l1Lines.length > 0 || l1Note) {
@@ -396,7 +420,11 @@ export function buildBudgetedResumeContext(
     handoffDisclosure,
   });
   if (!sections) return null;
+  return renderBudgetedSections(db, sections, { sessionId, excludeOriginId, maxChars });
+}
 
+/** 組み立て済みのセクションを、予算内の注入テキストにする（/clear の引き継ぎと自動圧縮後の継続が共有）。 */
+function renderBudgetedSections(db, sections, { sessionId, excludeOriginId, maxChars }) {
   const lineCost = (s) => s.length + 1; // join('\n') 分
 
   // L2 行をターン単位のグループにまとめる（元の古い順を保つ）
@@ -418,7 +446,7 @@ export function buildBudgetedResumeContext(
   const fixedCost =
     lineCost(sections.header) +
     (sections.anchorLines.length > 0
-      ? lineCost('') + lineCost('### 現在地 (直前のやりとり)') +
+      ? lineCost('') + lineCost(sections.anchorTitle) +
         sections.anchorLines.reduce((a, l) => a + lineCost(l), 0)
       : 0) +
     lineCost('') + lineCost('### 直前の対話 (L2 / active work thread, 古い順)');
@@ -487,7 +515,7 @@ export function buildBudgetedResumeContext(
   const lines = [sections.header];
   if (sections.anchorLines.length > 0) {
     lines.push('');
-    lines.push('### 現在地 (直前のやりとり)');
+    lines.push(sections.anchorTitle);
     lines.push(...sections.anchorLines);
   }
   lines.push('');
@@ -511,3 +539,63 @@ export function buildBudgetedResumeContext(
     truncatedNewestL2,
   };
 }
+
+// 長い依頼は、指示が先頭にも末尾にも書かれる。先頭 3/4 と末尾 1/4 を残し、間を抜いたことを明示する。
+function truncateInFlight(text, maxChars) {
+  const trimmed = text.trim();
+  if (trimmed.length <= maxChars) return trimmed;
+  const head = Math.ceil(maxChars * 0.75);
+  const tail = maxChars - head;
+  return `${trimmed.slice(0, head)} …(長いため中略 ${trimmed.length - maxChars} 字)… ${trimmed.slice(-tail)}`;
+}
+
+/**
+ * 自動継続で立てた新しい会話へ注入するテキスト (ADR 0033)。
+ *
+ * 構成は /clear の引き継ぎと同じ予算付き（ヘッダ + 現在地 + 案内 + 入るだけの L2）。違いは現在地で、
+ * DB の最新ターンではなく、止めた時点に記録した作業途中のターンを載せる。
+ *
+ * @param {import('node:sqlite').DatabaseSync} db
+ * @param {{
+ *   sessionId: string,  合流を終えた後継の session id
+ *   inFlight: {
+ *     user: {content: string, timestamp: number|null},
+ *     last_fragment: {content: string, timestamp: number|null} | null,
+ *   } | null,
+ *   projectPath?: string | null,  前の会話の作業ディレクトリ。依頼の中の相対的な場所の基準として渡す
+ *   maxChars?: number,
+ * }} params
+ */
+export function buildAutoContinuationContext(
+  db,
+  { sessionId, inFlight, projectPath = null, maxChars = INJECTION_BUDGET_CHARS },
+) {
+  const stored = buildResumeSections(db, { sessionId, isInheritance: true, handoffDisclosure: 'silent' });
+  const stamp = (timestamp) => (timestamp == null ? '' : ` [${formatClock(timestamp)}]`);
+  const anchorLines = [];
+  if (inFlight) {
+    anchorLines.push(
+      `**作業中のユーザー依頼**${stamp(inFlight.user.timestamp)}: ` +
+        truncateInFlight(inFlight.user.content, IN_FLIGHT_USER_MAX_CHARS),
+    );
+    if (inFlight.last_fragment) {
+      anchorLines.push(
+        `**止める直前のあなたの発言**${stamp(inFlight.last_fragment.timestamp)}: ` +
+          truncateInFlight(inFlight.last_fragment.content, IN_FLIGHT_ASSISTANT_MAX_CHARS),
+      );
+    }
+  }
+  if (!stored && anchorLines.length === 0) return null;
+
+  return renderBudgetedSections(
+    db,
+    {
+      header: AUTO_CONTINUATION_HEADER(projectPath),
+      anchorTitle: AUTO_CONTINUATION_ANCHOR_TITLE,
+      anchorLines,
+      l1Lines: [],
+      l2Lines: stored?.l2Lines ?? [],
+    },
+    { sessionId, excludeOriginId: null, maxChars },
+  );
+}