throughline 0.12.8 → 0.13.0

package/src/claude-auto-handoff.mjs

@@ -0,0 +1,207 @@
+/**
+ * claude-auto-handoff.mjs — Claude Code の自動継続 (ADR 0032)
+ *
+ * Codex の自動継続は、自動圧縮の前に旧タスクを止めて新しいタスクへ記憶を渡す。Claude Code は
+ * hook から作業を止められず、新しい会話へ指示を送る公開 API も無い。自動圧縮の後は host が
+ * 同じ会話で作業を続け、SessionStart(source=compact) の hook 出力を圧縮後の文脈へ足す。
+ * そこで Claude では、会話を切り替えずに次の 2 段で記憶を渡す。
+ *
+ *   1. PreCompact      : trigger=auto の時だけ、その会話に「自動圧縮が始まった」印を残す。
+ *                        圧縮は止めない（止めると文脈上限の error になる）。
+ *   2. SessionStart    : source=compact で印があれば、完了済みのターンを回収し、
+ *      (source=compact)  作業途中のターンと直近の会話の原文を stdout へ書く。
+ *
+ * 手動の /compact は対象にしない（Codex と同じ）。印は PreCompact の payload だけから作り、
+ * SessionStart の時点の transcript から trigger を推測しない（圧縮境界の行は hook より後に書かれる）。
+ */
+
+import { mkdirSync, readFileSync, readdirSync, renameSync, rmSync, statSync, writeFileSync } from 'node:fs';
+import { homedir } from 'node:os';
+import { join } from 'node:path';
+import { randomUUID } from 'node:crypto';
+import { readClaudeAutoHandoffConfig, claudeAutoHandoffEnabledFor } from './claude-auto-handoff-config.mjs';
+import { CLAUDE_HOST, hostOfSessionId } from './hosts/identity.mjs';
+import { claudeHostAdapter } from './hosts/claude.mjs';
+import { readLatestUserGroup } from './transcript-reader.mjs';
+import { backfillBodies, logBackfill } from './turn-backfill.mjs';
+import { resolveMergeTarget } from './session-merger.mjs';
+import { buildCompactContinuationContext } from './resume-context.mjs';
+
+export const CLAUDE_COMPACT_REQUEST_SCHEMA = 'throughline.claude-auto-handoff.request.v1';
+// 印は圧縮の完了で消える。圧縮が失敗して残った印は、次の PreCompact の時にこの期限で掃除する。
+const STALE_REQUEST_MS = 24 * 60 * 60 * 1000;
+// session id を印のファイル名に使う。Claude の id は UUID で、path の区切りを含む値は受け付けない。
+const CLAUDE_SESSION_ID_PATTERN = /^[A-Za-z0-9_-]{1,128}$/;
+
+export const claudeCompactRequestDir = () => join(homedir(), '.throughline', 'claude-auto-handoff');
+
+function requestPath(sessionId, dir) {
+  if (hostOfSessionId(sessionId) !== CLAUDE_HOST || !CLAUDE_SESSION_ID_PATTERN.test(sessionId)) {
+    throw new Error('auto_handoff_session_id_invalid');
+  }
+  return join(dir, `${sessionId}.json`);
+}
+
+function removeStaleRequests(dir, now) {
+  let names;
+  try { names = readdirSync(dir); }
+  catch (error) {
+    if (error.code === 'ENOENT') return;
+    throw error;
+  }
+  for (const name of names) {
+    if (!name.endsWith('.json')) continue;
+    const path = join(dir, name);
+    let modifiedAt;
+    try { modifiedAt = statSync(path).mtimeMs; }
+    catch (error) {
+      if (error.code === 'ENOENT') continue; // 別の hook が同時に消した
+      throw error;
+    }
+    if (now - modifiedAt > STALE_REQUEST_MS) rmSync(path, { force: true });
+  }
+}
+
+/**
+ * PreCompact hook の本体。自動圧縮で、その project が有効な時だけ印を残す。
+ * 手動と無効の時は、同じ会話の古い印を消して何もしない。subagent の中の圧縮は、
+ * 親の会話の印に触らない（payload の session_id は親の会話を指す）。
+ *
+ * @param {{
+ *   payload: {session_id?: string, trigger?: string, cwd?: string, transcript_path?: string},
+ *   env?: NodeJS.ProcessEnv,
+ *   config?: {enabled: boolean, projects: string[]},
+ *   now?: number,
+ *   dir?: string,
+ * }} params
+ * @returns {{status: 'requested'|'skipped', reason?: string, sessionId: string, projectPath?: string}}
+ */
+export function recordClaudeCompactRequest({
+  payload,
+  env = process.env,
+  config = readClaudeAutoHandoffConfig(),
+  now = Date.now(),
+  dir = claudeCompactRequestDir(),
+}) {
+  const sessionId = payload?.session_id;
+  if (typeof sessionId !== 'string' || !sessionId) throw new Error('Missing session_id in PreCompact payload');
+  if (payload.agent_id) return { status: 'skipped', reason: 'subagent_compact', sessionId };
+  const path = requestPath(sessionId, dir);
+  // 有効判定は会話を起動した project で行う。hook の cwd は Bash の cd に追従する。
+  const projectPath = claudeHostAdapter.completionProjectPath({ cwd: payload.cwd ?? process.cwd(), env });
+
+  const reason = payload.trigger !== 'auto'
+    ? 'manual_compact'
+    : claudeAutoHandoffEnabledFor(config, projectPath) ? null : 'auto_handoff_disabled';
+  if (reason) {
+    rmSync(path, { force: true });
+    return { status: 'skipped', reason, sessionId, projectPath };
+  }
+
+  mkdirSync(dir, { recursive: true, mode: 0o700 });
+  removeStaleRequests(dir, now);
+  const temporary = `${path}.${randomUUID()}.tmp`;
+  writeFileSync(temporary, `${JSON.stringify({
+    schema: CLAUDE_COMPACT_REQUEST_SCHEMA,
+    session_id: sessionId,
+    trigger: 'auto',
+    project_path: projectPath,
+    transcript_path: payload.transcript_path ?? null,
+    requested_at: now,
+  })}\n`, { mode: 0o600, flag: 'wx' });
+  renameSync(temporary, path);
+  return { status: 'requested', sessionId, projectPath };
+}
+
+/**
+ * SessionStart(source=compact) から呼ぶ。その会話の印を取り出して消す。無ければ null。
+ * @returns {{session_id: string, trigger: 'auto', project_path: string, transcript_path: string|null, requested_at: number}|null}
+ */
+export function consumeClaudeCompactRequest({ sessionId, dir = claudeCompactRequestDir() }) {
+  if (hostOfSessionId(sessionId) !== CLAUDE_HOST || !CLAUDE_SESSION_ID_PATTERN.test(sessionId)) return null;
+  const path = requestPath(sessionId, dir);
+  let text;
+  try { text = readFileSync(path, 'utf8'); }
+  catch (error) {
+    if (error.code === 'ENOENT') return null;
+    throw error;
+  }
+  rmSync(path, { force: true });
+  const request = JSON.parse(text);
+  if (request.schema !== CLAUDE_COMPACT_REQUEST_SCHEMA || request.session_id !== sessionId ||
+      request.trigger !== 'auto') throw new Error('auto_handoff_request_invalid');
+  return request;
+}
+
+export function listClaudeCompactRequests({ dir = claudeCompactRequestDir() } = {}) {
+  let names;
+  try { names = readdirSync(dir); }
+  catch (error) {
+    if (error.code === 'ENOENT') return [];
+    throw error;
+  }
+  return names.filter(name => name.endsWith('.json')).map(name => {
+    const { session_id, project_path, requested_at } = JSON.parse(readFileSync(join(dir, name), 'utf8'));
+    return { session_id, project_path, requested_at };
+  }).sort((a, b) => a.requested_at - b.requested_at);
+}
+
+/**
+ * 自動圧縮の直後に注入するテキストを作る。
+ *
+ * 作業途中のターン（最後の user 発言の群）は Stop の前なので、回収の対象から外して transcript から読む。
+ * それより前の完了済みターンは、Stop が空振りした分もここで bodies へ回収してから並べる。
+ *
+ * transcript は hook より遅れて書かれることがある。hook payload の `prompt_id` と、最後の user 行の
+ * `promptId` が両方あって食い違う時は、今の依頼がまだ書かれていない。その時は最後の群を
+ * 作業途中として見せず、回収もしない（どちらのターンか確定できない群を、完了として保存しない）。
+ *
+ * @param {import('node:sqlite').DatabaseSync} db
+ * @param {{ sessionId: string, transcriptPath: string|null|undefined, promptId?: string|null, now?: number }} params
+ * @returns {{
+ *   text: string,
+ *   stats: {total_chars: number, injected_l2_turns: number, remaining_l2_turns: number, older_turns: number,
+ *     in_flight_user: boolean, in_flight_unreadable: boolean, in_flight_fragments: number, backfilled_turns: number},
+ * } | null}
+ */
+export function buildClaudeCompactContinuation(db, { sessionId, transcriptPath, promptId = null, now = Date.now() }) {
+  const { target, origin } = resolveMergeTarget(db, sessionId);
+  const latest = readLatestUserGroup(transcriptPath);
+  const inFlightUnreadable = Boolean(promptId && latest?.user.prompt_id && latest.user.prompt_id !== promptId);
+  const inFlight = inFlightUnreadable ? null : latest;
+
+  const backfill = backfillBodies(db, {
+    targetSessionId: target,
+    originSessionId: origin,
+    transcriptPath,
+    now,
+    beforeUserTurnNumber: latest ? latest.user.turn_number : null,
+  });
+  logBackfill({
+    ts: new Date(now).toISOString(),
+    hook: 'session-start-compact',
+    session_id: sessionId,
+    target,
+    origin,
+    transcript_path: transcriptPath ?? null,
+    groups: backfill.groups,
+    inserted_turns: backfill.insertedTurns,
+    skipped_existing: backfill.skippedExisting,
+  });
+
+  const context = buildCompactContinuationContext(db, { sessionId: target, inFlight, inFlightUnreadable });
+  if (!context) return null;
+  return {
+    text: context.text,
+    stats: {
+      total_chars: context.totalChars,
+      injected_l2_turns: context.injectedL2Turns,
+      remaining_l2_turns: context.remainingL2Turns,
+      older_turns: context.olderTurns,
+      in_flight_user: Boolean(inFlight),
+      in_flight_unreadable: inFlightUnreadable,
+      in_flight_fragments: inFlight?.fragments.length ?? 0,
+      backfilled_turns: backfill.insertedTurns,
+    },
+  };
+}

package/src/claude-auto-handoff.test.mjs

@@ -0,0 +1,308 @@
+import { test } from 'node:test';
+import assert from 'node:assert/strict';
+import { spawnSync } from 'node:child_process';
+import { appendFileSync, existsSync, mkdirSync, mkdtempSync, readFileSync, readdirSync, rmSync, utimesSync, writeFileSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { dirname, join } from 'node:path';
+import { DatabaseSync } from 'node:sqlite';
+import { fileURLToPath } from 'node:url';
+import {
+  recordClaudeCompactRequest,
+  consumeClaudeCompactRequest,
+  listClaudeCompactRequests,
+} from './claude-auto-handoff.mjs';
+import { parseAutoHandoffArgs } from './cli/auto-handoff.mjs';
+
+const REPO_ROOT = dirname(dirname(fileURLToPath(import.meta.url)));
+const CLI = join(REPO_ROOT, 'bin', 'throughline.mjs');
+const SESSION = '0f3a6c1e-7b2d-4e5f-9a81-3c4d5e6f7a8b';
+const ENABLED = { enabled: true, projects: [] };
+
+function withDir(fn) {
+  const dir = mkdtempSync(join(tmpdir(), 'tl-claude-auto-'));
+  try { return fn(dir); }
+  finally { rmSync(dir, { recursive: true, force: true }); }
+}
+
+function childEnv(home) {
+  // 設定とstateの置き場も一時HOMEへ向ける（本物のruntime error storeへ書かない）。
+  return {
+    ...process.env,
+    HOME: home,
+    USERPROFILE: home,
+    XDG_CONFIG_HOME: join(home, '.config'),
+    XDG_STATE_HOME: join(home, '.local', 'state'),
+    LOCALAPPDATA: join(home, 'AppData', 'Local'),
+    THROUGHLINE_NO_VSCODE: '1',
+    CLAUDE_PROJECT_DIR: '',
+  };
+}
+
+function cli(home, args, input = '') {
+  return spawnSync(process.execPath, [CLI, ...args], { cwd: REPO_ROOT, env: childEnv(home), input, encoding: 'utf8' });
+}
+
+const user = (text, timestamp) => ({ type: 'user', timestamp, message: { role: 'user', content: text } });
+const assistant = (text, timestamp) => ({ type: 'assistant', timestamp, message: { role: 'assistant', content: [{ type: 'text', text }] } });
+const toolUse = (id, name) => ({ type: 'assistant', message: { role: 'assistant', content: [{ type: 'tool_use', id, name, input: {} }] } });
+const toolResult = (id, text) => ({ type: 'user', message: { role: 'user', content: [{ type: 'tool_result', tool_use_id: id, content: text }] } });
+const compactSummary = () => ({ type: 'user', isCompactSummary: true, isVisibleInTranscriptOnly: true,
+  message: { role: 'user', content: 'This session is being continued from a previous conversation that ran out of context.' } });
+const jsonl = entries => entries.map(entry => JSON.stringify(entry)).join('\n') + '\n';
+
+test('PreCompact: 自動圧縮で有効な時だけ印を残し、手動・無効・対象外のprojectでは古い印を消す', () => withDir(dir => {
+  const payload = { session_id: SESSION, trigger: 'auto', cwd: '/work/app', transcript_path: '/t.jsonl' };
+  const args = { payload, env: {}, config: ENABLED, dir, now: 1_000 };
+
+  assert.deepEqual(recordClaudeCompactRequest(args), { status: 'requested', sessionId: SESSION, projectPath: '/work/app' });
+  assert.deepEqual(listClaudeCompactRequests({ dir }), [{ session_id: SESSION, project_path: '/work/app', requested_at: 1_000 }]);
+
+  for (const [override, reason] of [
+    [{ payload: { ...payload, trigger: 'manual' } }, 'manual_compact'],
+    [{ config: { enabled: false, projects: [] } }, 'auto_handoff_disabled'],
+    [{ config: { enabled: true, projects: ['/work/other'] } }, 'auto_handoff_disabled'],
+  ]) {
+    recordClaudeCompactRequest(args);
+    const result = recordClaudeCompactRequest({ ...args, ...override });
+    assert.equal(result.status, 'skipped');
+    assert.equal(result.reason, reason);
+    assert.deepEqual(readdirSync(dir), [], reason);
+  }
+
+  // 有効判定は会話を起動した project で行う（cwd は Bash の cd に追従する）
+  const started = recordClaudeCompactRequest({ ...args, payload: { ...payload, cwd: '/work/app/sub' },
+    env: { CLAUDE_PROJECT_DIR: '/work/app' }, config: { enabled: true, projects: ['/work/app'] } });
+  assert.equal(started.status, 'requested');
+  assert.equal(started.projectPath, '/work/app');
+}));
+
+test('PreCompact: subagent の中の圧縮は親の会話の印に触らない', () => withDir(dir => {
+  const payload = { session_id: SESSION, trigger: 'auto', cwd: '/work/app' };
+  recordClaudeCompactRequest({ payload, env: {}, config: ENABLED, dir, now: 1_000 });
+  for (const trigger of ['auto', 'manual']) {
+    const result = recordClaudeCompactRequest({ payload: { ...payload, trigger, agent_id: 'agent-1' }, env: {}, config: ENABLED, dir, now: 2_000 });
+    assert.deepEqual(result, { status: 'skipped', reason: 'subagent_compact', sessionId: SESSION });
+  }
+  assert.equal(listClaudeCompactRequests({ dir })[0].requested_at, 1_000);
+}));
+
+test('PreCompact: session id が無い・pathを含む時は失敗し、期限を過ぎた他の会話の印は掃除する', () => withDir(dir => {
+  assert.throws(() => recordClaudeCompactRequest({ payload: { trigger: 'auto' }, env: {}, config: ENABLED, dir }), /Missing session_id/);
+  assert.throws(() => recordClaudeCompactRequest({ payload: { session_id: '../escape', trigger: 'auto', cwd: '/w' }, env: {}, config: ENABLED, dir }),
+    /auto_handoff_session_id_invalid/);
+
+  const now = Date.parse('2026-10-04T12:00:00Z');
+  mkdirSync(dir, { recursive: true });
+  const stale = join(dir, 'aaaaaaaa-0000-4000-8000-000000000001.json');
+  const fresh = join(dir, 'aaaaaaaa-0000-4000-8000-000000000002.json');
+  for (const path of [stale, fresh]) writeFileSync(path, '{}');
+  utimesSync(stale, new Date(now - 25 * 3_600_000), new Date(now - 25 * 3_600_000));
+  utimesSync(fresh, new Date(now - 3_600_000), new Date(now - 3_600_000));
+  recordClaudeCompactRequest({ payload: { session_id: SESSION, trigger: 'auto', cwd: '/w' }, env: {}, config: ENABLED, dir, now });
+  assert.deepEqual(readdirSync(dir).sort(), [`${SESSION}.json`, 'aaaaaaaa-0000-4000-8000-000000000002.json'].sort());
+}));
+
+test('SessionStart: 印は一度だけ取り出せる。別の会話・他hostの会話は取り出さない', () => withDir(dir => {
+  recordClaudeCompactRequest({ payload: { session_id: SESSION, trigger: 'auto', cwd: '/work/app', transcript_path: '/t.jsonl' },
+    env: {}, config: ENABLED, dir, now: 5_000 });
+  assert.equal(consumeClaudeCompactRequest({ sessionId: 'aaaaaaaa-0000-4000-8000-000000000009', dir }), null);
+  assert.equal(consumeClaudeCompactRequest({ sessionId: `grok:${SESSION}`, dir }), null);
+  const request = consumeClaudeCompactRequest({ sessionId: SESSION, dir });
+  assert.equal(request.trigger, 'auto');
+  assert.equal(request.project_path, '/work/app');
+  assert.equal(request.transcript_path, '/t.jsonl');
+  assert.equal(request.requested_at, 5_000);
+  assert.equal(consumeClaudeCompactRequest({ sessionId: SESSION, dir }), null);
+
+  writeFileSync(join(dir, `${SESSION}.json`), JSON.stringify({ schema: 'other', session_id: SESSION, trigger: 'auto' }));
+  assert.throws(() => consumeClaudeCompactRequest({ sessionId: SESSION, dir }), /auto_handoff_request_invalid/);
+  assert.deepEqual(readdirSync(dir), [], '読めない印は残さない');
+}));
+
+test('公開CLI: --host claude は enable・disable・status だけを受け取る', () => {
+  assert.equal(parseAutoHandoffArgs(['status', '--json']).host, 'codex');
+  assert.deepEqual(
+    (({ action, host, project, json }) => ({ action, host, project, json }))(parseAutoHandoffArgs(['enable', '--host', 'claude', '--project', REPO_ROOT, '--json'])),
+    { action: 'enable', host: 'claude', project: REPO_ROOT, json: true },
+  );
+  for (const args of [['resume', '--host', 'claude', '--operation', 'id'], ['status', '--host', 'claude', '--operation', 'id'],
+    ['worker', '--host', 'claude', '--operation', 'id'], ['status', '--host', 'grok'], ['status', '--host'], ['disable', '--host', 'claude', '--project', '/p']]) {
+    assert.throws(() => parseAutoHandoffArgs(args), JSON.stringify(args));
+  }
+});
+
+test('公開CLI: enable は PreCompact hook と設定を書き、Codex の設定には触らない', () => withDir(home => {
+  const settingsPath = join(home, '.claude', 'settings.json');
+  mkdirSync(dirname(settingsPath), { recursive: true });
+  // 他製品のhookと、matcher付きの古い自分の登録がある状態から始める
+  writeFileSync(settingsPath, JSON.stringify({ model: 'sonnet', hooks: { PreCompact: [
+    { matcher: 'auto', hooks: [{ type: 'command', command: 'throughline pre-compact' }] },
+    { hooks: [{ type: 'command', command: 'other-product pre-compact' }] },
+  ] } }));
+
+  const before = JSON.parse(cli(home, ['auto-handoff', 'status', '--host', 'claude', '--json']).stdout);
+  assert.deepEqual(before, { host: 'claude', config: { schema: 'throughline.claude-auto-handoff.v1', enabled: false, projects: [] },
+    hook: { registered: false }, pending: [] });
+  assert.equal(existsSync(join(home, '.throughline')), false, 'status は何も作らない');
+
+  const enabled = cli(home, ['auto-handoff', 'enable', '--host', 'claude', '--json']);
+  assert.equal(enabled.status, 0, enabled.stderr);
+  assert.equal(JSON.parse(enabled.stdout).status, 'enabled');
+  const settings = JSON.parse(readFileSync(settingsPath, 'utf8'));
+  assert.equal(settings.model, 'sonnet');
+  assert.deepEqual(settings.hooks.PreCompact, [
+    { hooks: [{ type: 'command', command: 'throughline pre-compact' }] },
+    { hooks: [{ type: 'command', command: 'other-product pre-compact' }] },
+  ]);
+  const again = cli(home, ['auto-handoff', 'enable', '--host', 'claude', '--json']);
+  assert.equal(again.status, 0, again.stderr);
+  assert.equal(readFileSync(settingsPath, 'utf8'), JSON.stringify(settings, null, 2) + '\n', '2回目は書き換えない');
+
+  const text = cli(home, ['auto-handoff', 'status', '--host', 'claude']);
+  assert.equal(text.stdout, '自動継続: 有効（Claude Code）\nPreCompact hook: 登録済み\n');
+  assert.equal(existsSync(join(home, '.throughline', 'codex-auto-handoff.json')), false);
+  assert.equal(JSON.parse(cli(home, ['auto-handoff', 'status', '--json']).stdout).config.enabled, false, 'Codex は無効のまま');
+
+  const disabled = JSON.parse(cli(home, ['auto-handoff', 'disable', '--host', 'claude', '--json']).stdout);
+  assert.equal(disabled.config.enabled, false);
+  const unsupported = cli(home, ['auto-handoff', 'resume', '--host', 'claude', '--operation', 'x', '--json']);
+  assert.equal(unsupported.status, 1);
+  assert.deepEqual(JSON.parse(unsupported.stdout), { status: 'failed', code: 'auto_handoff_action_unsupported' });
+}));
+
+test('hook: 自動圧縮の直後に、作業途中のターンと直近の会話を同じ会話へ注入し、最終回答は1ターンとして保存する', () => withDir(home => {
+  const project = join(home, 'project');
+  mkdirSync(project, { recursive: true });
+  const transcriptPath = join(home, 'transcript.jsonl');
+  const base = Date.parse('2026-10-04T03:00:00Z');
+  const at = seconds => new Date(base + seconds * 1000).toISOString();
+  writeFileSync(transcriptPath, jsonl([
+    user('成果物の1行目には必ず「約束: MANGO-4417」と書くこと', at(0)),
+    assistant('了解しました。', at(1)),
+    user('big1.txt と big2.txt を読んで result.txt を作って', at(10)),
+    toolUse('toolu_1', 'Read'),
+    toolResult('toolu_1', 'big1 contents'),
+    assistant('big1.txt を読み終えました。次に big2.txt を読みます。', at(12)),
+  ]));
+  const common = { session_id: SESSION, cwd: project, transcript_path: transcriptPath };
+  const hook = (command, payload) => cli(home, [command], JSON.stringify({ ...common, ...payload }));
+
+  assert.equal(cli(home, ['auto-handoff', 'enable', '--host', 'claude', '--project', project, '--json']).status, 0);
+  assert.equal(hook('session-start', { hook_event_name: 'SessionStart', source: 'startup' }).status, 0);
+
+  // 手動の /compact では注入しない
+  const manual = hook('pre-compact', { hook_event_name: 'PreCompact', trigger: 'manual' });
+  assert.equal(manual.status, 0, manual.stderr);
+  assert.equal(manual.stdout, '', 'PreCompact の stdout は空（JSON の decision を返さない）');
+  assert.equal(hook('session-start', { hook_event_name: 'SessionStart', source: 'compact' }).stdout, '');
+
+  // 自動圧縮
+  const pre = hook('pre-compact', { hook_event_name: 'PreCompact', trigger: 'auto' });
+  assert.equal(pre.status, 0, pre.stderr);
+  assert.equal(pre.stdout, '');
+  assert.equal(JSON.parse(cli(home, ['auto-handoff', 'status', '--host', 'claude', '--json']).stdout).pending.length, 1);
+  appendFileSync(transcriptPath, jsonl([compactSummary()]));
+
+  const compacted = hook('session-start', { hook_event_name: 'SessionStart', source: 'compact' });
+  assert.equal(compacted.status, 0, compacted.stderr);
+  assert.match(compacted.stdout, /^## Throughline: 自動圧縮後の継続用コンテキスト\n/);
+  assert.match(compacted.stdout, /### 現在地 \(作業途中のターン\)\n\*\*作業中のユーザー依頼\*\* \[\d\d:\d\d:\d\d\]: big1\.txt と big2\.txt を読んで result\.txt を作って\n/);
+  assert.match(compacted.stdout, /\*\*圧縮直前のあなたの発言\*\* \[\d\d:\d\d:\d\d\]: big1\.txt を読み終えました。次に big2\.txt を読みます。\n/);
+  assert.match(compacted.stdout, /\[user\]: 成果物の1行目には必ず「約束: MANGO-4417」と書くこと\n/);
+  assert.match(compacted.stdout, /\[assistant\]: 了解しました。/);
+  assert.doesNotMatch(compacted.stdout, /This session is being continued/, '圧縮の要約は記録に入れない');
+  assert.ok(compacted.stdout.length <= 9_501);
+
+  const db = new DatabaseSync(join(home, '.throughline', 'throughline.db'));
+  const bodies = () => db.prepare('SELECT turn_number, role, text FROM bodies ORDER BY turn_number, role DESC').all()
+    .map(row => [row.turn_number, row.role, row.text]);
+  assert.deepEqual(bodies(), [
+    [1, 'user', '成果物の1行目には必ず「約束: MANGO-4417」と書くこと'],
+    [1, 'assistant', '了解しました。'],
+  ], '作業途中のターンは保存しない（途中の発言を回答として固定しない）');
+
+  // 印は消費済み。次の圧縮が手動なら何も出さない
+  assert.equal(JSON.parse(cli(home, ['auto-handoff', 'status', '--host', 'claude', '--json']).stdout).pending.length, 0);
+  assert.equal(hook('session-start', { hook_event_name: 'SessionStart', source: 'compact' }).stdout, '');
+
+  // 圧縮の後、作業が終わる
+  appendFileSync(transcriptPath, jsonl([
+    toolUse('toolu_2', 'Read'),
+    toolResult('toolu_2', 'big2 contents'),
+    assistant('result.txt を作りました。', at(40)),
+  ]));
+  const stop = hook('process-turn', { hook_event_name: 'Stop', last_assistant_message: 'result.txt を作りました。' });
+  assert.equal(stop.status, 0, stop.stderr);
+  assert.deepEqual(bodies().slice(2), [
+    [5, 'user', 'big1.txt と big2.txt を読んで result.txt を作って'],
+    [5, 'assistant', 'result.txt を作りました。'],
+  ]);
+  const tools = db.prepare("SELECT tool_name FROM details WHERE kind = 'tool_input' AND turn_number = 5 ORDER BY id").all();
+  assert.deepEqual(tools.map(row => row.tool_name), ['Read', 'Read'], '圧縮より前のtoolも同じターンのL3に入る');
+  db.close();
+
+  const decisions = readFileSync(join(home, '.throughline', 'logs', 'inheritance-decision.log'), 'utf8').trim().split('\n').map(JSON.parse);
+  assert.deepEqual(decisions.filter(entry => entry.phase === 'pre-compact').map(entry => [entry.trigger, entry.auto_continuation, entry.skip_reason]),
+    [['manual', 'skipped', 'manual_compact'], ['auto', 'requested', null]]);
+  const continuation = decisions.filter(entry => entry.phase === 'compact-continuation');
+  assert.equal(continuation.length, 1);
+  assert.equal(continuation[0].injected, true);
+  assert.equal(continuation[0].in_flight_fragments, 1);
+  assert.equal(continuation[0].injected_l2_turns, 1);
+}));
+
+test('hook: transcript に今の依頼がまだ無い時（prompt_id が合わない）、前のターンを作業中として見せず、保存もしない', () => withDir(home => {
+  const project = join(home, 'project');
+  mkdirSync(project, { recursive: true });
+  const transcriptPath = join(home, 'transcript.jsonl');
+  writeFileSync(transcriptPath, jsonl([
+    { ...user('最初の依頼', '2026-10-04T03:00:00Z'), promptId: 'prompt-1' },
+    assistant('最初の回答', '2026-10-04T03:00:01Z'),
+    { ...user('前の依頼', '2026-10-04T03:00:10Z'), promptId: 'prompt-2' },
+    assistant('前の回答', '2026-10-04T03:00:11Z'),
+  ]));
+  const common = { session_id: SESSION, cwd: project, transcript_path: transcriptPath, prompt_id: 'prompt-3' };
+  const hook = (command, payload) => cli(home, [command], JSON.stringify({ ...common, ...payload }));
+  assert.equal(cli(home, ['auto-handoff', 'enable', '--host', 'claude', '--json']).status, 0);
+  assert.equal(hook('pre-compact', { hook_event_name: 'PreCompact', trigger: 'auto' }).status, 0);
+
+  const compacted = hook('session-start', { hook_event_name: 'SessionStart', source: 'compact' });
+  assert.equal(compacted.status, 0, compacted.stderr);
+  assert.match(compacted.stdout, /\*\*作業中のユーザー依頼\*\*: （記録からまだ読めません。/);
+  assert.doesNotMatch(compacted.stdout, /前の依頼|前の回答|圧縮直前のあなたの発言/);
+  assert.match(compacted.stdout, /\[user\]: 最初の依頼\n/);
+  const db = new DatabaseSync(join(home, '.throughline', 'throughline.db'));
+  assert.deepEqual(db.prepare('SELECT text FROM bodies ORDER BY id').all().map(row => row.text), ['最初の依頼', '最初の回答']);
+  db.close();
+
+  // prompt_id が合う時は、その群が作業途中のターン
+  assert.equal(hook('pre-compact', { hook_event_name: 'PreCompact', trigger: 'auto', prompt_id: 'prompt-2' }).status, 0);
+  const matched = hook('session-start', { hook_event_name: 'SessionStart', source: 'compact', prompt_id: 'prompt-2' });
+  assert.match(matched.stdout, /\*\*作業中のユーザー依頼\*\* \[\d\d:\d\d:\d\d\]: 前の依頼\n\*\*圧縮直前のあなたの発言\*\* \[\d\d:\d\d:\d\d\]: 前の回答\n/);
+}));
+
+test('hook: 自動継続が無効な時、自動圧縮の前後で何も残さず何も出さない', () => withDir(home => {
+  const project = join(home, 'project');
+  mkdirSync(project, { recursive: true });
+  const transcriptPath = join(home, 'transcript.jsonl');
+  writeFileSync(transcriptPath, jsonl([user('依頼'), assistant('途中')]));
+  const common = { session_id: SESSION, cwd: project, transcript_path: transcriptPath };
+  const hook = (command, payload) => cli(home, [command], JSON.stringify({ ...common, ...payload }));
+
+  const pre = hook('pre-compact', { hook_event_name: 'PreCompact', trigger: 'auto' });
+  assert.equal(pre.status, 0, pre.stderr);
+  assert.equal(pre.stdout, '');
+  assert.equal(existsSync(join(home, '.throughline', 'claude-auto-handoff')), false);
+  const compacted = hook('session-start', { hook_event_name: 'SessionStart', source: 'compact' });
+  assert.equal(compacted.status, 0, compacted.stderr);
+  assert.equal(compacted.stdout, '');
+}));
+
+test('hook: PreCompact が失敗しても圧縮を止める終了コード(2)を返さず、理由を端末に残す', () => withDir(home => {
+  const failed = cli(home, ['pre-compact'], '{"trigger":"auto"}');
+  assert.equal(failed.status, 1);
+  assert.equal(failed.stdout, '');
+  const log = readFileSync(join(home, '.throughline', 'logs', 'hook-failures.log'), 'utf8');
+  assert.match(log, /HOOK_PRE_COMPACT_FAILED/);
+  assert.match(log, /Missing session_id in PreCompact payload/);
+}));

package/src/claude-pre-compact.mjs

@@ -0,0 +1,55 @@
+#!/usr/bin/env node
+/**
+ * PreCompact hook — Claude Code の自動継続の第一段 (ADR 0032)
+ *
+ * stdin: { session_id, transcript_path, cwd, hook_event_name, trigger, custom_instructions }
+ *
+ * 自動圧縮（trigger=auto）で、自動継続が有効な project の時だけ、その会話に印を残す。
+ * 記憶の注入は圧縮の後の SessionStart(source=compact) が行う。
+ *
+ * この hook は圧縮を止めない。Claude Code は PreCompact の exit code 2 と `decision: "block"` を
+ * 「圧縮を止める」と解釈するので、stdout には何も書かず、失敗した時も exit code 1 で終わる。
+ */
+
+import { pathToFileURL } from 'node:url';
+import { parseHookPayload } from './hosts/index.mjs';
+import { recordClaudeCompactRequest } from './claude-auto-handoff.mjs';
+import { logDecision } from './decision-log.mjs';
+import { recordRuntimeErrorBestEffort } from './runtime-error-store.mjs';
+import { logHookFailure } from './hook-failure-log.mjs';
+
+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 = recordClaudeCompactRequest({ payload, env: process.env, now });
+
+  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,
+    skip_reason: result.reason ?? null,
+  });
+
+  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/cli/auto-handoff.mjs

@@ -6,23 +6,31 @@ 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, installClaudeAutoHandoffHook, claudeAutoHandoffHookRegistered } 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';
+
+// Claude の自動継続は圧縮後の同じ会話へ記憶を注入する (ADR 0032)。引き継ぎ操作の記録を持たないので、
+// 使える action は有効化・無効化・状態だけ。
+const CLAUDE_ACTIONS = ['enable', 'disable', 'status'];
 
 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) || out.operation)) 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 +67,26 @@ export async function enableAutoHandoff({ project = null, codexHome = realCodexH
   return { status: 'enabled', config, hookKeys, host: 'desktop' };
 }
 
+export function enableClaudeAutoHandoff({ project = null, register = installClaudeAutoHandoffHook } = {}) {
+  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' };
+}
+
+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 pending = listClaudeCompactRequests()
+    .filter(request => !parsed.project || sameProjectPath(request.project_path, parsed.project));
+  return { host: 'claude', config: readClaudeAutoHandoffConfig(),
+    hook: { registered: claudeAutoHandoffHookRegistered() }, pending };
+}
+
 export function publicOperation(operation) {
   if (!operation) return null;
   const { handoff_id, source_thread_id, source_turn_id, target_thread_id, delivery_id,
@@ -73,6 +101,16 @@ export async function run(args = []) {
   try {
     const parsed = parseAutoHandoffArgs(args);
     let result;
+    if (parsed.host === 'claude') {
+      result = 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`);
+      } else process.stdout.write(JSON.stringify(result, null, 2) + '\n');
+      return 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') {