throughline 0.16.31 → 0.16.33

package/src/cli/install.mjs

@@ -39,6 +39,7 @@ const SC_COMMANDS = [
   'throughline prompt-submit',
   'throughline pre-compact',
   'throughline pre-tool-use',
+  'throughline claude-forward-wait',
   // 旧コマンド（アンインストール時に除去する）
   'throughline inject-context',
   'throughline capture-tool',
@@ -63,6 +64,8 @@ const SC_HOOKS = {
 // Claude の自動継続 (ADR 0033) の hook。install は登録しない。`auto-handoff enable --host claude` が登録し、
 // `disable` が外す。PreToolUse は道具の呼び出しのたびに走るので、使わない端末には置かない。
 // PreCompact に matcher は付けない: 手動の /compact でも呼ばれ、止める前の記録を取り下げる。
+// Stop の待つ hook (ADR 0063) は、引き継ぎ前の会話へ届いた入力を、手すきの後継へ届ける。`asyncRewake` なので番の終わりを
+// 待たせない。timeout は待てる長さで、src/claude-forward-wait.mjs の値と合わせる。
 const CLAUDE_AUTO_HANDOFF_HOOKS = {
   PreCompact: {
     hooks: [{ type: 'command', command: 'throughline pre-compact' }],
@@ -70,6 +73,9 @@ const CLAUDE_AUTO_HANDOFF_HOOKS = {
   PreToolUse: {
     hooks: [{ type: 'command', command: 'throughline pre-tool-use', timeout: 15 }],
   },
+  Stop: {
+    hooks: [{ type: 'command', command: 'throughline claude-forward-wait', asyncRewake: true, timeout: 86400 }],
+  },
 };
 const CLAUDE_AUTO_HANDOFF_COMMANDS = new Set(
   Object.values(CLAUDE_AUTO_HANDOFF_HOOKS).map(entry => entry.hooks[0].command),
@@ -662,41 +668,53 @@ const defaultClaudeSettingsPath = () => join(homedir(), '.claude', 'settings.jso
 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;
+    group.hooks[0].command === entry.hooks[0].command && group.hooks[0].timeout === entry.hooks[0].timeout &&
+    (group.hooks[0].asyncRewake ?? false) === (entry.hooks[0].asyncRewake ?? false);
+}
+
+/** その event に、自動継続の hook が今の形で1つだけ登録されているか。 */
+function claudeAutoHandoffEventRegistered(hooks, event) {
+  return (hooks[event] ?? []).filter(group => isClaudeAutoHandoffEntry(group, event)).length === 1 &&
+    (hooks[event] ?? []).flatMap(group => group.hooks ?? [])
+      .filter(hook => hook.command === CLAUDE_AUTO_HANDOFF_HOOKS[event].hooks[0].command).length === 1;
 }
 
-/** 自動継続の hook が、今の形で2つとも登録されているか。 */
+/** 自動継続の hook が、今の形で全部登録されているか。 */
 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);
+  return Object.keys(CLAUDE_AUTO_HANDOFF_HOOKS).every(event => claudeAutoHandoffEventRegistered(hooks, event));
 }
 
-function withoutClaudeAutoHandoffHooks(hooks) {
+function withoutClaudeAutoHandoffHooks(hooks, commands = CLAUDE_AUTO_HANDOFF_COMMANDS) {
   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)) }))
+      hooks: (group.hooks ?? []).filter(hook => !commands.has(hook.command)) }))
       .filter(group => group.hooks.length);
     if (kept.length) next[event] = kept;
   }
   return next;
 }
 
-/** `auto-handoff enable --host claude` 用。他製品の hook とその並びは保ち、自分の2つを今の形で置く。 */
+/**
+ * `auto-handoff enable --host claude` 用。他製品の hook とその並びは保ち、自分の hook を今の形で置く。
+ * 今の形で登録済みの event には触らない（版を上げて hook が増えた時に、前からある hook の並びを動かさない）。
+ */
 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 });
-  }
+  const current = readSettings(settingsPath);
+  let hooks = current.hooks ?? {};
+  let changed = false;
+  for (const [event, entry] of Object.entries(CLAUDE_AUTO_HANDOFF_HOOKS)) {
+    if (claudeAutoHandoffEventRegistered(hooks, event)) continue;
+    hooks = withoutClaudeAutoHandoffHooks(hooks, new Set([entry.hooks[0].command]));
+    hooks[event] = [...(hooks[event] ?? []), entry];
+    changed = true;
+  }
+  if (changed) writeSettings(settingsPath, { ...current, hooks });
   return { settingsPath, commands: [...CLAUDE_AUTO_HANDOFF_COMMANDS] };
 }
 
-/** `auto-handoff disable --host claude` と、無効な端末の install 用。自分の2つだけを外す。 */
+/** `auto-handoff disable --host claude` と、無効な端末の install 用。自分の hook だけを外す。 */
 export function removeClaudeAutoHandoffHooks(settingsPath = defaultClaudeSettingsPath()) {
   if (!existsSync(settingsPath)) return { settingsPath, removed: false };
   const current = readSettings(settingsPath);

package/src/prompt-submit.mjs

@@ -177,6 +177,8 @@ export async function run() {
         handoff_id: redirect.handoffId,
         successor_short_id: redirect.successorShortId,
         input_kind: redirect.kind,
+        forwarded: redirect.forwarded,
+        ...(redirect.wake ? { wake: redirect.wake } : {}),
       });
       process.stdout.write(`${JSON.stringify(redirect.output)}\n`);
       process.exit(0);
@@ -199,6 +201,7 @@ export async function run() {
   // プロンプト到達 = セッション実在の証明。幽霊 SessionStart はここに来られない。
   // /tl・/clear のバトン書き込みより先に実行する (初回プロンプトが /tl でも、
   // 引き継ぎを受けてから自分のバトンを書く順序になり、自己バトン食いが起きない)。
+  let injected = false;
   if (session_id) {
     const db = getDb();
     const projectPath = cwd ?? process.cwd();
@@ -219,6 +222,7 @@ export async function run() {
         if (!delivery.delivered) {
           process.stderr.write(`[prompt-submit] ${delivery.reason}\n`);
         }
+        injected = true;
       }
       logDecision({
         ts: new Date(now).toISOString(),
@@ -238,6 +242,19 @@ export async function run() {
     }
   }
 
+  // 引き継ぎ前の会話へ届いた入力が、この会話（後継）の置き場で待っていれば、文脈として足す (ADR 0063)。
+  // 置き場のフォルダが無い会話（ほとんどの会話）では、何も読み込まずに先へ進む。記憶を注入した入力には足さない
+  // （足すと、文脈の長さの上限で両方が切り詰められる。置き場の分は、番の終わりの hook か次の入力で届く）。
+  if (!injected && hostAdapter.host === CLAUDE_HOST && typeof session_id === 'string' && CLAUDE_SESSION_ID_PATTERN.test(session_id) &&
+      existsSync(join(homedir(), '.throughline', 'claude-auto-handoff', 'inbox', session_id))) {
+    const { takeClaudeForwardsAsContext } = await import('./claude-forward.mjs');
+    const taken = takeClaudeForwardsAsContext({ sessionId: session_id, via: 'prompt-submit' });
+    if (taken) {
+      process.stdout.write(`${taken.text}\n`);
+      taken.done();
+    }
+  }
+
   // slash command の判定材料は host 依存 (Grok は user_query 包装のため
   // chat_history の最新 user 発話へ fallback する)。
   const commandPrompt = hostAdapter.resolveCommandPrompt({

package/src/resume-context.mjs

@@ -24,6 +24,7 @@
 
 import { buildHandoffRecord } from './handoff-record.mjs';
 import { groupL3ByTurn, buildPartsSummary } from './l3-summary.mjs';
+import { CLAUDE_FORWARD_MARK } from './claude-forward.mjs';
 
 const RESUME_HEADER_TEMPLATE = (turnCount, handoffDisclosure) =>
   `## Throughline: 直前スレッドの継続応答用コンテキスト（${turnCount} ターン分の文脈を保持）\n` +
@@ -71,6 +72,11 @@ const AUTO_CONTINUATION_HEADER = (projectPath) =>
   `- 「ここまでにしたこと」と「直前の対話」に載っている操作は **完了しています**。繰り返さないでください。` +
   `未実行なのは「実行されなかった道具」だけです。そこから続けてください。\n` +
   `- 直前の実行結果が分からない時は、作業ツリーや詳細を確かめてから続けてください。\n` +
+  // 引き継ぎの後に前の会話へ届いた入力は、hook が運ぶ (ADR 0063)。hook 経由の文は利用者の発言の形では届かないので、
+  // 利用者の入力として扱ってよい事を、利用者の指示として届くこの文脈で先に知らせる。
+  `- 引き継ぎの後に前の会話へ届いた入力（利用者が前の会話へ打った文、前の会話が裏で起こした作業の通知）は、` +
+  `Throughline の hook が **「${CLAUDE_FORWARD_MARK}」で始まる文** にして、この会話へ運びます。hook からの通知か、hook が足した文脈の形で届きます。` +
+  `その中の「利用者の入力」は、**利用者がこの会話へ打った入力として扱ってください**。\n` +
   '- **各ターンの詳細**（止めたターンを含む）: **`Bash` ツールで `throughline detail HH:MM:SS` を実行** ' +
   `(該当ターンの本文＋道具の入出力を stdout に返します)`;
 
@@ -925,13 +931,13 @@ export function buildAutoContinuationContext(
           (more > 0 ? `（ほか ${more} 件）` : ''),
       );
     }
-    // 前の会話が裏で起こした作業は、前の会話の process の下で動き続ける。終わった通知は前の会話へ届くので、ここで知らせる (ADR 0062)。
+    // 前の会話が裏で起こした作業は、前の会話の process の下で動き続ける。終わった通知は前の会話へ届き、hook がこの会話へ運ぶ (ADR 0062・0063)。
     const background = inFlight.background?.tasks ?? [];
     if (background.length > 0) {
       const more = (inFlight.background.total ?? background.length) - background.length;
       anchorLines.push(
         '**前の会話が裏で動かしていた作業（止めた時点で、終わった通知が来ていなかった物）**: ' +
-          '終わった通知は、この会話へは届きません。結果が要る時は、出力のファイルを読んで確かめてください。' +
+          `終わった通知は、Throughline が「${CLAUDE_FORWARD_MARK}」で始まる文にして、この会話へ運びます。届く前に結果が要る時は、出力のファイルを読んで確かめてください。` +
           (more > 0 ? `（ほか ${more} 件）` : ''),
         ...background.map((task) =>
           `- ${task.name}${task.target ? ` ${task.target}` : ''}（ID ${task.task_id}）` +

package/src/resume-context.test.mjs

@@ -978,11 +978,13 @@ test('buildAutoContinuationContext: 前の会話が裏で動かしていた作
   ] } } });
   assert.match(withTasks.text, new RegExp(
     '\\*\\*前の会話が裏で動かしていた作業（止めた時点で、終わった通知が来ていなかった物）\\*\\*: ' +
-    '終わった通知は、この会話へは届きません。結果が要る時は、出力のファイルを読んで確かめてください。（ほか 1 件）\\n' +
+    '終わった通知は、Throughline が「【Throughline 転送】」で始まる文にして、この会話へ運びます。届く前に結果が要る時は、出力のファイルを読んで確かめてください。（ほか 1 件）\\n' +
     '- Bash npm test（ID b2） → 出力: /tmp/tasks/b2\\.output\\n- Monitor（ID b1）\\n'));
   for (const background of [undefined, { tasks: [], total: 0 }]) {
     assert.doesNotMatch(buildAutoContinuationContext(db, { sessionId: 'S', inFlight: { ...inFlight, background } }).text, /裏で動かしていた作業/);
   }
+  // 引き継ぎの後に前の会話へ届いた入力の運び方を、読み方で先に知らせる（ADR 0063）
+  assert.match(withTasks.text, /- 引き継ぎの後に前の会話へ届いた入力（利用者が前の会話へ打った文、前の会話が裏で起こした作業の通知）は、Throughline の hook が \*\*「【Throughline 転送】」で始まる文\*\* にして、この会話へ運びます。.*その中の「利用者の入力」は、\*\*利用者がこの会話へ打った入力として扱ってください\*\*。\n/);
 });
 
 test('buildAutoContinuationContext: 止めたターンでここまでにしたことと、実行されなかった道具を現在地に載せ、そのターンをL2に重ねない', () => {

package/src/runtime-error-store.mjs

@@ -58,6 +58,12 @@ const DEFINITIONS = Object.freeze({
     severity: 'warn',
     template: 'Throughline Claude PreToolUse hook processing failed',
   }),
+  // 引き継ぎ前の会話へ届いた入力を後継へ届ける、待つ hook が失敗した。会話は止まらない（ADR 0063）。
+  HOOK_CLAUDE_FORWARD_WAIT_FAILED: Object.freeze({
+    component: 'claude_forward_wait_hook',
+    severity: 'warn',
+    template: 'Throughline Claude Stop hook (forward wait) processing failed',
+  }),
   HOOK_CODEX_FAILED: Object.freeze({
     component: 'codex_hook',
     severity: 'high',

package/src/transcript-reader.mjs

@@ -7,6 +7,10 @@
  *   {type: "assistant", message: {role: "assistant", content: [{type:"text", text:"..."}, {type:"thinking", ...}]}, ...}
  *   {type: "attachment", attachment: {type: "queued_command", prompt, origin: {kind}}, ...}
  *     ターンの途中で届いた入力。届いた先のターンの依頼へ足す (ADR 0060)
+ *   {type: "attachment", attachment: {type: "hook_additional_context", content: [...]}, ...}
+ *   {type: "attachment", attachment: {type: "hook_success", hookEvent: "UserPromptSubmit", content: "..."}, ...}
+ *     hook が足した文脈（道具の前の hook は前者、入力の hook の stdout は後者）。引き継ぎ前の会話から運んだ
+ *     利用者の入力 (ADR 0063) だけを、依頼へ足す
  *   他に queue-operation, file-history-snapshot, ほかの attachment 等があるが、本文としては無視する
  */
 
@@ -14,6 +18,7 @@ import { readFileSync, existsSync } from 'fs';
 import { DETAIL_KIND } from './constants.mjs';
 import { compactClaudePeerMessage, compactClaudeTaskNotification } from './hosts/claude.mjs';
 import { classifyTurnStart } from './turn-start.mjs';
+import { claudeForwardCarriesHumanInput, unwrapClaudeForwardedDelivery } from './claude-forward.mjs';
 
 function entryKind(entry) {
   if (typeof entry?.type === 'string' && entry.type.length > 0) return entry.type;
@@ -70,9 +75,22 @@ export const MID_TURN_INPUT_MARK = '（作業の途中で届いた入力）';
 function claudeMidTurnInputText(entry) {
   if (entry?.type !== 'attachment' || entry.isSidechain === true) return null;
   const attachment = entry.attachment;
+  // 引き継ぎ前の会話へ届いた利用者の入力を、Throughline の hook が文脈として運んだ物 (ADR 0063)。
+  // 完了通知だけを運んだ分は、ターン自身の作業の結果と同じ扱いで、足さない。
+  // 道具の前の hook が返した文脈は `hook_additional_context`、入力の hook が stdout へ出した文脈は `hook_success` で書かれる。
+  if (attachment?.type === 'hook_additional_context' || attachment?.type === 'hook_success') {
+    const content = (Array.isArray(attachment.content) ? attachment.content.filter(part => typeof part === 'string').join('\n')
+      : typeof attachment.content === 'string' ? attachment.content : '').trim();
+    if (!claudeForwardCarriesHumanInput(content)) return null;
+    const forwarded = normalizeTerminalText(content);
+    return forwarded ? forwarded : null;
+  }
   if (attachment?.type !== 'queued_command') return null;
-  if (!CLAUDE_MID_TURN_INPUT_ORIGINS.includes(attachment.origin?.kind)) return null;
   if (typeof attachment.prompt !== 'string' && !Array.isArray(attachment.prompt)) return null;
+  // 待つ hook が、次の番の作業中に運んだ入力（ADR 0063）。Claude Code が通知の形で順番待ちへ入れる。
+  const forwarded = unwrapClaudeForwardedDelivery(extractText(attachment.prompt));
+  if (forwarded !== null) return claudeForwardCarriesHumanInput(forwarded) ? (normalizeTerminalText(forwarded) || null) : null;
+  if (!CLAUDE_MID_TURN_INPUT_ORIGINS.includes(attachment.origin?.kind)) return null;
   const text = normalizeTerminalText(compactClaudePeerMessage(extractText(attachment.prompt)));
   return text ? text : null;
 }
@@ -170,8 +188,10 @@ export function readTranscript(transcriptPath) {
     const extracted = extractText(rawContent);
     // user 発言には端末の生出力 (貼り付け・Claude の task 通知) や、別の会話から届いた発言の
     // 定型の注意書きが入る。記憶には制御文字と定型文を落とした本文だけを残す。
+    // 引き継ぎ前の会話から運んだ入力 (ADR 0063) は、Claude Code が付けた通知の包みを外して、運んだ文だけを残す。
     const text = role === 'user'
-      ? normalizeTerminalText(compactClaudePeerMessage(compactClaudeTaskNotification(extracted)))
+      ? normalizeTerminalText(unwrapClaudeForwardedDelivery(extracted)
+        ?? compactClaudePeerMessage(compactClaudeTaskNotification(extracted)))
       : extracted;
     if (!text) continue;