throughline 0.13.0 → 0.14.1

package/src/resume-context.mjs

@@ -3,7 +3,7 @@
  *
  * 呼び出し元:
  *   - handoff-executor.mjs（最初のUserPromptSubmitでauto path / baton path共通注入）
- *   - claude-auto-handoff.mjs（自動圧縮の直後のSessionStartで同じ会話へ注入。ADR 0032）
+ *   - handoff-executor.mjs（前任が自動継続で引き継いだ会話の、最初のUserPromptSubmit。ADR 0033）
  *
  * 設計 (docs/02_clear_auto_handoff_plan.md):
  *   - 予算付き注入: ヘッダ + 現在地アンカー + pull案内を固定部とし、残りへ
@@ -58,25 +58,29 @@ const NORMAL_HEADER = '## Throughline: セッション記憶';
 
 const DEFAULT_ANCHOR_TITLE = '### 現在地 (直前のやりとり)';
 
-// 自動圧縮の直後に、同じ会話へ注入する時のヘッダ (ADR 0032)。/clear の引き継ぎと違い、
-// 作業の途中で、次のユーザー入力は来ない。宣言はさせず、そのまま続けさせる。
-const COMPACT_HEADER =
-  `## Throughline: 自動圧縮後の継続用コンテキスト\n` +
+// 自動継続で立てた新しい会話へ注入する時のヘッダ (ADR 0033)。/clear の引き継ぎと違い、
+// 前の会話は作業の途中で止めてあり、次のユーザー入力は来ない。宣言はさせず、そのまま続けさせる。
+const AUTO_CONTINUATION_HEADER = (projectPath) =>
+  `## Throughline: 自動継続の文脈\n` +
+  (projectPath ? `作業ディレクトリ: ${projectPath}\n` : '') +
   `\n` +
   `**読み方 (重要):**\n` +
-  `- この会話は、たった今 Claude Code の自動圧縮で要約に置き換わりました。下記は Throughline が` +
-  `圧縮の前に保存した **あなた自身とユーザーの会話の原文** です。\n` +
-  `- 圧縮の要約と下記の記録が食い違う時は、下記の記録（元のユーザーの依頼・合意）を正としてください。\n` +
-  `- 「現在地」のターンは **作業の途中** です。ユーザーの追加入力を待たず、未完了の作業をそのまま続けてください。\n` +
-  `- 完了済みの操作を繰り返さないでください。直前の実行結果が分からない時は、作業ツリーや記録を確かめてから続けてください。\n` +
-  '- **完了したターンの詳細**: **`Bash` ツールで `throughline detail HH:MM:SS` を実行** ' +
-  `(該当ターンの本文＋詳細を stdout に返します)`;
-
-const COMPACT_ANCHOR_TITLE = '### 現在地 (作業途中のターン)';
-// 作業途中のターンは Stop の前で、まだ bodies に無い。依頼の原文を残せる場所はここだけなので、
-// /clear のアンカー (600 字) より厚く取る。
-const IN_FLIGHT_USER_MAX_CHARS = 4_000;
+  `- 前の会話は文脈の上限に近づいたため、Throughline が自動圧縮の前に止めて、この新しい会話へ引き継ぎました。` +
+  `下記は、前の会話で **あなた自身とユーザーが交わした会話の原文** です。\n` +
+  `- 「現在地」のターンは **作業の途中で止めたもの** です。ユーザーの追加入力を待たず、未完了の作業をそのまま続けてください。\n` +
+  `- 「ここまでにしたこと」と「直前の対話」に載っている操作は **完了しています**。繰り返さないでください。` +
+  `未実行なのは「実行されなかった道具」だけです。そこから続けてください。\n` +
+  `- 直前の実行結果が分からない時は、作業ツリーや詳細を確かめてから続けてください。\n` +
+  '- **各ターンの詳細**（止めたターンを含む）: **`Bash` ツールで `throughline detail HH:MM:SS` を実行** ' +
+  `(該当ターンの本文＋道具の入出力を stdout に返します)`;
+
+const AUTO_CONTINUATION_ANCHOR_TITLE = '### 現在地 (作業の途中で止めたターン)';
+// 止めたターンは現在地にだけ載せ、L2 の一覧からは外す（同じ依頼を二度載せない）。
+// /clear のアンカー (600 字) より厚く取る。3つの上限を足しても、ヘッダと案内を合わせて予算に収まる。
+const IN_FLIGHT_USER_MAX_CHARS = 3_500;
 const IN_FLIGHT_ASSISTANT_MAX_CHARS = 1_500;
+// 止めたターンでここまでにしたこと（発言と道具の呼び出し）。新しい側から、入るだけ載せる。
+const IN_FLIGHT_STEPS_MAX_CHARS = 2_400;
 
 // v0.10.12以前にThroughline自身がassistantへ付与させていた宣言行。
 // 製品由来のメタ情報だけを引き継ぎ材料から除き、会話本文への模倣連鎖を止める。
@@ -500,7 +504,8 @@ function renderBudgetedSections(db, sections, { sessionId, excludeOriginId, maxC
   const older = loadOlderTurnStats(db, {
     sessionId,
     excludeOriginId,
-    windowKeys: new Set(turns.map((t) => t.turnKey)),
+    // 現在地にだけ載せたターン（自動継続の止めたターン）は、窓の外の古いターンに数えない。
+    windowKeys: new Set([...turns.map((t) => t.turnKey), ...(sections.anchorTurnKeys ?? [])]),
   });
 
   const guidanceLines = buildGuidanceLines({
@@ -549,60 +554,123 @@ function truncateInFlight(text, maxChars) {
 }
 
 /**
- * 自動圧縮の直後に、同じ会話へ注入するテキスト (ADR 0032)。
+ * 止めたターンでここまでにしたことを、現在地の行にする。
+ * 新しい側から予算に入るだけ載せ、載せなかった古い側は件数だけを1行にまとめる。
+ * @returns {{lines: string[], shownTexts: Set<string>}}
+ */
+function renderInFlightSteps(inFlight, detailClock) {
+  const steps = [...(inFlight.steps ?? [])];
+  const earlier = inFlight.earlier_steps ?? null;
+  // 一覧の最後が止める直前の発言で、1行に詰めると元の文と変わる（改行がある・長い）時は、
+  // 一覧から外して、下の「止める直前のあなたの発言」に全文で載せる。
+  const last = steps.at(-1);
+  const lastFragment = inFlight.last_fragment;
+  if (last?.kind === 'text' && lastFragment && last.timestamp === lastFragment.timestamp &&
+      last.content !== lastFragment.content.trim()) {
+    steps.pop();
+  }
+  if (steps.length === 0 && !earlier) return { lines: [], shownTexts: new Set() };
+
+  const rendered = steps.map((step) =>
+    step.kind === 'text'
+      ? `- 発言: ${step.content}`
+      : `- 道具: ${step.name}${step.target ? ` ${step.target}` : ''}${step.failed ? ' → 失敗' : ''}`,
+  );
+  let budget = IN_FLIGHT_STEPS_MAX_CHARS;
+  let first = rendered.length;
+  while (first > 0 && budget - (rendered[first - 1].length + 1) >= 0) {
+    first -= 1;
+    budget -= rendered[first].length + 1;
+  }
+  const omitted = steps.slice(0, first);
+  const omittedTexts = (earlier?.texts ?? 0) + omitted.filter((step) => step.kind === 'text').length;
+  const omittedTools =
+    Object.values(earlier?.tools ?? {}).reduce((sum, count) => sum + count, 0) +
+    omitted.filter((step) => step.kind === 'tool').length;
+
+  const lines = [
+    `**このターンでここまでにしたこと**（古い順。どれも完了済み` +
+      (detailClock ? `。道具の入出力の全文: \`throughline detail ${detailClock}\`` : '') +
+      `）:`,
+  ];
+  if (omittedTexts + omittedTools > 0) {
+    lines.push(`- （これより前に、発言 ${omittedTexts} 件・道具 ${omittedTools} 回）`);
+  }
+  lines.push(...rendered.slice(first));
+  return {
+    lines,
+    shownTexts: new Set(steps.slice(first).filter((step) => step.kind === 'text').map((step) => step.content)),
+  };
+}
+
+/**
+ * 自動継続で立てた新しい会話へ注入するテキスト (ADR 0033)。
  *
  * 構成は /clear の引き継ぎと同じ予算付き（ヘッダ + 現在地 + 案内 + 入るだけの L2）。違いは現在地で、
- * DB の最新ターンではなく、transcript から読んだ作業途中のターンを載せる。作業途中のターンは
- * Stop の前で bodies に無いので、L2 セクションには出ない。
- *
- * 完了したターンが 1 つも無い会話（最初のターンの途中で圧縮）でも、現在地だけを返す。
+ * DB の最新ターンではなく、止めた時点に記録した作業途中のターンを載せる。依頼、ここまでにしたこと
+ * （発言と道具の呼び出し）、止める直前の発言、実行されなかった道具の順。止めたターンは L2 の一覧から外す。
  *
  * @param {import('node:sqlite').DatabaseSync} db
  * @param {{
- *   sessionId: string,
+ *   sessionId: string,  合流を終えた後継の session id
  *   inFlight: {
  *     user: {content: string, timestamp: number|null},
- *     fragments: Array<{content: string, timestamp: number|null}>,
+ *     last_fragment: {content: string, timestamp: number|null} | null,
+ *     steps?: Array<{kind: 'text', content: string, timestamp: number|null} | {kind: 'tool', name: string, target: string, failed: boolean}>,
+ *     earlier_steps?: {texts: number, tools: Record<string, number>} | null,
+ *     stopped_tools?: Array<{name: string, target: string}>,
+ *     stopped_tools_total?: number,
+ *     turn?: {origin_session_id: string, turn_number: number, user_at: number, assistant_at: number|null} | null,
  *   } | null,
- *   inFlightUnreadable?: boolean,  transcript に今の依頼がまだ書かれていない（hook の prompt_id と合わない）
+ *   projectPath?: string | null,  前の会話の作業ディレクトリ。依頼の中の相対的な場所の基準として渡す
  *   maxChars?: number,
  * }} params
  */
-export function buildCompactContinuationContext(
+export function buildAutoContinuationContext(
   db,
-  { sessionId, inFlight, inFlightUnreadable = false, maxChars = INJECTION_BUDGET_CHARS },
+  { 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 = [];
+  const turn = inFlight?.turn ?? null;
+  const turnKey = turn ? `${turn.origin_session_id}\x00${turn.turn_number}` : null;
   if (inFlight) {
     anchorLines.push(
       `**作業中のユーザー依頼**${stamp(inFlight.user.timestamp)}: ` +
         truncateInFlight(inFlight.user.content, IN_FLIGHT_USER_MAX_CHARS),
     );
-    const lastFragment = inFlight.fragments.at(-1);
-    if (lastFragment) {
+    const steps = renderInFlightSteps(inFlight, turn ? formatClock(turn.assistant_at ?? turn.user_at) : null);
+    anchorLines.push(...steps.lines);
+    // 一覧に同じ文がそのまま載っている時は、重ねて載せない。改行のある発言や長い発言は、ここに全文を載せる。
+    if (inFlight.last_fragment && !steps.shownTexts.has(inFlight.last_fragment.content.trim())) {
       anchorLines.push(
-        `**圧縮直前のあなたの発言**${stamp(lastFragment.timestamp)}: ` +
-          truncateInFlight(lastFragment.content, IN_FLIGHT_ASSISTANT_MAX_CHARS),
+        `**止める直前のあなたの発言**${stamp(inFlight.last_fragment.timestamp)}: ` +
+          truncateInFlight(inFlight.last_fragment.content, IN_FLIGHT_ASSISTANT_MAX_CHARS),
+      );
+    }
+    const stoppedTools = inFlight.stopped_tools ?? [];
+    if (stoppedTools.length > 0) {
+      const more = (inFlight.stopped_tools_total ?? stoppedTools.length) - stoppedTools.length;
+      anchorLines.push(
+        `**止める直前に呼ぼうとして、実行されなかった道具**: ` +
+          stoppedTools.map((tool) => `${tool.name}${tool.target ? ` ${tool.target}` : ''}`).join('、') +
+          (more > 0 ? `（ほか ${more} 件）` : ''),
       );
     }
-  }
-  if (!inFlight && inFlightUnreadable) {
-    anchorLines.push(
-      '**作業中のユーザー依頼**: （記録からまだ読めません。圧縮後の文脈にある最新のユーザー依頼を続けてください）',
-    );
   }
   if (!stored && anchorLines.length === 0) return null;
 
   return renderBudgetedSections(
     db,
     {
-      header: COMPACT_HEADER,
-      anchorTitle: COMPACT_ANCHOR_TITLE,
+      header: AUTO_CONTINUATION_HEADER(projectPath),
+      anchorTitle: AUTO_CONTINUATION_ANCHOR_TITLE,
       anchorLines,
+      anchorTurnKeys: turnKey ? [turnKey] : [],
       l1Lines: [],
-      l2Lines: stored?.l2Lines ?? [],
+      // 止めたターンは現在地に載せた。L2 の一覧には、それより前のターンだけを載せる。
+      l2Lines: (stored?.l2Lines ?? []).filter((line) => line.turnKey !== turnKey),
     },
     { sessionId, excludeOriginId: null, maxChars },
   );

package/src/resume-context.test.mjs

@@ -4,7 +4,7 @@ import { DatabaseSync } from 'node:sqlite';
 import {
   buildResumeContext,
   buildBudgetedResumeContext,
-  buildCompactContinuationContext,
+  buildAutoContinuationContext,
   INJECTION_BUDGET_CHARS,
 } from './resume-context.mjs';
 
@@ -907,58 +907,59 @@ test('budgeted: header and anchor always survive even under pressure', () => {
   assert.ok(budgeted.text.includes('### 現在地 (直前のやりとり)'));
 });
 
-// --- 自動圧縮後の継続 (ADR 0032) ---
+// --- 自動継続で立てた新しい会話への注入 (ADR 0033) ---
 
-test('buildCompactContinuationContext: 完了したターンが無くても、作業途中のターンだけで組み立てる', () => {
+test('buildAutoContinuationContext: 保存済みのターンが無くても、止めた時点の依頼だけで組み立てる', () => {
   const db = makeDb();
-  const result = buildCompactContinuationContext(db, {
+  const result = buildAutoContinuationContext(db, {
     sessionId: 'S',
-    inFlight: { user: { content: '最初の依頼', timestamp: null }, fragments: [] },
+    inFlight: { user: { content: '最初の依頼', timestamp: null }, last_fragment: null },
   });
-  assert.match(result.text, /^## Throughline: 自動圧縮後の継続用コンテキスト\n/);
-  assert.match(result.text, /### 現在地 \(作業途中のターン\)\n\*\*作業中のユーザー依頼\*\*: 最初の依頼\n/);
-  assert.doesNotMatch(result.text, /圧縮直前のあなたの発言/);
+  assert.match(result.text, /^## Throughline: 自動継続の文脈\n/);
+  assert.match(result.text, /### 現在地 \(作業の途中で止めたターン\)\n\*\*作業中のユーザー依頼\*\*: 最初の依頼\n/);
+  assert.doesNotMatch(result.text, /止める直前のあなたの発言/);
   assert.doesNotMatch(result.text, /### 直前の対話/);
   assert.equal(result.injectedL2Turns, 0);
-  assert.equal(buildCompactContinuationContext(db, { sessionId: 'S', inFlight: null }), null);
+  assert.equal(buildAutoContinuationContext(db, { sessionId: 'S', inFlight: null }), null);
 });
 
-test('buildCompactContinuationContext: 現在地は作業途中のターンで、保存済みのターンはL2に並び、宣言は求めない', () => {
+test('buildAutoContinuationContext: 現在地は止めた時点のターンで、保存済みのターンはL2に並び、宣言は求めない', () => {
   const db = makeDb();
-  insertBody(db, { session: 'S', origin: 'S', turn: 1, role: 'user', text: '前の依頼', createdAt: 1_000 });
-  insertBody(db, { session: 'S', origin: 'S', turn: 1, role: 'assistant', text: '前の回答', createdAt: 2_000 });
-  const result = buildCompactContinuationContext(db, {
+  insertBody(db, { session: 'S', origin: 'P', turn: 1, role: 'user', text: '前の依頼', createdAt: 1_000 });
+  insertBody(db, { session: 'S', origin: 'P', turn: 1, role: 'assistant', text: '前の回答', createdAt: 2_000 });
+  const result = buildAutoContinuationContext(db, {
     sessionId: 'S',
     inFlight: {
       user: { content: '今の依頼', timestamp: 3_000 },
-      fragments: [{ content: '途中1', timestamp: 4_000 }, { content: '途中2', timestamp: 5_000 }],
+      last_fragment: { content: '途中2', timestamp: 5_000 },
     },
   });
   const anchor = result.text.slice(result.text.indexOf('### 現在地'), result.text.indexOf('### さらに前の記憶'));
-  assert.match(anchor, /\*\*作業中のユーザー依頼\*\* \[\d\d:\d\d:\d\d\]: 今の依頼\n\*\*圧縮直前のあなたの発言\*\* \[\d\d:\d\d:\d\d\]: 途中2\n/);
-  assert.doesNotMatch(anchor, /前の依頼|途中1/);
+  assert.match(anchor, /\*\*作業中のユーザー依頼\*\* \[\d\d:\d\d:\d\d\]: 今の依頼\n\*\*止める直前のあなたの発言\*\* \[\d\d:\d\d:\d\d\]: 途中2\n/);
+  assert.doesNotMatch(anchor, /前の依頼/);
   assert.match(result.text, /### 直前の対話 \(L2 \/ active work thread, 古い順\)\n\[\d\d:\d\d:\d\d\] \[user\]: 前の依頼\n\[\d\d:\d\d:\d\d\] \[assistant\]: 前の回答/);
-  assert.doesNotMatch(result.text, /宣言|\/clear/);
+  assert.doesNotMatch(result.text, /宣言|\/clear|圧縮の要約/);
+  assert.match(result.text, /未実行なのは「実行されなかった道具」だけです/);
   assert.equal(result.injectedL2Turns, 1);
 });
 
-test('buildCompactContinuationContext: 長い依頼と多数のターンでも予算内に収め、依頼は切り詰めを明示する', () => {
+test('buildAutoContinuationContext: 長い依頼は先頭と末尾を残し、多数のターンでも予算内に収める', () => {
   const db = makeDb();
   for (let turn = 1; turn <= 12; turn++) {
-    insertBody(db, { session: 'S', origin: 'S', turn, role: 'user', text: `依頼${turn} ` + 'あ'.repeat(600), createdAt: turn * 1_000 });
-    insertBody(db, { session: 'S', origin: 'S', turn, role: 'assistant', text: `回答${turn} ` + 'い'.repeat(600), createdAt: turn * 1_000 + 500 });
+    insertBody(db, { session: 'S', origin: 'P', turn, role: 'user', text: `依頼${turn} ` + 'あ'.repeat(600), createdAt: turn * 1_000 });
+    insertBody(db, { session: 'S', origin: 'P', turn, role: 'assistant', text: `回答${turn} ` + 'い'.repeat(600), createdAt: turn * 1_000 + 500 });
   }
-  const result = buildCompactContinuationContext(db, {
+  const result = buildAutoContinuationContext(db, {
     sessionId: 'S',
     inFlight: {
-      user: { content: 'ヰ'.repeat(6_000), timestamp: 20_000 },
-      fragments: [{ content: 'ヱ'.repeat(3_000), timestamp: 21_000 }],
+      user: { content: '先頭の指示' + 'ヰ'.repeat(6_000) + '末尾の指示', timestamp: 20_000 },
+      last_fragment: { content: 'ヱ'.repeat(3_000), timestamp: 21_000 },
     },
   });
   assert.ok(result.totalChars <= INJECTION_BUDGET_CHARS, `${result.totalChars}`);
-  assert.equal((result.text.match(/ヰ/g) ?? []).length, 4_000);
+  assert.match(result.text, /\*\*作業中のユーザー依頼\*\* \[\d\d:\d\d:\d\d\]: 先頭の指示ヰ+ …\(長いため中略 2510 字\)… ヰ+末尾の指示\n/);
+  assert.equal((result.text.match(/ヰ/g) ?? []).length, 3_490);
   assert.equal((result.text.match(/ヱ/g) ?? []).length, 1_500);
-  assert.match(result.text, /ヰ …\(長いため中略 2000 字\)… ヰ/);
   assert.match(result.text, /ヱ …\(長いため中略 1500 字\)… ヱ/);
   assert.ok(result.injectedL2Turns >= 1, '最新の保存済みターンは入る');
   assert.match(result.text, /回答12/);
@@ -966,14 +967,70 @@ test('buildCompactContinuationContext: 長い依頼と多数のターンでも
   assert.match(result.text, /throughline recall --l2 --session S /);
 });
 
-test('buildCompactContinuationContext: 長い依頼は先頭と末尾を残す。今の依頼が記録から読めない時は、その旨だけを現在地に書く', () => {
+test('buildAutoContinuationContext: 止めたターンでここまでにしたことと、実行されなかった道具を現在地に載せ、そのターンをL2に重ねない', () => {
   const db = makeDb();
-  const long = buildCompactContinuationContext(db, {
+  insertBody(db, { session: 'S', origin: 'P0', turn: 1, role: 'user', text: '前の依頼', createdAt: 1_000 });
+  insertBody(db, { session: 'S', origin: 'P0', turn: 1, role: 'assistant', text: '前の回答', createdAt: 2_000 });
+  // worker が取り込んだ止めたターン（発言を全部つないだ本文）
+  insertBody(db, { session: 'S', origin: 'P', turn: 7, role: 'user', text: '今の依頼', createdAt: 3_000 });
+  insertBody(db, { session: 'S', origin: 'P', turn: 7, role: 'assistant', text: 'a を直しました。\n\nb を読みます。', createdAt: 5_000 });
+  const result = buildAutoContinuationContext(db, {
     sessionId: 'S',
-    inFlight: { user: { content: '先頭の指示' + 'あ'.repeat(6_000) + '末尾の指示', timestamp: null }, fragments: [] },
+    inFlight: {
+      user: { content: '今の依頼', timestamp: 3_000 },
+      last_fragment: { content: 'b を読みます。', timestamp: 5_000 },
+      steps: [
+        { kind: 'tool', name: 'Edit', target: '/work/a.mjs', failed: false },
+        { kind: 'tool', name: 'Bash', target: 'npm test', failed: true },
+        { kind: 'text', content: 'a を直しました。', timestamp: 4_000 },
+        { kind: 'text', content: 'b を読みます。', timestamp: 5_000 },
+      ],
+      earlier_steps: null,
+      stopped_tools: [{ name: 'Read', target: '/work/b.mjs' }, { name: 'Read', target: '/work/c.mjs' }],
+      stopped_tools_total: 3,
+      turn: { origin_session_id: 'P', turn_number: 7, user_at: 3_000, assistant_at: 5_000 },
+    },
   });
-  assert.match(long.text, /\*\*作業中のユーザー依頼\*\*: 先頭の指示あ+ …\(長いため中略 2010 字\)… あ+末尾の指示\n/);
+  const anchor = result.text.slice(result.text.indexOf('### 現在地'), result.text.indexOf('### さらに前の記憶'));
+  assert.match(anchor, new RegExp(
+    '\\*\\*作業中のユーザー依頼\\*\\* \\[\\d\\d:\\d\\d:\\d\\d\\]: 今の依頼\\n' +
+    '\\*\\*このターンでここまでにしたこと\\*\\*（古い順。どれも完了済み。道具の入出力の全文: `throughline detail \\d\\d:\\d\\d:\\d\\d`）:\\n' +
+    '- 道具: Edit /work/a\\.mjs\\n- 道具: Bash npm test → 失敗\\n- 発言: a を直しました。\\n- 発言: b を読みます。\\n' +
+    '\\*\\*止める直前に呼ぼうとして、実行されなかった道具\\*\\*: Read /work/b\\.mjs、Read /work/c\\.mjs（ほか 1 件）\\n'));
+  assert.doesNotMatch(anchor, /止める直前のあなたの発言/, '一覧に同じ文が載っている発言は重ねない');
+  const l2 = result.text.slice(result.text.indexOf('### 直前の対話'));
+  assert.match(l2, /\[user\]: 前の依頼\n\[\d\d:\d\d:\d\d\] \[assistant\]: 前の回答/);
+  assert.doesNotMatch(l2, /今の依頼|a を直しました/, '止めたターンは現在地だけに載せる');
+  assert.equal(result.injectedL2Turns, 1);
+  assert.equal(result.olderTurns, 0, '止めたターンを、窓の外の古いターンに数えない');
+});
 
-  const unreadable = buildCompactContinuationContext(db, { sessionId: 'S', inFlight: null, inFlightUnreadable: true });
-  assert.match(unreadable.text, /### 現在地 \(作業途中のターン\)\n\*\*作業中のユーザー依頼\*\*: （記録からまだ読めません。圧縮後の文脈にある最新のユーザー依頼を続けてください）\n/);
+test('buildAutoContinuationContext: 改行のある直前の発言は全文を載せ、多い手順は新しい側から入るだけ載せて残りは件数にする', () => {
+  const db = makeDb();
+  const steps = [];
+  for (let n = 1; n <= 80; n++) {
+    steps.push({ kind: 'tool', name: 'Read', target: `/work/file-${String(n).padStart(3, '0')}-${'x'.repeat(40)}.mjs`, failed: false });
+  }
+  steps.push({ kind: 'text', content: '方針: 1. 型を直す 2. 試験を足す', timestamp: 9_000 });
+  const result = buildAutoContinuationContext(db, {
+    sessionId: 'S',
+    inFlight: {
+      user: { content: '大きな依頼', timestamp: 1_000 },
+      last_fragment: { content: '方針:\n1. 型を直す\n2. 試験を足す', timestamp: 9_000 },
+      steps,
+      earlier_steps: { texts: 4, tools: { Read: 30, Edit: 6 } },
+      stopped_tools: [{ name: 'Edit', target: '/work/types.mjs' }],
+      stopped_tools_total: 1,
+      turn: null,
+    },
+  });
+  assert.ok(result.totalChars <= INJECTION_BUDGET_CHARS, `${result.totalChars}`);
+  assert.match(result.text, /\*\*このターンでここまでにしたこと\*\*（古い順。どれも完了済み）:\n- （これより前に、発言 4 件・道具 (\d+) 回）\n- 道具: Read /);
+  const omittedTools = Number(/これより前に、発言 4 件・道具 (\d+) 回/.exec(result.text)[1]);
+  const shownTools = (result.text.match(/^- 道具: Read /gm) ?? []).length;
+  assert.equal(omittedTools + shownTools, 36 + 80, '載せた分と件数にした分で全部');
+  assert.ok(shownTools >= 20 && shownTools < 80, `${shownTools}`);
+  assert.doesNotMatch(result.text, /- 発言: 方針/, '下に全文を載せる発言は、一覧に重ねない');
+  assert.match(result.text, /- 道具: Read \/work\/file-080-x+\.mjs\n\*\*止める直前のあなたの発言\*\* \[\d\d:\d\d:\d\d\]: 方針:\n1\. 型を直す\n2\. 試験を足す\n\*\*止める直前に呼ぼうとして、実行されなかった道具\*\*: Edit \/work\/types\.mjs\n/);
 });
+

package/src/runtime-error-store.mjs

@@ -47,12 +47,17 @@ const DEFINITIONS = Object.freeze({
     severity: 'high',
     template: 'Throughline Claude Stop hook processing failed',
   }),
-  // 自動継続の印を残せなかった。圧縮と作業は続く（ADR 0032）。
+  // 自動継続の hook が失敗した。圧縮も道具も止まらず、作業は続く（ADR 0033）。
   HOOK_PRE_COMPACT_FAILED: Object.freeze({
     component: 'claude_pre_compact_hook',
     severity: 'warn',
     template: 'Throughline Claude PreCompact hook processing failed',
   }),
+  HOOK_PRE_TOOL_USE_FAILED: Object.freeze({
+    component: 'claude_pre_tool_use_hook',
+    severity: 'warn',
+    template: 'Throughline Claude PreToolUse hook processing failed',
+  }),
   HOOK_CODEX_FAILED: Object.freeze({
     component: 'codex_hook',
     severity: 'high',

package/src/session-start.mjs

@@ -22,11 +22,11 @@
  *   バトンの消費・merge・注入は最初の UserPromptSubmit (= 実体の証明) で行う。
  *   幽霊はプロンプトを発火しないため記憶を奪えない。
  *
- * 【自動圧縮後の継続】 ADR 0032
+ * 【自動継続の後継】 ADR 0033
  *
- *   source='compact' は新しい会話ではなく、圧縮を終えた同じ会話。PreCompact hook が
- *   自動圧縮の印を残していた時だけ、作業途中のターンと直近の会話の原文を stdout へ書く。
- *   host がそのまま作業を続けるので、次の UserPromptSubmit は待たない。
+ *   同じ project で後継の立ち上げ中の引き継ぎがある時だけ、この会話の受け口（inbox socket）を
+ *   控える。worker がそれを読んで、継続の指示を1通送る。記憶の注入は、その指示が届いた時の
+ *   UserPromptSubmit（上の二相ハンドオフの第二相）が行う。
  */
 
 import { getDb } from './db.mjs';
@@ -41,7 +41,7 @@ import { recordRuntimeErrorBestEffort } from './runtime-error-store.mjs';
 import { logHookFailure } from './hook-failure-log.mjs';
 import { CLAUDE_HOST, hostAdapterForSessionId, hostOfSessionId, NON_CLAUDE_SESSION_PREFIXES, parseHookPayload } from './hosts/index.mjs';
 import { executeFirstPromptHandoff } from './handoff-executor.mjs';
-import { consumeClaudeCompactRequest, buildClaudeCompactContinuation } from './claude-auto-handoff.mjs';
+import { recordClaudeSuccessorTarget } from './claude-auto-handoff.mjs';
 
 const ENV_DISABLE_AUTO_HANDOFF = 'THROUGHLINE_DISABLE_AUTO_HANDOFF';
 
@@ -170,29 +170,9 @@ export async function run() {
     pending_registered: true,
   });
 
-  // 自動圧縮の直後: 印があれば、圧縮前の記録を同じ会話へ注入する (ADR 0032)。
-  // subagent の中で走った hook は、親の会話の印を消費しない。
-  if (source === 'compact' && hostOfSessionId(session_id) === CLAUDE_HOST && !payload.agent_id) {
-    const request = consumeClaudeCompactRequest({ sessionId: session_id });
-    if (request) {
-      const continuation = buildClaudeCompactContinuation(db, {
-        sessionId: session_id,
-        transcriptPath: transcript_path ?? request.transcript_path,
-        promptId: payload.prompt_id ?? null,
-        now,
-      });
-      if (continuation) process.stdout.write(continuation.text + '\n');
-      logDecision({
-        ts: new Date(now).toISOString(),
-        phase: 'compact-continuation',
-        session_id,
-        project_path: request.project_path,
-        transcript_path: transcript_path ?? request.transcript_path ?? null,
-        requested_at: new Date(request.requested_at).toISOString(),
-        injected: Boolean(continuation),
-        ...(continuation?.stats ?? {}),
-      });
-    }
+  // 自動継続の後継として立ち上がった会話なら、worker が指示を送れるように受け口を控える (ADR 0033)。
+  if (hostOfSessionId(session_id) === CLAUDE_HOST) {
+    recordClaudeSuccessorTarget({ payload, env: process.env, now });
   }
 
   // Cursor は beforeSubmitPrompt が additional_context を持たない。

package/src/transcript-reader.mjs

@@ -10,7 +10,7 @@
 
 import { readFileSync, existsSync } from 'fs';
 import { DETAIL_KIND } from './constants.mjs';
-import { compactClaudeTaskNotification } from './hosts/claude.mjs';
+import { compactClaudePeerMessage, compactClaudeTaskNotification } from './hosts/claude.mjs';
 import { classifyTurnStart } from './turn-start.mjs';
 
 function entryKind(entry) {
@@ -86,10 +86,10 @@ export function readTranscript(transcriptPath) {
     if (!role || rawContent == null) continue;
 
     const extracted = extractText(rawContent);
-    // user 発言には端末の生出力 (貼り付け・Claude の task 通知) が入る。記憶には
-    // 制御文字を落とした本文だけを残す。
+    // user 発言には端末の生出力 (貼り付け・Claude の task 通知) や、別の会話から届いた発言の
+    // 定型の注意書きが入る。記憶には制御文字と定型文を落とした本文だけを残す。
     const text = role === 'user'
-      ? normalizeTerminalText(compactClaudeTaskNotification(extracted))
+      ? normalizeTerminalText(compactClaudePeerMessage(compactClaudeTaskNotification(extracted)))
       : extracted;
     if (!text) continue;
 
@@ -387,6 +387,28 @@ export function sliceCurrentTurnEntries(entries) {
   return entries.slice(userTextIdx, lastAssistantTextIdx + 1);
 }
 
+/**
+ * 作業途中で止めたターンのエントリ範囲 (ADR 0033)。最後の user 本文の行から、transcript の末尾まで。
+ *
+ * sliceCurrentTurnEntries は最後の assistant 本文で切るので、その後に呼んだ道具が入らない。
+ * hook で止めたターンは、止めた道具の呼び出しと結果が末尾に並ぶ。それも同じターンとして返す。
+ *
+ * @param {Array<object>} entries readRawEntries の結果
+ * @returns {Array<object>}
+ */
+export function sliceInFlightTurnEntries(entries) {
+  for (let i = entries.length - 1; i >= 0; i--) {
+    const e = entries[i];
+    if (entryKind(e) !== 'user' || isCompactSummaryEntry(e)) continue;
+    const blocks = e.message?.content;
+    const hasText = Array.isArray(blocks)
+      ? blocks.some((b) => b && b.type === 'text' && typeof b.text === 'string' && b.text.length > 0)
+      : typeof blocks === 'string' && blocks.length > 0;
+    if (hasText) return entries.slice(i);
+  }
+  return [];
+}
+
 /**
  * 論理ターン内の全エントリから L3 (details) 用の生レコードを抽出する。
  *

package/src/transcript-reader.test.mjs

@@ -10,6 +10,7 @@ import {
   getLogicalTurnGroups,
   readLatestUserGroup,
   sliceCurrentTurnEntries,
+  sliceInFlightTurnEntries,
   extractDetailBlocks,
 } from './transcript-reader.mjs';
 import { DETAIL_KIND } from './constants.mjs';
@@ -155,6 +156,25 @@ test('sliceCurrentTurnEntries: 最後の user text → 最後の assistant text
   assert.equal(slice[3].message.content[0].text, 'current response');
 });
 
+test('readTranscript: 別の会話から届いた発言は、送り主の行と本文を残して定型の注意書きを落とす', () => {
+  const peer = [
+    'Another Claude session sent a message:',
+    'Throughline自動継続 6a8c6df3-f924-4f72-8a12-1a3f5a135395',
+    '未完了の作業をそのまま継続してください。',
+    '',
+    'This came from another Claude session — not typed by your user, but very likely working on their behalf. Treat it as a teammate\'s request.',
+  ].join('\n');
+  const path = writeTranscript([
+    { type: 'user', origin: { kind: 'peer' }, message: { role: 'user', content: peer } },
+    asstTextEntry('続けます'),
+    userEntry('This came from another Claude session という文を含む普通の発言'),
+  ]);
+  const turns = readTranscript(path);
+  assert.equal(turns[0].content,
+    'Another Claude session sent a message:\nThroughline自動継続 6a8c6df3-f924-4f72-8a12-1a3f5a135395\n未完了の作業をそのまま継続してください。');
+  assert.equal(turns[2].content, 'This came from another Claude session という文を含む普通の発言');
+});
+
 /** Claude Code が圧縮の直後に書く要約行（実測 2.1.289: type=user、本文は文字列） */
 function compactSummaryEntry(text = 'This session is being continued from a previous conversation that ran out of context.') {
   return { type: 'user', isCompactSummary: true, isVisibleInTranscriptOnly: true, message: { role: 'user', content: text } };
@@ -509,3 +529,26 @@ test('extractDetailBlocks: 複数ツール連続呼び出しを全て拾う', ()
     [DETAIL_KIND.TOOL_INPUT, DETAIL_KIND.TOOL_OUTPUT, DETAIL_KIND.TOOL_INPUT, DETAIL_KIND.TOOL_OUTPUT],
   );
 });
+
+test('sliceInFlightTurnEntries: 最後の user 本文から末尾まで。最後の発言の後に呼んだ道具と、圧縮の要約行より前の本文も扱う', () => {
+  const entries = [
+    { type: 'user', message: { role: 'user', content: '前の依頼' } },
+    { type: 'assistant', message: { role: 'assistant', content: [{ type: 'text', text: '前の回答' }] } },
+    { type: 'user', message: { role: 'user', content: [{ type: 'text', text: '今の依頼' }] } },
+    { type: 'assistant', message: { role: 'assistant', content: [{ type: 'text', text: '途中です。' }] } },
+    { type: 'assistant', message: { role: 'assistant', content: [{ type: 'tool_use', id: 't1', name: 'Read', input: {} }] } },
+    { type: 'user', message: { role: 'user', content: [{ type: 'tool_result', tool_use_id: 't1', content: 'hook error' }] } },
+    { type: 'attachment', attachment: { type: 'hook_stopped_continuation' } },
+  ];
+  const slice = sliceInFlightTurnEntries(entries);
+  assert.equal(slice.length, 5);
+  assert.equal(slice[0].message.content[0].text, '今の依頼');
+  assert.equal(sliceCurrentTurnEntries(entries).length, 2, '完了したターン用の切り出しは、最後の発言で終わる');
+  assert.deepEqual(extractDetailBlocks(slice).map((d) => d.source_id), ['t1', 't1:result', null]);
+
+  // 圧縮の要約行はターンの始まりにしない
+  const summary = { type: 'user', isCompactSummary: true, message: { role: 'user', content: '要約…' } };
+  assert.equal(sliceInFlightTurnEntries([entries[2], entries[3], summary, entries[4]]).length, 4);
+  assert.deepEqual(sliceInFlightTurnEntries([entries[1]]), []);
+});
+