throughline 0.9.0 → 0.10.0

package/src/cli/grok-continue.mjs

@@ -0,0 +1,197 @@
+import { spawn } from 'node:child_process';
+import { randomUUID } from 'node:crypto';
+import { existsSync, mkdirSync, writeFileSync } from 'node:fs';
+import { homedir, tmpdir } from 'node:os';
+import { delimiter, join } from 'node:path';
+
+import { readHandoffContext, readSessionProjectPath } from './handoff-context.mjs';
+
+export const GROK_CONTINUE_PREAMBLE = 'この発言は直前 Throughline 席の履歴を前提とする。';
+export const GROK_CONTINUE_REQUEST = '直前の作業の自然な続きとして応答すること。';
+export const GROK_CONTINUE_WAIT = 'この後ユーザーが指示を出す。何もせず待機すること。';
+
+export function parseArgs(argv = []) {
+  if (
+    argv.length !== 2
+    || argv[0] !== '--session'
+    || typeof argv[1] !== 'string'
+    || argv[1].length === 0
+  ) {
+    throw new TypeError('usage error');
+  }
+  return { sessionId: argv[1] };
+}
+
+export function buildGrokContinuePrompt(context) {
+  if (typeof context !== 'string' || context.length === 0) {
+    throw new TypeError('empty context');
+  }
+  return `${GROK_CONTINUE_PREAMBLE}\n\n${context}\n\n${GROK_CONTINUE_REQUEST}\n\n${GROK_CONTINUE_WAIT}`;
+}
+
+export function shQuote(value) {
+  return `'${String(value).replace(/'/g, `'\\''`)}'`;
+}
+
+export function resolveGrokBin({
+  home = homedir(),
+  env = process.env,
+  exists = existsSync,
+} = {}) {
+  const homeBin = join(home, '.grok', 'bin', 'grok');
+  if (exists(homeBin)) return homeBin;
+  for (const dir of String(env.PATH ?? '').split(delimiter)) {
+    if (!dir) continue;
+    const candidate = join(dir, 'grok');
+    if (exists(candidate)) return candidate;
+  }
+  return null;
+}
+
+export function buildGrokArgv(grokBin, sessionUuid, prompt) {
+  return [grokBin, '--session-id', sessionUuid, prompt];
+}
+
+export function buildLaunchScript({ cwd, grokBin, sessionUuid, promptFile }) {
+  return [
+    '#!/bin/sh',
+    'set -e',
+    `cd ${shQuote(cwd)}`,
+    `exec ${shQuote(grokBin)} --session-id ${shQuote(sessionUuid)} "$(cat ${shQuote(promptFile)})"`,
+    '',
+  ].join('\n');
+}
+
+export function appleScriptForLaunch(launchScriptPath) {
+  return [
+    'tell application "Terminal"',
+    '  activate',
+    `  do script "exec " & quoted form of ${JSON.stringify(launchScriptPath)}`,
+    'end tell',
+    '',
+  ].join('\n');
+}
+
+export function buildContinuePlan({
+  context,
+  grokBin,
+  cwd,
+  sessionUuid,
+}) {
+  const prompt = buildGrokContinuePrompt(context);
+  const grokArgv = buildGrokArgv(grokBin, sessionUuid, prompt);
+  if (grokArgv.includes('--rules')) {
+    throw new Error('grok-continue must not pass --rules');
+  }
+  return {
+    prompt,
+    grokArgv,
+    cwd,
+    sessionUuid,
+    throughlineSessionId: `grok:${sessionUuid}`,
+  };
+}
+
+export function writeLaunchArtifacts({
+  cwd,
+  grokBin,
+  sessionUuid,
+  prompt,
+  tmp = tmpdir(),
+}) {
+  const dir = join(tmp, `tl-grok-continue-${sessionUuid}`);
+  mkdirSync(dir, { recursive: true });
+  const promptFile = join(dir, 'prompt.txt');
+  const launchFile = join(dir, 'launch.sh');
+  writeFileSync(promptFile, prompt);
+  writeFileSync(launchFile, buildLaunchScript({
+    cwd,
+    grokBin,
+    sessionUuid,
+    promptFile,
+  }), { mode: 0o755 });
+  return { promptFile, launchFile };
+}
+
+export function defaultSpawnLaunch({ launchFile, spawnImpl = spawn }) {
+  const child = spawnImpl('osascript', ['-e', appleScriptForLaunch(launchFile)], {
+    detached: true,
+    stdio: 'ignore',
+  });
+  child.unref?.();
+  return child;
+}
+
+export function run(argv = [], {
+  stdout = process.stdout,
+  stderr = process.stderr,
+  readContext = readHandoffContext,
+  readProjectPath = readSessionProjectPath,
+  resolveBin = resolveGrokBin,
+  createSessionId = randomUUID,
+  platform = process.platform,
+  spawnLaunch = defaultSpawnLaunch,
+} = {}) {
+  let sessionId;
+  try {
+    ({ sessionId } = parseArgs(argv));
+  } catch {
+    stderr.write('Usage: throughline grok-continue --session <id>\n');
+    return 2;
+  }
+
+  let context;
+  try {
+    context = readContext(sessionId);
+  } catch {
+    stderr.write('Throughline handoff context could not be read.\n');
+    return 1;
+  }
+  if (!context) {
+    stderr.write('Throughline handoff context is not available for that session.\n');
+    return 1;
+  }
+
+  let cwd;
+  try {
+    cwd = readProjectPath(sessionId);
+  } catch {
+    stderr.write('Throughline session project path could not be read.\n');
+    return 1;
+  }
+  if (!cwd) {
+    stderr.write('Throughline session project path is not available for that session.\n');
+    return 1;
+  }
+  if (!existsSync(cwd)) {
+    stderr.write('Throughline session project path does not exist.\n');
+    return 1;
+  }
+
+  const grokBin = resolveBin();
+  if (!grokBin) {
+    stderr.write('grok binary was not found.\n');
+    return 1;
+  }
+  if (platform !== 'darwin') {
+    stderr.write('throughline grok-continue requires macOS Terminal.\n');
+    return 1;
+  }
+
+  const sessionUuid = createSessionId();
+  const plan = buildContinuePlan({
+    context,
+    grokBin,
+    cwd,
+    sessionUuid,
+  });
+  const { launchFile } = writeLaunchArtifacts({
+    cwd: plan.cwd,
+    grokBin,
+    sessionUuid: plan.sessionUuid,
+    prompt: plan.prompt,
+  });
+  spawnLaunch({ launchFile, grokArgv: plan.grokArgv, cwd: plan.cwd });
+  stdout.write(`${plan.throughlineSessionId}\n`);
+  return 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`,