throughline 0.9.1 → 0.10.1

package/src/codex-capture.mjs

@@ -1,23 +1,19 @@
 import { parseCodexRolloutFile } from './codex-rollout-memory.mjs';
 import { defaultCodexHome, findCodexThreadCandidate } from './codex-thread-index.mjs';
-
-export const CODEX_SESSION_PREFIX = 'codex:';
-
-export function buildCodexThroughlineSessionId(threadId) {
-  if (typeof threadId !== 'string' || threadId.trim().length === 0) {
-    throw new Error('threadId is required');
-  }
-  return `${CODEX_SESSION_PREFIX}${threadId.trim()}`;
-}
-
-export function isCodexThroughlineSessionId(sessionId) {
-  return typeof sessionId === 'string' && sessionId.startsWith(CODEX_SESSION_PREFIX);
-}
-
-export function codexSessionIdToThreadId(sessionId) {
-  if (!isCodexThroughlineSessionId(sessionId)) return null;
-  return sessionId.slice(CODEX_SESSION_PREFIX.length) || null;
-}
+import {
+  CODEX_SESSION_PREFIX,
+  buildCodexThroughlineSessionId,
+  codexSessionIdToThreadId,
+  isCodexSessionId,
+} from './hosts/identity.mjs';
+
+// session identity の正本は hosts/identity.mjs。既存 import 面のため再 export する。
+export {
+  CODEX_SESSION_PREFIX,
+  buildCodexThroughlineSessionId,
+  codexSessionIdToThreadId,
+};
+export const isCodexThroughlineSessionId = isCodexSessionId;
 
 export function captureCodexRolloutToDb(
   db,

package/src/codex-handoff-model-smoke.mjs

@@ -1,4 +1,4 @@
-import { spawnPortableSync } from './portable-spawn-sync.mjs';
+import { spawnPortableSync } from './os/portable-spawn-sync.mjs';
 
 export const CODEX_HANDOFF_MODEL_SMOKE_ENV = 'THROUGHLINE_EXPERIMENTAL_CODEX_HANDOFF_MODEL_SMOKE';
 export const DEFAULT_CODEX_HANDOFF_MODEL_SMOKE_TIMEOUT_MS = 120_000;

package/src/codex-sidecar.mjs

@@ -1,4 +1,4 @@
-import { spawnPortableSync } from './portable-spawn-sync.mjs';
+import { spawnPortableSync } from './os/portable-spawn-sync.mjs';
 
 export const CODEX_SIDECAR_WORKFLOWS = Object.freeze([
   'review',

package/src/completed-turn-receipts.mjs

@@ -8,12 +8,12 @@ import {
   rmSync,
   writeFileSync,
 } from 'node:fs';
-import childProcess from 'node:child_process';
-import { homedir, platform as hostPlatform } from 'node:os';
+import { homedir } from 'node:os';
 import { dirname, join } from 'node:path';
 import { DatabaseSync } from 'node:sqlite';
 import { hashAuditorBody } from './body-digest.mjs';
 import { normalizeProjectPathForCompare } from './project-path.mjs';
+import { applyAndVerifyWindowsAcl, isWindows, verifyWindowsAcl } from './os/windows-acl.mjs';
 
 export const COMPLETED_TURN_RECEIPT_STORE_SCHEMA = 'throughline.completed_turn_receipts.v1';
 export const COMPLETED_TURN_RECEIPT_SCHEMA_VERSION = '1.0';
@@ -21,7 +21,6 @@ export const COMPLETED_TURN_RECEIPT_LIMIT = 256;
 
 const PRIVATE_DIRECTORY_CAPABILITY = Symbol('throughline.completed-turn-receipt-directory');
 // CI実測でPowerShellコールドスタートが3.0〜3.2秒に達しflakeしたため15秒 (run 29586852389 / 29628634501)
-const WINDOWS_ACL_TIMEOUT_MS = 15_000;
 
 export function defaultCompletedTurnReceiptStorePath(projectSha256, env = process.env) {
   if (!isSha256(projectSha256)) throw new TypeError('projectSha256 must be a SHA-256 digest');
@@ -351,30 +350,4 @@ function assertExactOptions(options) {
     throw new TypeError('completed turn receipt options are invalid');
   }
 }
-function isWindows(env = process.env) { return env.OS === 'Windows_NT' || hostPlatform() === 'win32'; }
-
-function applyAndVerifyWindowsAcl(path, directory) { runWindowsAclScript(path, directory, WINDOWS_ACL_APPLY_SCRIPT); }
-function verifyWindowsAcl(path, directory) { runWindowsAclScript(path, directory, WINDOWS_ACL_VERIFY_SCRIPT); }
-function runWindowsAclScript(path, directory, script) {
-  const result = childProcess.spawnSync('powershell.exe', ['-NoProfile', '-NonInteractive', '-Command', script], {
-    env: { ...process.env, THROUGHLINE_ACL_PATH: path, THROUGHLINE_ACL_DIRECTORY: directory ? '1' : '0' },
-    stdio: 'ignore', timeout: WINDOWS_ACL_TIMEOUT_MS, windowsHide: true,
-  });
-  if (result.status !== 0) throw new Error('Windows owner-only ACL verification failed');
-}
 
-const WINDOWS_ACL_VERIFY_SCRIPT = String.raw`
-$p=$env:THROUGHLINE_ACL_PATH; $isDir=$env:THROUGHLINE_ACL_DIRECTORY -eq '1'; $sid=[System.Security.Principal.WindowsIdentity]::GetCurrent().User.Value
-$acl=if($isDir){[System.IO.Directory]::GetAccessControl($p)}else{[System.IO.File]::GetAccessControl($p)}
-$owner=$acl.GetOwner([System.Security.Principal.SecurityIdentifier]).Value
-if($owner -ne $sid){exit 41}; $rules=@($acl.GetAccessRules($true,$true,[System.Security.Principal.SecurityIdentifier])); if($rules.Count -ne 1){exit 42}
-$r=$rules[0]; if($r.IdentityReference.Value -ne $sid -or $r.AccessControlType -ne 'Allow' -or $r.IsInherited -or ($r.FileSystemRights -band [System.Security.AccessControl.FileSystemRights]::FullControl) -ne [System.Security.AccessControl.FileSystemRights]::FullControl){exit 43}
-`;
-
-const WINDOWS_ACL_APPLY_SCRIPT = String.raw`
-$p=$env:THROUGHLINE_ACL_PATH; $sid=[System.Security.Principal.WindowsIdentity]::GetCurrent().User
-$isDir=$env:THROUGHLINE_ACL_DIRECTORY -eq '1'; $acl=if($isDir){New-Object System.Security.AccessControl.DirectorySecurity}else{New-Object System.Security.AccessControl.FileSecurity}; $acl.SetAccessRuleProtection($true,$false)
-$flags=if($isDir){[System.Security.AccessControl.InheritanceFlags]'ContainerInherit, ObjectInherit'}else{[System.Security.AccessControl.InheritanceFlags]::None}
-$rule=New-Object System.Security.AccessControl.FileSystemAccessRule($sid,'FullControl',$flags,[System.Security.AccessControl.PropagationFlags]::None,[System.Security.AccessControl.AccessControlType]::Allow)
-$acl.SetOwner($sid); $acl.AddAccessRule($rule); if($isDir){[System.IO.Directory]::SetAccessControl($p,$acl)}else{[System.IO.File]::SetAccessControl($p,$acl)}
-` + WINDOWS_ACL_VERIFY_SCRIPT;

package/src/completed-turn-receipts.test.mjs

@@ -12,7 +12,7 @@ import {
   writeCompletedTurnReceipt,
 } from './completed-turn-receipts.mjs';
 import { seedCompletedTurnReceiptStore } from './completed-turn-receipts-test-fixture.mjs';
-import { verifyWindowsPrivateAcl } from './windows-acl-test-helper.mjs';
+import { verifyWindowsPrivateAcl } from './os/windows-acl-test-helper.mjs';
 
 function sandbox() {
   const root = mkdtempSync(join(tmpdir(), 'throughline-completed-receipts-'));

package/src/grok-history-inject.mjs

@@ -0,0 +1,71 @@
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'node:fs';
+import { dirname } from 'node:path';
+
+// Grok includes native injections only when synthetic_reason is
+// system_reminder. A custom reason is written to disk and dropped from
+// the model prompt (live session 01a00cf9).
+export const GROK_HANDOFF_SYNTHETIC_REASON = 'system_reminder';
+export const GROK_HANDOFF_MARKER = 'data-throughline-handoff="1"';
+
+function rowText(entry) {
+  if (typeof entry?.content === 'string') return entry.content;
+  if (Array.isArray(entry?.content)) {
+    return entry.content
+      .filter((block) => block && block.type === 'text' && typeof block.text === 'string')
+      .map((block) => block.text)
+      .join('');
+  }
+  return '';
+}
+
+function parseLines(raw) {
+  const rows = [];
+  for (const line of raw.split('\n')) {
+    const trimmed = line.trim();
+    if (!trimmed) continue;
+    try {
+      rows.push(JSON.parse(trimmed));
+    } catch {
+      rows.push({ type: 'unparsed', content: line });
+    }
+  }
+  return rows;
+}
+
+/**
+ * Insert Throughline resume text as a Grok synthetic user row immediately
+ * before the latest <user_query>. Grok ignores UserPromptSubmit stdout.
+ */
+export function injectGrokHandoffContext(transcriptPath, injectionText) {
+  if (!transcriptPath || typeof injectionText !== 'string' || injectionText.length === 0) {
+    return { injected: false, reason: 'missing_path_or_text' };
+  }
+
+  const existing = existsSync(transcriptPath) ? readFileSync(transcriptPath, 'utf8') : '';
+  const rows = parseLines(existing);
+  if (rows.some((row) => rowText(row).includes(GROK_HANDOFF_MARKER))) {
+    return { injected: false, reason: 'already_present' };
+  }
+
+  const reminder = {
+    type: 'user',
+    content: [{
+      type: 'text',
+      text: `<system-reminder ${GROK_HANDOFF_MARKER}>\n${injectionText}\n</system-reminder>`,
+    }],
+    synthetic_reason: GROK_HANDOFF_SYNTHETIC_REASON,
+  };
+
+  let insertAt = rows.length;
+  for (let i = rows.length - 1; i >= 0; i--) {
+    if (rows[i].type === 'user' && rowText(rows[i]).includes('<user_query>')) {
+      insertAt = i;
+      break;
+    }
+  }
+  rows.splice(insertAt, 0, reminder);
+
+  mkdirSync(dirname(transcriptPath), { recursive: true });
+  writeFileSync(transcriptPath, `${rows.map((row) => JSON.stringify(row)).join('\n')}\n`, 'utf8');
+  return { injected: true, reason: null, insertAt };
+}

package/src/grok-history-inject.test.mjs

@@ -0,0 +1,69 @@
+import { test } from 'node:test';
+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 {
+  GROK_HANDOFF_SYNTHETIC_REASON,
+  injectGrokHandoffContext,
+} from './grok-history-inject.mjs';
+
+test('injectGrokHandoffContext inserts reminder before the latest user_query', () => {
+  const dir = mkdtempSync(join(tmpdir(), 'tl-grok-inject-'));
+  const path = join(dir, 'chat_history.jsonl');
+  writeFileSync(
+    path,
+    [
+      JSON.stringify({ type: 'system', content: 'sys' }),
+      JSON.stringify({ type: 'user', content: [{ type: 'text', text: '<user_info>x</user_info>' }] }),
+      JSON.stringify({ type: 'user', content: [{ type: 'text', text: '<user_query>\nこれかな？\n</user_query>' }] }),
+    ].join('\n') + '\n',
+  );
+  try {
+    const result = injectGrokHandoffContext(path, 'old assistant body');
+    assert.equal(result.injected, true);
+    const rows = readFileSync(path, 'utf8')
+      .split('\n')
+      .filter(Boolean)
+      .map((line) => JSON.parse(line));
+    assert.equal(rows.length, 4);
+    assert.equal(rows[2].synthetic_reason, GROK_HANDOFF_SYNTHETIC_REASON);
+    assert.match(rows[2].content[0].text, /data-throughline-handoff="1"/);
+    assert.match(rows[2].content[0].text, /old assistant body/);
+    assert.match(rows[3].content[0].text, /これかな？/);
+  } finally {
+    rmSync(dir, { recursive: true, force: true });
+  }
+});
+
+test('injectGrokHandoffContext appends when no user_query exists yet', () => {
+  const dir = mkdtempSync(join(tmpdir(), 'tl-grok-inject-'));
+  const path = join(dir, 'chat_history.jsonl');
+  writeFileSync(path, `${JSON.stringify({ type: 'system', content: 'sys' })}\n`);
+  try {
+    const result = injectGrokHandoffContext(path, 'memory');
+    assert.equal(result.injected, true);
+    const rows = readFileSync(path, 'utf8')
+      .split('\n')
+      .filter(Boolean)
+      .map((line) => JSON.parse(line));
+    assert.equal(rows.at(-1).synthetic_reason, GROK_HANDOFF_SYNTHETIC_REASON);
+  } finally {
+    rmSync(dir, { recursive: true, force: true });
+  }
+});
+
+test('injectGrokHandoffContext is idempotent', () => {
+  const dir = mkdtempSync(join(tmpdir(), 'tl-grok-inject-'));
+  const path = join(dir, 'chat_history.jsonl');
+  try {
+    assert.equal(injectGrokHandoffContext(path, 'memory').injected, true);
+    assert.deepEqual(injectGrokHandoffContext(path, 'memory'), {
+      injected: false,
+      reason: 'already_present',
+    });
+  } finally {
+    rmSync(dir, { recursive: true, force: true });
+  }
+});

package/src/haiku-summarizer.mjs

@@ -50,7 +50,7 @@ import {
   CODEX_SIDECAR_STATUS,
   runCodexSidecarCommand,
 } from './codex-sidecar.mjs';
-import { spawnPortableSync } from './portable-spawn-sync.mjs';
+import { spawnPortableSync } from './os/portable-spawn-sync.mjs';
 
 const MODEL = 'claude-haiku-4-5-20251001';
 // Codex CLI 要約の既定。gpt-5.6-luna@low@1/5 は 2026-07-17 の実測評価で選定

package/src/handoff-record.mjs

@@ -6,9 +6,11 @@
  * persisted to DB; adapters can render it for Claude, Codex, or diagnostics.
  */
 
+import { CODEX_SESSION_PREFIX } from './hosts/identity.mjs';
+
 export const HANDOFF_RECORD_VERSION = 1;
 export const N_RECENT_L2 = 20;
-export const CODEX_SESSION_PREFIX = 'codex:';
+export { CODEX_SESSION_PREFIX };
 
 const DEFAULT_INTENT = 'continue implementation';
 const DEFAULT_CONSTRAINTS = [

package/src/hook-entrypoints.test.mjs

@@ -74,65 +74,196 @@ test('hook modules can be imported without executing their hook body', () => {
   }
 });
 
-test('Grok camelCase envelopes are unsupported no-op before Throughline side effects [GF04T]', () => {
+test('Grok camelCase envelopes register a grok: session instead of no-op', () => {
   const home = makeTempHome();
   const project = makeTempProject();
+  const sessionId = '01a00aa2-50f8-7791-86fd-df2d27cf003e';
   const common = {
-    sessionId: 'grok-session',
+    sessionId,
     cwd: project,
     workspaceRoot: project,
-    timestamp: '2026-08-14T00:00:00Z',
+    timestamp: '2026-08-17T00:00:00Z',
     permissionMode: 'default',
   };
-  const cases = [
-    {
-      event: 'SessionStart',
-      entrypoint: 'src/session-start.mjs',
-      input: { ...common, hookEventName: 'session_start', source: 'startup' },
-    },
-    {
-      event: 'UserPromptSubmit',
-      entrypoint: 'src/prompt-submit.mjs',
-      input: { ...common, hookEventName: 'user_prompt_submit', prompt: 'hello' },
-    },
-    {
-      event: 'Stop',
-      entrypoint: 'src/turn-processor.mjs',
-      input: {
+
+  try {
+    const start = runNode([join(REPO_ROOT, 'src/session-start.mjs')], {
+      home,
+      cwd: project,
+      input: JSON.stringify({ ...common, hookEventName: 'session_start', source: 'startup' }),
+    });
+    assert.equal(start.status, 0, start.stderr);
+
+    const prompt = runNode([join(REPO_ROOT, 'src/prompt-submit.mjs')], {
+      home,
+      cwd: project,
+      input: JSON.stringify({ ...common, hookEventName: 'user_prompt_submit', prompt: 'hello grok' }),
+    });
+    assert.equal(prompt.status, 0, prompt.stderr);
+
+    const historyDir = join(home, '.grok', 'sessions', encodeURIComponent(project), sessionId);
+    mkdirSync(historyDir, { recursive: true });
+    writeFileSync(
+      join(historyDir, 'chat_history.jsonl'),
+      [
+        JSON.stringify({ type: 'user', content: [{ type: 'text', text: 'hello grok' }] }),
+        JSON.stringify({ type: 'assistant', content: 'captured reply' }),
+      ].join('\n'),
+    );
+    const stop = runNode([join(REPO_ROOT, 'src/turn-processor.mjs')], {
+      home,
+      cwd: project,
+      input: JSON.stringify({
         ...common,
         hookEventName: 'stop',
-        reason: 'end_turn',
-        stopHookActive: false,
-        lastAssistantMessage: 'done',
-        backgroundTasks: [],
-        sessionCrons: [],
-      },
-    },
-  ];
+        lastAssistantMessage: 'captured reply',
+      }),
+    });
+    assert.equal(stop.status, 0, stop.stderr);
+
+    const db = openDb(home);
+    const row = db.prepare('SELECT session_id, project_path FROM sessions').get();
+    assert.equal(row.session_id, `grok:${sessionId}`);
+    assert.equal(row.project_path, project);
+    const bodies = db.prepare('SELECT role, text FROM bodies ORDER BY role').all();
+    assert.deepEqual(
+      bodies.map((b) => ({ role: b.role, text: b.text })),
+      [
+        { role: 'assistant', text: 'captured reply' },
+        { role: 'user', text: 'hello grok' },
+      ],
+    );
+    db.close();
+  } finally {
+    rmSync(project, { recursive: true, force: true });
+    rmSync(home, { recursive: true, force: true });
+  }
+});
+
+test('Grok Stop with updates.jsonl transcriptPath still captures L2 from chat_history', () => {
+  const home = makeTempHome();
+  const project = makeTempProject();
+  const sessionId = '01a00b38-87ea-7670-8f7d-a9fe937263c5';
+  const common = {
+    sessionId,
+    cwd: project,
+    workspaceRoot: project,
+    timestamp: '2026-08-17T00:00:00Z',
+    permissionMode: 'default',
+  };
 
   try {
-    const results = cases.map(({ event, entrypoint, input }) => {
-      const result = runNode([join(REPO_ROOT, entrypoint)], {
-        home,
-        cwd: project,
-        input: JSON.stringify(input),
-        env: { THROUGHLINE_NO_VSCODE: '0', TERM_PROGRAM: 'vscode' },
-      });
-      return { event, status: result.status, stdout: result.stdout, stderr: result.stderr };
+    const start = runNode([join(REPO_ROOT, 'src/session-start.mjs')], {
+      home,
+      cwd: project,
+      input: JSON.stringify({ ...common, hookEventName: 'session_start', source: 'startup' }),
+    });
+    assert.equal(start.status, 0, start.stderr);
+
+    const historyDir = join(home, '.grok', 'sessions', encodeURIComponent(project), sessionId);
+    mkdirSync(historyDir, { recursive: true });
+    writeFileSync(
+      join(historyDir, 'updates.jsonl'),
+      JSON.stringify({
+        method: '_x.ai/session/update',
+        params: { update: { sessionUpdate: 'hook_execution', event_name: 'stop' } },
+      }) + '\n',
+    );
+    writeFileSync(
+      join(historyDir, 'chat_history.jsonl'),
+      [
+        JSON.stringify({ type: 'user', content: [{ type: 'text', text: 'hello grok' }] }),
+        JSON.stringify({ type: 'assistant', content: 'captured reply' }),
+      ].join('\n'),
+    );
+    const stop = runNode([join(REPO_ROOT, 'src/turn-processor.mjs')], {
+      home,
+      cwd: project,
+      input: JSON.stringify({
+        ...common,
+        hookEventName: 'stop',
+        transcriptPath: join(historyDir, 'updates.jsonl'),
+        lastAssistantMessage: 'captured reply',
+      }),
     });
+    assert.equal(stop.status, 0, stop.stderr);
 
+    const db = openDb(home);
+    const bodies = db.prepare('SELECT role, text FROM bodies ORDER BY role').all();
     assert.deepEqual(
-      {
-        results,
-        throughlineStateExists: existsSync(join(home, '.throughline')),
-        vscodeTaskExists: existsSync(join(project, '.vscode', 'tasks.json')),
-      },
-      {
-        results: cases.map(({ event }) => ({ event, status: 0, stdout: '', stderr: '' })),
-        throughlineStateExists: false,
-        vscodeTaskExists: false,
-      },
+      bodies.map((b) => ({ role: b.role, text: b.text })),
+      [
+        { role: 'assistant', text: 'captured reply' },
+        { role: 'user', text: 'hello grok' },
+      ],
     );
+    db.close();
+  } finally {
+    rmSync(project, { recursive: true, force: true });
+    rmSync(home, { recursive: true, force: true });
+  }
+});
+
+test('Grok wrapped /tl prompt writes a grok: baton', () => {
+  const home = makeTempHome();
+  const project = makeTempProject();
+  const sessionId = '01a00b38-87ea-7670-8f7d-a9fe937263c5';
+  try {
+    const result = runNode([join(REPO_ROOT, 'src/prompt-submit.mjs')], {
+      home,
+      cwd: project,
+      input: JSON.stringify({
+        sessionId,
+        cwd: project,
+        hookEventName: 'user_prompt_submit',
+        prompt:
+          '<user_query>\n/tl\n</user_query>\n<skill_information>\nThroughline saved the baton.\n</skill_information>',
+      }),
+    });
+    assert.equal(result.status, 0, result.stderr);
+    assert.match(result.stderr, /grok-continue exited/);
+
+    const db = openDb(home);
+    const row = db.prepare('SELECT project_path, session_id FROM handoff_batons').get();
+    assert.equal(row.project_path, project);
+    assert.equal(row.session_id, `grok:${sessionId}`);
+    db.close();
+  } finally {
+    rmSync(project, { recursive: true, force: true });
+    rmSync(home, { recursive: true, force: true });
+  }
+});
+
+test('Grok empty hook prompt still writes /tl baton from chat_history', () => {
+  const home = makeTempHome();
+  const project = makeTempProject();
+  const sessionId = '01a00b38-87ea-7670-8f7d-a9fe937263c5';
+  const historyDir = join(home, '.grok', 'sessions', encodeURIComponent(project), sessionId);
+  mkdirSync(historyDir, { recursive: true });
+  writeFileSync(
+    join(historyDir, 'chat_history.jsonl'),
+    JSON.stringify({
+      type: 'user',
+      content: [{ type: 'text', text: '<user_query>\n/tl\n</user_query>\n<skill_information>x</skill_information>' }],
+    }) + '\n',
+  );
+  try {
+    const result = runNode([join(REPO_ROOT, 'src/prompt-submit.mjs')], {
+      home,
+      cwd: project,
+      input: JSON.stringify({
+        sessionId,
+        cwd: project,
+        hookEventName: 'user_prompt_submit',
+      }),
+    });
+    assert.equal(result.status, 0, result.stderr);
+    assert.match(result.stderr, /grok-continue exited/);
+
+    const db = openDb(home);
+    const row = db.prepare('SELECT session_id FROM handoff_batons').get();
+    assert.equal(row.session_id, `grok:${sessionId}`);
+    db.close();
   } finally {
     rmSync(project, { recursive: true, force: true });
     rmSync(home, { recursive: true, force: true });
@@ -154,6 +285,7 @@ test('prompt-submit subprocess writes a /tl baton into an isolated DB', () => {
     });
 
     assert.equal(result.status, 0, result.stderr);
+    assert.equal(result.stderr.includes('grok-continue'), false);
 
     const db = openDb(home);
     const row = db.prepare('SELECT project_path, session_id FROM handoff_batons').get();
@@ -249,6 +381,87 @@ test('prompt-submit: non-baton prompt does not write any baton', () => {
   }
 });
 
+test('Grok first prompt injects handoff into chat_history instead of stdout', () => {
+  const home = makeTempHome();
+  const project = makeTempProject();
+  const oldId = '01a00aa2-50f8-7791-86fd-df2d27cf003e';
+  const newId = '01a00ce5-0169-7852-95c0-9e6b8cc50c06';
+  const historyDir = join(home, '.grok', 'sessions', encodeURIComponent(project), newId);
+  mkdirSync(historyDir, { recursive: true });
+  writeFileSync(
+    join(historyDir, 'chat_history.jsonl'),
+    [
+      JSON.stringify({ type: 'system', content: 'sys' }),
+      JSON.stringify({
+        type: 'user',
+        content: [{ type: 'text', text: '<user_query>\nこれかな？\n</user_query>' }],
+      }),
+    ].join('\n') + '\n',
+  );
+  try {
+    const baton = runNode([join(REPO_ROOT, 'src/prompt-submit.mjs')], {
+      home,
+      cwd: project,
+      input: JSON.stringify({
+        sessionId: oldId,
+        cwd: project,
+        hookEventName: 'user_prompt_submit',
+        prompt: '/tl',
+      }),
+    });
+    assert.equal(baton.status, 0, baton.stderr);
+
+    const db = openDb(home);
+    db.prepare(
+      `INSERT INTO sessions (session_id, project_path, status, created_at, updated_at)
+       VALUES (?, ?, 'active', 1, 1)`,
+    ).run(`grok:${oldId}`, project);
+    db.prepare(
+      `INSERT INTO bodies
+         (session_id, origin_session_id, turn_number, role, text, token_count, created_at)
+       VALUES (?, ?, 1, 'assistant', 'old assistant body', 4, 2)`,
+    ).run(`grok:${oldId}`, `grok:${oldId}`);
+    db.close();
+
+    const started = runNode([join(REPO_ROOT, 'src/session-start.mjs')], {
+      home,
+      cwd: project,
+      input: JSON.stringify({
+        sessionId: newId,
+        cwd: project,
+        hookEventName: 'session_start',
+        source: 'new',
+      }),
+    });
+    assert.equal(started.status, 0, started.stderr);
+
+    const firstPrompt = runNode([join(REPO_ROOT, 'src/prompt-submit.mjs')], {
+      home,
+      cwd: project,
+      input: JSON.stringify({
+        sessionId: newId,
+        cwd: project,
+        hookEventName: 'user_prompt_submit',
+        prompt: 'これかな？',
+      }),
+    });
+    assert.equal(firstPrompt.status, 0, firstPrompt.stderr);
+    assert.equal(firstPrompt.stdout, '', 'Grok must not rely on ignored hook stdout');
+
+    const rows = readFileSync(join(historyDir, 'chat_history.jsonl'), 'utf8')
+      .split('\n')
+      .filter(Boolean)
+      .map((line) => JSON.parse(line));
+    assert.equal(rows[1].synthetic_reason, 'system_reminder');
+    assert.match(rows[1].content[0].text, /data-throughline-handoff="1"/);
+    assert.match(rows[1].content[0].text, /old assistant body/);
+    assert.match(rows[2].content[0].text, /これかな？/);
+  } finally {
+    rmSync(project, { recursive: true, force: true });
+    rmSync(home, { recursive: true, force: true });
+  }
+});
+
 test('two-phase: session-start registers intent only; first prompt consumes baton and injects', () => {
   const home = makeTempHome();
   const project = makeTempProject();

package/src/hosts/claude.mjs

@@ -0,0 +1,27 @@
+/**
+ * hosts/claude.mjs — Claude host adapter
+ *
+ * Claude は Throughline の基準 host。hook payload は snake_case のまま届き、
+ * 引き継ぎ注入は UserPromptSubmit hook の stdout でモデルへ渡る。
+ */
+import { CLAUDE_HOST, hostOfSessionId } from './identity.mjs';
+
+export const claudeHostAdapter = Object.freeze({
+  host: CLAUDE_HOST,
+  matchesSessionId: (sessionId) => hostOfSessionId(sessionId) === CLAUDE_HOST,
+  // Claude Stop payload の last_assistant_message を transcript 可視化の
+  // barrier に使う (ADR 0012)。
+  waitsForStopTranscriptFlush: true,
+  // Claude は UserPromptSubmit stdout がそのままモデル可視 context になる。
+  deliverHandoffInjection({ text, stdout = process.stdout }) {
+    stdout.write(text + '\n');
+    return { delivered: true };
+  },
+  // Claude の prompt は裸の slash command がそのまま届く。
+  resolveCommandPrompt({ prompt }) {
+    return prompt;
+  },
+  afterBatonWrite() {
+    return { launched: false };
+  },
+});