throughline 0.12.8 → 0.13.0

package/src/cli/install.mjs

@@ -36,6 +36,7 @@ const SC_COMMANDS = [
   'throughline process-turn',
   'throughline session-start',
   'throughline prompt-submit',
+  'throughline pre-compact',
   // 旧コマンド（アンインストール時に除去する）
   'throughline inject-context',
   'throughline capture-tool',
@@ -55,8 +56,15 @@ const SC_HOOKS = {
   UserPromptSubmit: {
     hooks: [{ type: 'command', command: 'throughline prompt-submit' }],
   },
+  // 自動継続の第一段 (ADR 0032)。matcher は付けない: 手動の /compact でも呼ばれ、古い印を消す。
+  // 自動継続が無効な時は何も残さずに抜ける。
+  PreCompact: {
+    hooks: [{ type: 'command', command: 'throughline pre-compact' }],
+  },
 };
 
+const CLAUDE_PRE_COMPACT_COMMAND = SC_HOOKS.PreCompact.hooks[0].command;
+
 const CODEX_COMMANDS = [
   'throughline codex-hook stop',
   'throughline codex-hook user-prompt-submit',
@@ -629,6 +637,25 @@ 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));
+}
+
+/** `auto-handoff enable --host claude` 用。古い版で install した端末にも PreCompact hook を足す。 */
+export function installClaudeAutoHandoffHook(settingsPath = join(homedir(), '.claude', 'settings.json')) {
+  if (!claudeAutoHandoffHookRegistered(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);
+  }
+  return { settingsPath, command: CLAUDE_PRE_COMPACT_COMMAND };
+}
+
 export function installCodexAutoHandoffHook(codexHome = join(homedir(), '.codex')) {
   const hooksPath = join(codexHome, 'hooks.json');
   const configPath = join(codexHome, 'config.toml');
@@ -777,6 +804,7 @@ 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,6 +667,12 @@ 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' }] }]);
+
+    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');
   } finally {
     unsilence();
     home.restore();

package/src/db-contention.test.mjs

@@ -93,3 +93,30 @@ test('getDb reuses an existing WAL database while another process owns the write
     rmSync(home, { recursive: true, force: true });
   }
 });
+
+test('getDbは、新しいDBを複数のprocessが同時に開いても、全員が現行schemaで開ける', async () => {
+  // WindowsのCursorの会話では同じhookが2本ほぼ同時に走る。初回はどのprocessも版0を読むので、lockの外で読んだ版から
+  // 移行をやり直すと、先に進んだprocessが消した表へ触って落ちた（修理前は6本で半分ほどの確率）。
+  const rounds = 6;
+  const processes = 6;
+  for (let round = 0; round < rounds; round += 1) {
+    const home = mkdtempSync(join(tmpdir(), 'throughline-db-first-open-'));
+    const env = { ...process.env, HOME: home, USERPROFILE: home };
+    try {
+      const results = await Promise.all(Array.from({ length: processes }, () => {
+        const child = spawn(process.execPath, ['--input-type=module', '-e', `
+          import { getDb, CURRENT_VERSION } from ${JSON.stringify(DB_MODULE_URL)};
+          const db = getDb();
+          const version = db.prepare('PRAGMA user_version').get().user_version;
+          db.prepare('SELECT count(*) AS n FROM sessions').get();
+          db.close();
+          if (version !== CURRENT_VERSION) process.exit(2);
+        `], { env, stdio: ['ignore', 'ignore', 'pipe'] });
+        return waitForExit(child);
+      }));
+      assert.deepEqual(results, Array.from({ length: processes }, () => ({ code: 0, stderr: '' })));
+    } finally {
+      rmSync(home, { recursive: true, force: true });
+    }
+  }
+});

package/src/db.mjs

@@ -25,10 +25,68 @@ export function openReadOnlyDb(path = DB_PATH) {
   }
 }
 
+const WAL_SWITCH_RETRY_MS = 25;
+
+function isSqliteBusy(error) {
+  if (typeof error?.errcode === 'number') return (error.errcode & 0xff) === 5;
+  return /database is locked/u.test(String(error?.message ?? ''));
+}
+
+function sleepSync(ms) {
+  Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, ms);
+}
+
+/**
+ * journal mode を WAL にする。既に WAL なら何も書かない。
+ *
+ * WAL への切り替えは排他 lock を要り、他の process が同じ DB を開いている間は busy_timeout を待たずに
+ * `database is locked` で断られる。新しい DB を複数の hook が同時に開く時に起きるので、
+ * busy_timeout と同じ時間まで読み直す (ADR 0031)。他の process が先に切り替えれば、読み直しで WAL が見える。
+ */
+function ensureWalJournalMode(db) {
+  const deadline = Date.now() + DB_BUSY_TIMEOUT_MS;
+  for (;;) {
+    try {
+      const journalMode = db.prepare('PRAGMA journal_mode').get().journal_mode;
+      if (String(journalMode).toLowerCase() === 'wal') return;
+      db.exec('PRAGMA journal_mode = WAL');
+      return;
+    } catch (error) {
+      if (!isSqliteBusy(error) || Date.now() >= deadline) throw error;
+      sleepSync(WAL_SWITCH_RETRY_MS);
+    }
+  }
+}
+
+function readSchemaVersion(db) {
+  return db.prepare('PRAGMA user_version').get().user_version ?? 0;
+}
+
+/**
+ * schema を現行版へ上げる。現行版なら何も書かない。
+ *
+ * 移行は書き込み lock を取ってから版を読み直し、1つの transaction で終える (ADR 0031)。
+ * lock の外で読んだ版は、他の process が移行を進めた後では古い。古い版から移行をやり直すと、
+ * 途中の版で消した表（v4 の judgments）へ触って `no such table` で落ちる。
+ */
 function initSchema(db) {
-  const row = db.prepare('PRAGMA user_version').get();
-  const version = row.user_version ?? 0;
+  if (readSchemaVersion(db) >= CURRENT_VERSION) return;
+  db.exec('BEGIN IMMEDIATE');
+  try {
+    const version = readSchemaVersion(db);
+    if (version < CURRENT_VERSION) applySchemaMigrations(db, version);
+    db.exec('COMMIT');
+  } catch (error) {
+    try {
+      db.exec('ROLLBACK');
+    } catch {
+      // ignore
+    }
+    throw error;
+  }
+}
 
+function applySchemaMigrations(db, version) {
   // v0 → v1: 全テーブル作成
   if (version < 1) {
     db.exec(`
@@ -353,10 +411,7 @@ export function migrateDefaultDb() {
       };
     }
 
-    const journalMode = db.prepare('PRAGMA journal_mode').get().journal_mode;
-    if (String(journalMode).toLowerCase() !== 'wal') {
-      db.exec('PRAGMA journal_mode = WAL');
-    }
+    ensureWalJournalMode(db);
     initSchema(db);
     const afterSchemaVersion = Number(db.prepare('PRAGMA user_version').get().user_version ?? 0);
     if (afterSchemaVersion !== CURRENT_VERSION) {
@@ -397,10 +452,7 @@ export function getDb() {
   const db = new DatabaseSync(DB_PATH);
   try {
     db.exec(`PRAGMA busy_timeout = ${DB_BUSY_TIMEOUT_MS}`);
-    const journalMode = db.prepare('PRAGMA journal_mode').get().journal_mode;
-    if (String(journalMode).toLowerCase() !== 'wal') {
-      db.exec('PRAGMA journal_mode = WAL');
-    }
+    ensureWalJournalMode(db);
     db.exec('PRAGMA foreign_keys = ON');
     initSchema(db);
     _db = db;

package/src/hook-entrypoints.test.mjs

@@ -976,7 +976,9 @@ test('a failed hook leaves its reason in the local hook failure log', () => {
       ['HOOK_SESSION_START_FAILED', 'Error', 'Missing session_id in SessionStart payload'],
     ]);
     for (const entry of entries) {
-      assert.deepEqual(Object.keys(entry), ['ts', 'code', 'version', 'name', 'message']);
+      assert.deepEqual(Object.keys(entry), ['ts', 'code', 'version', 'name', 'message', 'stack']);
+      // 失敗した位置は、payloadを検査して投げたhookの入口を指す。
+      assert.match(entry.stack[0], /^at .*(turn-processor|session-start)\.mjs:\d+:\d+\)?$/);
       assert.match(entry.ts, /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}\.\d{3}Z$/);
       assert.match(entry.version, /^\d+\.\d+\.\d+$/);
     }

package/src/hook-failure-log.mjs

@@ -3,7 +3,7 @@
  *
  * runtime error store は外へ送れる形（定型 code と回数）だけを持つ (ADR 0025)。失敗した時の
  * 例外の文面はどこにも残らず、後から原因を追えなかった（2026-10-04、Mac と main-server の
- * 7〜8月の失敗）。このログは理由を端末内にだけ残す。runtime error の収集・送信の設定とは
+ * 7〜8月の失敗）。このログは理由と失敗した位置（stack の先頭）を端末内にだけ残す。runtime error の収集・送信の設定とは
  * 独立で、外へは送らない。
  * 書き込み失敗は stderr に出す（黙って握りつぶさない）。
  */
@@ -17,11 +17,23 @@ const require = createRequire(import.meta.url);
 const PACKAGE_VERSION = require('../package.json').version;
 
 export const HOOK_FAILURE_MESSAGE_LIMIT = 1000;
+export const HOOK_FAILURE_STACK_FRAMES = 6;
+export const HOOK_FAILURE_STACK_FRAME_LIMIT = 300;
 
 export function hookFailureLogPath({ home = homedir() } = {}) {
   return join(home, '.throughline', 'logs', 'hook-failures.log');
 }
 
+function stackFrames(error) {
+  if (!(error instanceof Error) || typeof error.stack !== 'string') return [];
+  return error.stack
+    .split('\n')
+    .map((line) => line.trim())
+    .filter((line) => line.startsWith('at '))
+    .slice(0, HOOK_FAILURE_STACK_FRAMES)
+    .map((line) => line.slice(0, HOOK_FAILURE_STACK_FRAME_LIMIT));
+}
+
 /**
  * @param {string} code runtime error の定型 code（例: HOOK_PROCESS_TURN_FAILED）
  * @param {unknown} error 失敗の原因
@@ -36,6 +48,10 @@ export function logHookFailure(code, error, { home, now = Date.now(), stderr = p
     name: error instanceof Error ? error.name : typeof error,
     message: message.slice(0, HOOK_FAILURE_MESSAGE_LIMIT),
   };
+  // 失敗した位置を残す。`database is locked` のような文面だけでは、DB を開く時か書く時か、
+  // どの処理で落ちたかが分からない（2026-10-04、Windows の SessionStart と UserPromptSubmit の失敗）。
+  const frames = stackFrames(error);
+  if (frames.length > 0) entry.stack = frames;
   // どの会話の失敗かを残す（errorが `hookContext` を持つ時）。回数と文面だけでは、失敗した会話を
   // 端末の他の記録から探すことになる。
   const context = error?.hookContext;

package/src/hook-failure-log.test.mjs

@@ -3,7 +3,13 @@ import assert from 'node:assert/strict';
 import { mkdtempSync, readFileSync, rmSync, writeFileSync } from 'node:fs';
 import { tmpdir } from 'node:os';
 import { join } from 'node:path';
-import { HOOK_FAILURE_MESSAGE_LIMIT, hookFailureLogPath, logHookFailure } from './hook-failure-log.mjs';
+import {
+  HOOK_FAILURE_MESSAGE_LIMIT,
+  HOOK_FAILURE_STACK_FRAMES,
+  HOOK_FAILURE_STACK_FRAME_LIMIT,
+  hookFailureLogPath,
+  logHookFailure,
+} from './hook-failure-log.mjs';
 
 test('logHookFailureは、失敗の理由を1行のJSONで追記する', () => {
   const home = mkdtempSync(join(tmpdir(), 'tl-hook-failure-log-'));
@@ -12,9 +18,12 @@ test('logHookFailureは、失敗の理由を1行のJSONで追記する', () => {
     logHookFailure('HOOK_CODEX_FAILED', 'thrown string', { home, now: Date.UTC(2026, 9, 4, 0, 0, 1) });
     const lines = readFileSync(hookFailureLogPath({ home }), 'utf8').trim().split('\n').map((line) => JSON.parse(line));
     assert.equal(lines.length, 2);
-    assert.deepEqual({ ...lines[0], version: 'x' }, {
+    const { stack, ...first } = lines[0];
+    assert.deepEqual({ ...first, version: 'x' }, {
       ts: '2026-10-04T00:00:00.005Z', code: 'HOOK_PROCESS_TURN_FAILED', version: 'x', name: 'TypeError', message: 'first reason',
     });
+    // Errorは失敗した位置を持つ。文字列を投げた時はstackが無いので、項目ごと残さない。
+    assert.equal(Array.isArray(stack) && stack.length > 0, true);
     assert.deepEqual({ ...lines[1], version: 'x' }, {
       ts: '2026-10-04T00:00:01.000Z', code: 'HOOK_CODEX_FAILED', version: 'x', name: 'string', message: 'thrown string',
     });
@@ -61,6 +70,31 @@ test('logHookFailureは、どの会話の失敗かを残す', () => {
   }
 });
 
+test('logHookFailureは、失敗した位置をstackの先頭から残す', () => {
+  const home = mkdtempSync(join(tmpdir(), 'tl-hook-failure-log-'));
+  try {
+    const err = new Error('database is locked');
+    err.stack = [
+      'Error: database is locked',
+      '    at getDb (file:///throughline/src/db.mjs:455:5)',
+      `    at ${'x'.repeat(HOOK_FAILURE_STACK_FRAME_LIMIT + 40)}`,
+      ...Array.from({ length: HOOK_FAILURE_STACK_FRAMES + 3 }, (_, index) => `    at frame${index} (file:///throughline/src/a.mjs:${index}:1)`),
+    ].join('\n');
+    logHookFailure('HOOK_SESSION_START_FAILED', err, { home });
+    const noFrames = new Error('no frames');
+    noFrames.stack = 'Error: no frames';
+    logHookFailure('HOOK_SESSION_START_FAILED', noFrames, { home });
+    const [entry, second] = readFileSync(hookFailureLogPath({ home }), 'utf8').trim().split('\n').map((line) => JSON.parse(line));
+    assert.equal(entry.stack.length, HOOK_FAILURE_STACK_FRAMES);
+    assert.equal(entry.stack[0], 'at getDb (file:///throughline/src/db.mjs:455:5)');
+    assert.equal(entry.stack[1].length, HOOK_FAILURE_STACK_FRAME_LIMIT);
+    assert.equal(entry.stack[2], 'at frame0 (file:///throughline/src/a.mjs:0:1)');
+    assert.equal('stack' in second, false);
+  } finally {
+    rmSync(home, { recursive: true, force: true });
+  }
+});
+
 test('logHookFailureは、長い文面を上限で切る', () => {
   const home = mkdtempSync(join(tmpdir(), 'tl-hook-failure-log-'));
   try {

package/src/hosts/cursor.test.mjs

@@ -25,6 +25,16 @@ test('parseHookPayload accepts one leading BOM and preserves BOM inside prompt t
   assert.throws(() => parseHookPayload('\uFEFF{"conversation_id":'), SyntaxError);
 });
 
+test('parseHookPayloadは、stdinが空の時と途中で切れた時を、文面の字数で見分けられるようにする', () => {
+  assert.throws(() => parseHookPayload(''), (error) => {
+    assert.equal(error instanceof SyntaxError, true);
+    assert.match(error.message, /^hook stdin is not valid JSON \(0 chars\): /u);
+    assert.equal(error.cause instanceof SyntaxError, true);
+    return true;
+  });
+  assert.throws(() => parseHookPayload('\uFEFF{"conversation_id":'), /^SyntaxError: hook stdin is not valid JSON \(20 chars\): /u);
+});
+
 test('isCursorEnvelope detects Cursor events and cursor_version', () => {
   assert.equal(
     isCursorEnvelope({

package/src/hosts/index.mjs

@@ -29,7 +29,15 @@ const ADAPTERS = Object.freeze({
 
 /** Parse hook stdin, including the leading UTF-8 BOM emitted by Windows Cursor. */
 export function parseHookPayload(raw, options = {}) {
-  return normalizeHookPayload(JSON.parse(raw.replace(/^\uFEFF/, '')), options);
+  let parsed;
+  try {
+    parsed = JSON.parse(raw.replace(/^\uFEFF/, ''));
+  } catch (error) {
+    // host が stdin を渡さずに閉じた時（0 字）と、途中で切れた時を、理由の文面で見分けられるようにする。
+    const detail = error instanceof Error ? error.message : String(error);
+    throw new SyntaxError(`hook stdin is not valid JSON (${raw.length} chars): ${detail}`, { cause: error });
+  }
+  return normalizeHookPayload(parsed, options);
 }
 
 /**

package/src/resume-context.mjs

@@ -3,6 +3,7 @@
  *
  * 呼び出し元:
  *   - handoff-executor.mjs（最初のUserPromptSubmitでauto path / baton path共通注入）
+ *   - claude-auto-handoff.mjs（自動圧縮の直後のSessionStartで同じ会話へ注入。ADR 0032）
  *
  * 設計 (docs/02_clear_auto_handoff_plan.md):
  *   - 予算付き注入: ヘッダ + 現在地アンカー + pull案内を固定部とし、残りへ
@@ -55,6 +56,28 @@ const RESUME_HEADER_TEMPLATE = (turnCount, handoffDisclosure) =>
 
 const NORMAL_HEADER = '## Throughline: セッション記憶';
 
+const DEFAULT_ANCHOR_TITLE = '### 現在地 (直前のやりとり)';
+
+// 自動圧縮の直後に、同じ会話へ注入する時のヘッダ (ADR 0032)。/clear の引き継ぎと違い、
+// 作業の途中で、次のユーザー入力は来ない。宣言はさせず、そのまま続けさせる。
+const COMPACT_HEADER =
+  `## Throughline: 自動圧縮後の継続用コンテキスト\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;
+const IN_FLIGHT_ASSISTANT_MAX_CHARS = 1_500;
+
 // v0.10.12以前にThroughline自身がassistantへ付与させていた宣言行。
 // 製品由来のメタ情報だけを引き継ぎ材料から除き、会話本文への模倣連鎖を止める。
 // userが同じ文を引用した場合は会話内容なので保持する。
@@ -193,14 +216,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 +419,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 +445,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 +514,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 +538,72 @@ 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 0032)。
+ *
+ * 構成は /clear の引き継ぎと同じ予算付き（ヘッダ + 現在地 + 案内 + 入るだけの L2）。違いは現在地で、
+ * DB の最新ターンではなく、transcript から読んだ作業途中のターンを載せる。作業途中のターンは
+ * Stop の前で bodies に無いので、L2 セクションには出ない。
+ *
+ * 完了したターンが 1 つも無い会話（最初のターンの途中で圧縮）でも、現在地だけを返す。
+ *
+ * @param {import('node:sqlite').DatabaseSync} db
+ * @param {{
+ *   sessionId: string,
+ *   inFlight: {
+ *     user: {content: string, timestamp: number|null},
+ *     fragments: Array<{content: string, timestamp: number|null}>,
+ *   } | null,
+ *   inFlightUnreadable?: boolean,  transcript に今の依頼がまだ書かれていない（hook の prompt_id と合わない）
+ *   maxChars?: number,
+ * }} params
+ */
+export function buildCompactContinuationContext(
+  db,
+  { sessionId, inFlight, inFlightUnreadable = false, 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),
+    );
+    const lastFragment = inFlight.fragments.at(-1);
+    if (lastFragment) {
+      anchorLines.push(
+        `**圧縮直前のあなたの発言**${stamp(lastFragment.timestamp)}: ` +
+          truncateInFlight(lastFragment.content, IN_FLIGHT_ASSISTANT_MAX_CHARS),
+      );
+    }
+  }
+  if (!inFlight && inFlightUnreadable) {
+    anchorLines.push(
+      '**作業中のユーザー依頼**: （記録からまだ読めません。圧縮後の文脈にある最新のユーザー依頼を続けてください）',
+    );
+  }
+  if (!stored && anchorLines.length === 0) return null;
+
+  return renderBudgetedSections(
+    db,
+    {
+      header: COMPACT_HEADER,
+      anchorTitle: COMPACT_ANCHOR_TITLE,
+      anchorLines,
+      l1Lines: [],
+      l2Lines: stored?.l2Lines ?? [],
+    },
+    { sessionId, excludeOriginId: null, maxChars },
+  );
+}

package/src/resume-context.test.mjs

@@ -4,6 +4,7 @@ import { DatabaseSync } from 'node:sqlite';
 import {
   buildResumeContext,
   buildBudgetedResumeContext,
+  buildCompactContinuationContext,
   INJECTION_BUDGET_CHARS,
 } from './resume-context.mjs';
 
@@ -905,3 +906,74 @@ test('budgeted: header and anchor always survive even under pressure', () => {
   assert.match(budgeted.text, /^## Throughline: 直前スレッドの継続応答用コンテキスト/);
   assert.ok(budgeted.text.includes('### 現在地 (直前のやりとり)'));
 });
+
+// --- 自動圧縮後の継続 (ADR 0032) ---
+
+test('buildCompactContinuationContext: 完了したターンが無くても、作業途中のターンだけで組み立てる', () => {
+  const db = makeDb();
+  const result = buildCompactContinuationContext(db, {
+    sessionId: 'S',
+    inFlight: { user: { content: '最初の依頼', timestamp: null }, fragments: [] },
+  });
+  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);
+});
+
+test('buildCompactContinuationContext: 現在地は作業途中のターンで、保存済みのターンは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, {
+    sessionId: 'S',
+    inFlight: {
+      user: { content: '今の依頼', timestamp: 3_000 },
+      fragments: [{ content: '途中1', timestamp: 4_000 }, { 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(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.equal(result.injectedL2Turns, 1);
+});
+
+test('buildCompactContinuationContext: 長い依頼と多数のターンでも予算内に収め、依頼は切り詰めを明示する', () => {
+  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 });
+  }
+  const result = buildCompactContinuationContext(db, {
+    sessionId: 'S',
+    inFlight: {
+      user: { content: 'ヰ'.repeat(6_000), timestamp: 20_000 },
+      fragments: [{ 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.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/);
+  assert.equal(result.injectedL2Turns + result.remainingL2Turns, 12);
+  assert.match(result.text, /throughline recall --l2 --session S /);
+});
+
+test('buildCompactContinuationContext: 長い依頼は先頭と末尾を残す。今の依頼が記録から読めない時は、その旨だけを現在地に書く', () => {
+  const db = makeDb();
+  const long = buildCompactContinuationContext(db, {
+    sessionId: 'S',
+    inFlight: { user: { content: '先頭の指示' + 'あ'.repeat(6_000) + '末尾の指示', timestamp: null }, fragments: [] },
+  });
+  assert.match(long.text, /\*\*作業中のユーザー依頼\*\*: 先頭の指示あ+ …\(長いため中略 2010 字\)… あ+末尾の指示\n/);
+
+  const unreadable = buildCompactContinuationContext(db, { sessionId: 'S', inFlight: null, inFlightUnreadable: true });
+  assert.match(unreadable.text, /### 現在地 \(作業途中のターン\)\n\*\*作業中のユーザー依頼\*\*: （記録からまだ読めません。圧縮後の文脈にある最新のユーザー依頼を続けてください）\n/);
+});

package/src/runtime-error-store.mjs

@@ -47,6 +47,12 @@ const DEFINITIONS = Object.freeze({
     severity: 'high',
     template: 'Throughline Claude Stop hook processing failed',
   }),
+  // 自動継続の印を残せなかった。圧縮と作業は続く（ADR 0032）。
+  HOOK_PRE_COMPACT_FAILED: Object.freeze({
+    component: 'claude_pre_compact_hook',
+    severity: 'warn',
+    template: 'Throughline Claude PreCompact hook processing failed',
+  }),
   HOOK_CODEX_FAILED: Object.freeze({
     component: 'codex_hook',
     severity: 'high',

package/src/session-start.mjs

@@ -21,6 +21,12 @@
  *
  *   バトンの消費・merge・注入は最初の UserPromptSubmit (= 実体の証明) で行う。
  *   幽霊はプロンプトを発火しないため記憶を奪えない。
+ *
+ * 【自動圧縮後の継続】 ADR 0032
+ *
+ *   source='compact' は新しい会話ではなく、圧縮を終えた同じ会話。PreCompact hook が
+ *   自動圧縮の印を残していた時だけ、作業途中のターンと直近の会話の原文を stdout へ書く。
+ *   host がそのまま作業を続けるので、次の UserPromptSubmit は待たない。
  */
 
 import { getDb } from './db.mjs';
@@ -33,8 +39,9 @@ import { existsSync } from 'node:fs';
 import { pathToFileURL } from 'node:url';
 import { recordRuntimeErrorBestEffort } from './runtime-error-store.mjs';
 import { logHookFailure } from './hook-failure-log.mjs';
-import { hostAdapterForSessionId, NON_CLAUDE_SESSION_PREFIXES, parseHookPayload } from './hosts/index.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';
 
 const ENV_DISABLE_AUTO_HANDOFF = 'THROUGHLINE_DISABLE_AUTO_HANDOFF';
 
@@ -163,6 +170,31 @@ 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 ?? {}),
+      });
+    }
+  }
+
   // Cursor は beforeSubmitPrompt が additional_context を持たない。
   // 新規 composer 会話の sessionStart が公式の注入口なので、ここで第二相を実行する。
   // Claude の幽霊 SessionStart 問題はこの host では sessionStart = 会話作成のため適用しない。