throughline 0.9.1 → 0.10.0

package/src/cli/grok-continue.test.mjs

@@ -0,0 +1,239 @@
+import { test } from 'node:test';
+import assert from 'node:assert/strict';
+import { spawnSync } from 'node:child_process';
+import { readFileSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+import {
+  GROK_CONTINUE_PREAMBLE,
+  GROK_CONTINUE_REQUEST,
+  GROK_CONTINUE_WAIT,
+  appleScriptForLaunch,
+  buildContinuePlan,
+  buildGrokArgv,
+  buildGrokContinuePrompt,
+  buildLaunchScript,
+  parseArgs,
+  resolveGrokBin,
+  run,
+} from './grok-continue.mjs';
+
+const REPO_ROOT = fileURLToPath(new URL('../..', import.meta.url));
+const BIN_PATH = join(REPO_ROOT, 'bin/throughline.mjs');
+const CONTEXT = '固有事実：琥珀の合言葉は 9f3c2a。';
+
+function capture() {
+  let out = '';
+  let err = '';
+  return {
+    stdout: { write(chunk) { out += chunk; return true; } },
+    stderr: { write(chunk) { err += chunk; return true; } },
+    get out() { return out; },
+    get err() { return err; },
+  };
+}
+
+test('parseArgs accepts --session only', () => {
+  assert.deepEqual(parseArgs(['--session', 'grok:abc']), { sessionId: 'grok:abc' });
+  assert.throws(() => parseArgs(['--from', 'grok:abc']), /usage error/);
+  assert.throws(() => parseArgs(['--session']), /usage error/);
+  assert.throws(() => parseArgs([]), /usage error/);
+});
+
+test('first-user prompt is the locked text ending in wait', () => {
+  const prompt = buildGrokContinuePrompt(CONTEXT);
+  assert.equal(
+    prompt,
+    `${GROK_CONTINUE_PREAMBLE}\n\n${CONTEXT}\n\n${GROK_CONTINUE_REQUEST}\n\n${GROK_CONTINUE_WAIT}`,
+  );
+});
+
+test('grok argv is interactive grok with session id and no --rules', () => {
+  const argv = buildGrokArgv('/opt/grok/bin/grok', '11111111-1111-4111-8111-111111111111', CONTEXT);
+  assert.deepEqual(argv, [
+    '/opt/grok/bin/grok',
+    '--session-id',
+    '11111111-1111-4111-8111-111111111111',
+    CONTEXT,
+  ]);
+  assert.equal(argv.includes('--rules'), false);
+  assert.equal(argv.some((part) => String(part).includes('aiterm')), false);
+});
+
+test('launch script execs grok in the project cwd without --rules or aiterm', () => {
+  const script = buildLaunchScript({
+    cwd: '/work/Throughline',
+    grokBin: '/Users/kite/.grok/bin/grok',
+    sessionUuid: '11111111-1111-4111-8111-111111111111',
+    promptFile: '/tmp/prompt.txt',
+  });
+  assert.match(script, /^#!/);
+  assert.match(script, /cd '\/work\/Throughline'/);
+  assert.match(script, /exec '\/Users\/kite\/\.grok\/bin\/grok' --session-id/);
+  assert.equal(script.includes('--rules'), false);
+  assert.equal(script.includes('aiterm'), false);
+  assert.equal(script.includes('tmux'), false);
+  assert.equal(script.includes('subagent'), false);
+});
+
+test('macOS launch uses Terminal via osascript, not aiterm', () => {
+  const apple = appleScriptForLaunch('/tmp/tl-grok-continue/launch.sh');
+  assert.match(apple, /tell application "Terminal"/);
+  assert.match(apple, /do script "exec "/);
+  assert.equal(apple.includes('aiterm'), false);
+});
+
+test('resolveGrokBin prefers ~/.grok/bin/grok', () => {
+  const home = '/tmp/tl-home';
+  const found = resolveGrokBin({
+    home,
+    env: { PATH: '/usr/bin' },
+    exists: (path) => path === join(home, '.grok', 'bin', 'grok'),
+  });
+  assert.equal(found, join(home, '.grok', 'bin', 'grok'));
+});
+
+test('handoff-context failure does not spawn grok', () => {
+  const io = capture();
+  const spawned = [];
+  const code = run(['--session', 'grok:missing'], {
+    ...io,
+    readContext: () => null,
+    readProjectPath: () => '/work/dotagents',
+    resolveBin: () => '/tmp/grok',
+    spawnLaunch: (plan) => { spawned.push(plan); },
+    platform: 'darwin',
+  });
+  assert.equal(code, 1);
+  assert.equal(spawned.length, 0);
+  assert.match(io.err, /not available/);
+});
+
+test('handoff-context throw does not spawn grok', () => {
+  const io = capture();
+  const spawned = [];
+  const code = run(['--session', 'grok:broken'], {
+    ...io,
+    readContext: () => { throw new Error('db'); },
+    readProjectPath: () => REPO_ROOT,
+    resolveBin: () => '/tmp/grok',
+    spawnLaunch: (plan) => { spawned.push(plan); },
+    platform: 'darwin',
+  });
+  assert.equal(code, 1);
+  assert.equal(spawned.length, 0);
+});
+
+test('missing grok binary does not spawn', () => {
+  const io = capture();
+  const spawned = [];
+  const code = run(['--session', 'grok:ok'], {
+    ...io,
+    readContext: () => CONTEXT,
+    readProjectPath: () => REPO_ROOT,
+    resolveBin: () => null,
+    spawnLaunch: (plan) => { spawned.push(plan); },
+    platform: 'darwin',
+  });
+  assert.equal(code, 1);
+  assert.equal(spawned.length, 0);
+});
+
+test('successful continue spawn uses source project cwd and waits', () => {
+  const io = capture();
+  const spawned = [];
+  const uuid = '22222222-2222-4222-8222-222222222222';
+  const code = run(['--session', 'grok:source'], {
+    ...io,
+    readContext: (id) => {
+      assert.equal(id, 'grok:source');
+      return CONTEXT;
+    },
+    readProjectPath: (id) => {
+      assert.equal(id, 'grok:source');
+      return REPO_ROOT;
+    },
+    resolveBin: () => '/tmp/fake-grok',
+    createSessionId: () => uuid,
+    spawnLaunch: (plan) => { spawned.push(plan); },
+    platform: 'darwin',
+  });
+  assert.equal(code, 0);
+  assert.equal(spawned.length, 1);
+  assert.equal(io.out, `grok:${uuid}\n`);
+  const { grokArgv, launchFile, cwd } = spawned[0];
+  assert.equal(cwd, REPO_ROOT);
+  assert.equal(grokArgv.includes('--rules'), false);
+  assert.ok(grokArgv.at(-1).includes(CONTEXT));
+  assert.ok(grokArgv.at(-1).startsWith(GROK_CONTINUE_PREAMBLE));
+  assert.ok(grokArgv.at(-1).endsWith(GROK_CONTINUE_WAIT));
+  assert.equal(grokArgv[0], '/tmp/fake-grok');
+  assert.equal(grokArgv[1], '--session-id');
+  assert.match(readFileSync(launchFile, 'utf8'), /cd '/);
+  assert.match(appleScriptForLaunch(launchFile), /Terminal/);
+});
+
+test('missing source project path does not spawn', () => {
+  const io = capture();
+  const spawned = [];
+  const code = run(['--session', 'grok:source'], {
+    ...io,
+    readContext: () => CONTEXT,
+    readProjectPath: () => null,
+    resolveBin: () => '/tmp/grok',
+    spawnLaunch: (plan) => { spawned.push(plan); },
+    platform: 'darwin',
+  });
+  assert.equal(code, 1);
+  assert.equal(spawned.length, 0);
+  assert.match(io.err, /project path is not available/);
+});
+
+test('absent source project directory does not spawn', () => {
+  const io = capture();
+  const spawned = [];
+  const code = run(['--session', 'grok:source'], {
+    ...io,
+    readContext: () => CONTEXT,
+    readProjectPath: () => '/no/such/throughline-parent-project',
+    resolveBin: () => '/tmp/grok',
+    spawnLaunch: (plan) => { spawned.push(plan); },
+    platform: 'darwin',
+  });
+  assert.equal(code, 1);
+  assert.equal(spawned.length, 0);
+  assert.match(io.err, /does not exist/);
+});
+
+test('plan builder refuses --rules if a caller tries to add it', () => {
+  const plan = buildContinuePlan({
+    context: CONTEXT,
+    grokBin: '/tmp/grok',
+    cwd: '/work',
+    sessionUuid: '33333333-3333-4333-8333-333333333333',
+  });
+  assert.equal(plan.grokArgv.includes('--rules'), false);
+});
+
+test('bin dispatches grok-continue and help names the command', () => {
+  const bin = readFileSync(BIN_PATH, 'utf8');
+  assert.match(bin, /case 'grok-continue':/);
+  const help = spawnSync(process.execPath, [BIN_PATH, '--help'], {
+    cwd: REPO_ROOT,
+    encoding: 'utf8',
+  });
+  assert.equal(help.status, 0, help.stderr);
+  assert.match(help.stdout, /throughline grok-continue --session <id>/);
+});
+
+test('bin usage error is exit 2 without spawning a real grok', () => {
+  const result = spawnSync(process.execPath, [BIN_PATH, 'grok-continue'], {
+    cwd: REPO_ROOT,
+    encoding: 'utf8',
+    env: { ...process.env, HOME: join(tmpdir(), 'tl-grok-continue-missing-home') },
+  });
+  assert.equal(result.status, 2);
+  assert.match(result.stderr, /Usage: throughline grok-continue --session <id>/);
+});

package/src/cli/handoff-context.mjs

@@ -36,6 +36,25 @@ export function readHandoffContext(sessionId, {
   }
 }
 
+export function readSessionProjectPath(sessionId, {
+  dbPath = join(homedir(), '.throughline', 'throughline.db'),
+} = {}) {
+  if (!existsSync(dbPath)) return null;
+
+  const db = new DatabaseSync(dbPath, { readOnly: true });
+  try {
+    const row = db.prepare(
+      'SELECT project_path FROM sessions WHERE session_id = ?',
+    ).get(sessionId);
+    const projectPath = row?.project_path;
+    return typeof projectPath === 'string' && projectPath.length > 0
+      ? projectPath
+      : null;
+  } finally {
+    db.close();
+  }
+}
+
 export function run(argv = [], {
   stdout = process.stdout,
   stderr = process.stderr,

package/src/cli/handoff-context.test.mjs

@@ -8,6 +8,7 @@ import { fileURLToPath } from 'node:url';
 import { DatabaseSync } from 'node:sqlite';
 
 import { buildBudgetedResumeContext } from '../resume-context.mjs';
+import { readSessionProjectPath } from './handoff-context.mjs';
 
 const REPO_ROOT = fileURLToPath(new URL('../..', import.meta.url));
 const BIN_PATH = join(REPO_ROOT, 'bin/throughline.mjs');
@@ -131,6 +132,18 @@ test('handoff-context emits the exact inheritance context without changing DB ow
   }
 });
 
+test('readSessionProjectPath returns the source session project', () => {
+  const home = mkdtempSync(join(tmpdir(), 'tl-session-project-'));
+  try {
+    const { db, dbPath } = createFixture(home);
+    db.close();
+    assert.equal(readSessionProjectPath(SESSION_ID, { dbPath }), '/work/project');
+    assert.equal(readSessionProjectPath('missing', { dbPath }), null);
+  } finally {
+    rmSync(home, { recursive: true, force: true });
+  }
+});
+
 test('handoff-context fails without creating a missing database', () => {
   const home = mkdtempSync(join(tmpdir(), 'tl-handoff-context-missing-'));
   try {

package/src/cli/install.mjs

@@ -9,6 +9,8 @@
  * Claude-facing hook は従来通り PATH 解決型 (throughline <subcommand>) を使う。
  * Codex-facing hook は VSCode App Server の PATH 差分を避けるため、絶対 node + CLI
  * script path で登録する。
+ * Grok-facing hook も Desktop の GUI PATH に throughline が無いため、同じ絶対
+ * node + CLI script path で ~/.grok/hooks/throughline.json に書く。
  */
 
 import { readFileSync, writeFileSync, existsSync, mkdirSync, readdirSync, copyFileSync, unlinkSync, rmSync, realpathSync } from 'node:fs';
@@ -24,6 +26,7 @@ const CODEX_SKILLS_SRC = join(PACKAGE_ROOT, 'codex', 'skills');
 const CODEX_SKILL_NAMES = ['throughline'];
 const CODEX_HOOKS_RELATIVE_PATH = ['.codex', 'hooks.json'];
 const CODEX_CONFIG_RELATIVE_PATH = ['.codex', 'config.toml'];
+const GROK_HOOKS_RELATIVE_PATH = ['.grok', 'hooks', 'throughline.json'];
 
 // Throughline が管理する hook コマンド一覧
 // schema v4 以降: PostToolUse (capture-tool) は廃止。Stop 内で L2/L3 を一括処理する。
@@ -283,6 +286,54 @@ function resolveCodexSkillsDir() {
   return join(homedir(), '.codex', 'skills');
 }
 
+function resolveGrokHooksPath() {
+  return join(homedir(), ...GROK_HOOKS_RELATIVE_PATH);
+}
+
+export function buildGrokHookCommand(subcommand, {
+  nodePath = resolveCodexHookNodePath(),
+  cliScriptPath = join(PACKAGE_ROOT, 'bin', 'throughline.mjs'),
+} = {}) {
+  return `${quoteCommandPath(nodePath)} ${quoteCommandPath(cliScriptPath)} ${subcommand}`;
+}
+
+export function createGrokHooksFile(options = {}) {
+  return {
+    hooks: {
+      SessionStart: [
+        { hooks: [{ type: 'command', command: buildGrokHookCommand('session-start', options), timeout: 10 }] },
+      ],
+      UserPromptSubmit: [
+        { hooks: [{ type: 'command', command: buildGrokHookCommand('prompt-submit', options), timeout: 30 }] },
+      ],
+      Stop: [
+        {
+          hooks: [{
+            type: 'command',
+            command: buildGrokHookCommand('process-turn', options),
+            timeout: 300,
+            async: true,
+          }],
+        },
+      ],
+    },
+  };
+}
+
+function installGrokHooks() {
+  const hooksPath = resolveGrokHooksPath();
+  mkdirSync(dirname(hooksPath), { recursive: true });
+  writeFileSync(hooksPath, `${JSON.stringify(createGrokHooksFile(), null, 2)}\n`);
+  return { hooksPath };
+}
+
+function uninstallGrokHooks() {
+  const hooksPath = resolveGrokHooksPath();
+  if (!existsSync(hooksPath)) return { hooksPath, removed: 0 };
+  unlinkSync(hooksPath);
+  return { hooksPath, removed: 1 };
+}
+
 function installSlashCommands(commandsDir) {
   if (!existsSync(SLASH_COMMANDS_SRC)) {
     return { installed: [], skipped: 'source-missing' };
@@ -537,6 +588,7 @@ export async function run(args = []) {
     writeSettings(settingsPath, current);
     const removedCommands = uninstallSlashCommands(commandsDir);
     const codex = args.includes('--project') ? null : uninstallCodexHooks();
+    const grok = args.includes('--project') ? null : uninstallGrokHooks();
     const removedCodexSkills = args.includes('--project') ? [] : uninstallCodexSkills(codexSkillsDir);
     console.log('Throughline hooks を削除しました。');
     console.log(`  ${settingsPath}`);
@@ -546,6 +598,9 @@ export async function run(args = []) {
     if (codex?.removed > 0) {
       console.log(`  Codex hooks 削除: ${codex.removed} (${codex.hooksPath})`);
     }
+    if (grok?.removed > 0) {
+      console.log(`  Grok hooks 削除: ${grok.removed} (${grok.hooksPath})`);
+    }
     if (removedCodexSkills.length > 0) {
       console.log(`  Codex skills 削除: ${removedCodexSkills.join(', ')} (${codexSkillsDir})`);
     }
@@ -568,6 +623,7 @@ export async function run(args = []) {
   writeSettings(settingsPath, current);
   const { installed: installedCommands, skipped } = installSlashCommands(commandsDir);
   const codex = args.includes('--project') ? null : installCodexHooks();
+  const grok = args.includes('--project') ? null : installGrokHooks();
   const codexSkills = args.includes('--project') ? { installed: [], skipped: null } : installCodexSkills(codexSkillsDir);
   const monitorTask = ensureMonitorTaskFile({
     cwd: process.cwd(),
@@ -584,6 +640,9 @@ export async function run(args = []) {
       console.log(`  ${codexSkillsDir}`);
     }
   }
+  if (grok) {
+    console.log(`  ${grok.hooksPath}`);
+  }
   console.log('');
   console.log('有効な hooks:');
   console.log('  SessionStart     → throughline session-start  (セッション記録・バトン消費・引き継ぎ注入)');
@@ -594,6 +653,9 @@ export async function run(args = []) {
     console.log(`  Codex PostToolUse      → ${buildCodexPostToolUseHookCommand()} (capture / monitor state only; auto refresh disabled)`);
     console.log(`  Codex Stop             → ${buildCodexStopHookCommand()} (Codex rollout capture + L1 要約)`);
   }
+  if (grok) {
+    console.log('  Grok SessionStart / UserPromptSubmit / Stop → ~/.grok/hooks/throughline.json');
+  }
   console.log('');
   if (installedCommands.length > 0) {
     console.log(`slash commands を配置しました: ${installedCommands.map(n => '/' + n.replace(/\.md$/, '')).join(', ')}`);

package/src/cli/install.test.mjs

@@ -8,6 +8,8 @@ import {
   buildCodexPostToolUseHookCommand,
   buildCodexStopHookCommand,
   buildCodexUserPromptSubmitHookCommand,
+  buildGrokHookCommand,
+  createGrokHooksFile,
   isEquivalentCodexHookCommand,
   isThroughlineCodexHookCommand,
   parseCodexHookCommand,
@@ -72,6 +74,24 @@ test('global install copies Throughline slash commands to ~/.claude/commands/',
     assert.match(tlBody, /Throughline/, 'tl.md content should be real');
     const settings = JSON.parse(readFileSync(join(home.dir, '.claude', 'settings.json'), 'utf8'));
     assert.ok(settings.hooks?.UserPromptSubmit, 'UserPromptSubmit hook should be registered');
+    const grokHooks = JSON.parse(readFileSync(join(home.dir, '.grok', 'hooks', 'throughline.json'), 'utf8'));
+    assert.ok(grokHooks.hooks?.SessionStart, 'Grok SessionStart hook should be registered');
+    assert.ok(grokHooks.hooks?.UserPromptSubmit, 'Grok UserPromptSubmit hook should be registered');
+    assert.ok(grokHooks.hooks?.Stop, 'Grok Stop hook should be registered');
+    const grokCommands = [
+      grokHooks.hooks.SessionStart[0].hooks[0].command,
+      grokHooks.hooks.UserPromptSubmit[0].hooks[0].command,
+      grokHooks.hooks.Stop[0].hooks[0].command,
+    ];
+    assert.deepEqual(grokCommands, [
+      buildGrokHookCommand('session-start'),
+      buildGrokHookCommand('prompt-submit'),
+      buildGrokHookCommand('process-turn'),
+    ]);
+    for (const command of grokCommands) {
+      assert.match(command, /throughline\.mjs/);
+      assert.doesNotMatch(command, /^throughline /);
+    }
   } finally {
     unsilence();
     home.restore();
@@ -146,6 +166,32 @@ test('global install registers Codex session hooks and enables hooks features',
   }
 });
 
+test('Grok hook commands are absolute node + throughline.mjs on every platform', () => {
+  const options = {
+    nodePath: String.raw`C:\Program Files\nodejs\node.exe`,
+    cliScriptPath: String.raw`C:\Users\Kite\App Data\Roaming\npm\node_modules\throughline\bin\throughline.mjs`,
+  };
+  assert.equal(
+    buildGrokHookCommand('session-start', options),
+    String.raw`"C:\Program Files\nodejs\node.exe" "C:\Users\Kite\App Data\Roaming\npm\node_modules\throughline\bin\throughline.mjs" session-start`,
+  );
+  assert.equal(
+    buildGrokHookCommand('process-turn', {
+      nodePath: '/opt/homebrew/bin/node',
+      cliScriptPath: '/Users/kite/Developer/Throughline/bin/throughline.mjs',
+    }),
+    '/opt/homebrew/bin/node /Users/kite/Developer/Throughline/bin/throughline.mjs process-turn',
+  );
+  const file = createGrokHooksFile({
+    nodePath: '/usr/bin/node',
+    cliScriptPath: '/pkg/bin/throughline.mjs',
+  });
+  assert.equal(file.hooks.SessionStart[0].hooks[0].command, '/usr/bin/node /pkg/bin/throughline.mjs session-start');
+  assert.equal(file.hooks.UserPromptSubmit[0].hooks[0].command, '/usr/bin/node /pkg/bin/throughline.mjs prompt-submit');
+  assert.equal(file.hooks.Stop[0].hooks[0].command, '/usr/bin/node /pkg/bin/throughline.mjs process-turn');
+  assert.equal(file.hooks.Stop[0].hooks[0].async, true);
+});
+
 test('Codex hook builders use the PowerShell call operator on Windows only', () => {
   const options = {
     nodePath: String.raw`C:\Program Files\nodejs\node.exe`,

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 });
+  }
+});