throughline 0.9.1 → 0.10.0

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/hook-envelope.mjs

@@ -1,7 +1,13 @@
-// Grok can invoke Claude-compatible hook commands with its camelCase wire.
-// Throughline does not support Grok as a host, so this envelope is ignored
-// before DB, state, VS Code task, transcript, or runtime-error side effects.
-export function isUnsupportedNonClaudeEnvelope(payload) {
+// Grok sends Claude-compatible hook commands with a camelCase wire
+// (sessionId, hookEventName) and no session_id. Throughline treats that
+// envelope as host=grok: normalize to the Claude snake_case contract and
+// prefix session ids so they never mix with Claude predecessor search.
+import { homedir } from 'node:os';
+import { join } from 'node:path';
+
+export const GROK_SESSION_PREFIX = 'grok:';
+
+export function isGrokEnvelope(payload) {
   return payload !== null
     && typeof payload === 'object'
     && typeof payload.sessionId === 'string'
@@ -10,3 +16,36 @@ export function isUnsupportedNonClaudeEnvelope(payload) {
     && payload.hookEventName.length > 0
     && !Object.hasOwn(payload, 'session_id');
 }
+
+export function grokBareSessionId(sessionId) {
+  if (typeof sessionId !== 'string' || sessionId.length === 0) return null;
+  return sessionId.startsWith(GROK_SESSION_PREFIX)
+    ? sessionId.slice(GROK_SESSION_PREFIX.length)
+    : sessionId;
+}
+
+export function deriveGrokChatHistoryPath(projectPath, sessionId, { home = homedir() } = {}) {
+  const bare = grokBareSessionId(sessionId);
+  if (!projectPath || !bare) return null;
+  return join(home, '.grok', 'sessions', encodeURIComponent(projectPath), bare, 'chat_history.jsonl');
+}
+
+export function normalizeHookPayload(payload, { home = homedir() } = {}) {
+  if (!isGrokEnvelope(payload)) return payload;
+  const cwd = typeof payload.cwd === 'string' && payload.cwd.length > 0
+    ? payload.cwd
+    : (typeof payload.workspaceRoot === 'string' ? payload.workspaceRoot : undefined);
+  // Live Grok Stop sets transcriptPath to updates.jsonl (sessionUpdate frames,
+  // no user/assistant rows). L2 lives in chat_history.jsonl only.
+  const transcriptPath = deriveGrokChatHistoryPath(cwd, payload.sessionId, { home });
+  return {
+    ...payload,
+    session_id: `${GROK_SESSION_PREFIX}${payload.sessionId}`,
+    cwd,
+    source: payload.source,
+    prompt: payload.prompt,
+    hook_event_name: payload.hookEventName,
+    transcript_path: transcriptPath,
+    last_assistant_message: payload.lastAssistantMessage,
+  };
+}

package/src/hook-envelope.test.mjs

@@ -0,0 +1,79 @@
+import { test } from 'node:test';
+import assert from 'node:assert/strict';
+import { join } from 'node:path';
+
+import {
+  deriveGrokChatHistoryPath,
+  isGrokEnvelope,
+  normalizeHookPayload,
+} from './hook-envelope.mjs';
+
+test('isGrokEnvelope detects camelCase wire without session_id', () => {
+  assert.equal(
+    isGrokEnvelope({
+      sessionId: '01a00aa2-dead-beef',
+      hookEventName: 'session_start',
+      cwd: '/tmp/proj',
+    }),
+    true,
+  );
+  assert.equal(
+    isGrokEnvelope({
+      session_id: 'claude-session',
+      hook_event_name: 'SessionStart',
+    }),
+    false,
+  );
+});
+
+test('normalizeHookPayload prefixes grok: and derives chat_history path', () => {
+  const home = '/tmp/tl-home';
+  const cwd = '/Users/kite/Developer/dotagents';
+  const payload = normalizeHookPayload(
+    {
+      sessionId: '01a00aa2-dead-beef',
+      hookEventName: 'user_prompt_submit',
+      cwd,
+      prompt: 'hello',
+      lastAssistantMessage: 'hi',
+    },
+    { home },
+  );
+  assert.equal(payload.session_id, 'grok:01a00aa2-dead-beef');
+  assert.equal(payload.prompt, 'hello');
+  assert.equal(payload.last_assistant_message, 'hi');
+  assert.equal(
+    payload.transcript_path,
+    join(home, '.grok', 'sessions', encodeURIComponent(cwd), '01a00aa2-dead-beef', 'chat_history.jsonl'),
+  );
+  assert.equal(
+    deriveGrokChatHistoryPath(cwd, 'grok:01a00aa2-dead-beef', { home }),
+    payload.transcript_path,
+  );
+});
+
+test('normalizeHookPayload ignores Grok transcriptPath pointing at updates.jsonl', () => {
+  const home = '/tmp/tl-home';
+  const cwd = '/Users/kite/Developer/dotagents';
+  const sessionId = '01a00b38-87ea-7670-8f7d-a9fe937263c5';
+  const payload = normalizeHookPayload(
+    {
+      sessionId,
+      hookEventName: 'stop',
+      cwd,
+      transcriptPath: join(
+        home,
+        '.grok',
+        'sessions',
+        encodeURIComponent(cwd),
+        sessionId,
+        'updates.jsonl',
+      ),
+    },
+    { home },
+  );
+  assert.equal(
+    payload.transcript_path,
+    join(home, '.grok', 'sessions', encodeURIComponent(cwd), sessionId, 'chat_history.jsonl'),
+  );
+});

package/src/prompt-submit.mjs

@@ -42,7 +42,10 @@ import { join, dirname } from 'node:path';
 import { homedir } from 'node:os';
 import { pathToFileURL } from 'node:url';
 import { recordRuntimeErrorBestEffort } from './runtime-error-store.mjs';
-import { isUnsupportedNonClaudeEnvelope } from './hook-envelope.mjs';
+import { GROK_SESSION_PREFIX, normalizeHookPayload } from './hook-envelope.mjs';
+import { injectGrokHandoffContext } from './grok-history-inject.mjs';
+import { readTranscript } from './transcript-reader.mjs';
+import { run as runGrokContinue } from './cli/grok-continue.mjs';
 
 // Phase 0-5 spike marker (SessionStart の spike-inject.flag とは別)
 const PROMPT_SPIKE_MARKER_PATH = join(homedir(), '.throughline', 'spike-prompt.flag');
@@ -109,28 +112,61 @@ function markSpiked(sessionId) {
   writeFileSync(join(PROMPT_SPIKE_STATE_DIR, sessionId), '', 'utf8');
 }
 
+const USER_QUERY_RE = /<user_query>\s*([\s\S]*?)\s*<\/user_query>/i;
+
+/**
+ * Grok は hook prompt と chat_history を
+ * `<user_query>/tl</user_query>` + skill 本文で包む。
+ * Claude の裸 `/tl` はそのまま返す。
+ */
+export function commandTextFromPrompt(prompt) {
+  if (typeof prompt !== 'string') return '';
+  const match = prompt.match(USER_QUERY_RE);
+  return (match ? match[1] : prompt).trim();
+}
+
+function isNamedSlashCommand(prompt, name) {
+  const text = commandTextFromPrompt(prompt);
+  if (!text) return false;
+  return text === name || text.startsWith(`${name} `) || text.startsWith(`${name}\n`);
+}
+
+function lastUserPromptText(transcriptPath) {
+  const turns = readTranscript(transcriptPath);
+  for (let i = turns.length - 1; i >= 0; i--) {
+    if (turns[i].role === 'user') return turns[i].content;
+  }
+  return '';
+}
+
 /**
  * プロンプトが /tl バトン発動コマンドか判定する。
- * 許容: "/tl", "/tl\n", "/tl 何か" (前後空白は trim 済み前提)
+ * 許容: "/tl", "/tl\n", "/tl 何か"。Grok の user_query 包装も見る。
  */
 export function isBatonCommand(prompt) {
-  if (typeof prompt !== 'string') return false;
-  const trimmed = prompt.trim();
-  if (trimmed === '/tl') return true;
-  if (trimmed.startsWith('/tl ') || trimmed.startsWith('/tl\n')) return true;
-  return false;
+  return isNamedSlashCommand(prompt, '/tl');
 }
 
 /**
  * プロンプトが /clear バトン発動コマンドか判定する。
- * 許容: "/clear", "/clear\n", "/clear 何か" (前後空白は trim 済み前提)
+ * 許容: "/clear", Grok の alias "/new"。Grok の user_query 包装も見る。
  */
 export function isClearCommand(prompt) {
-  if (typeof prompt !== 'string') return false;
-  const trimmed = prompt.trim();
-  if (trimmed === '/clear') return true;
-  if (trimmed.startsWith('/clear ') || trimmed.startsWith('/clear\n')) return true;
-  return false;
+  return isNamedSlashCommand(prompt, '/clear') || isNamedSlashCommand(prompt, '/new');
+}
+
+export function shouldLaunchGrokContinue({ sessionId, trigger }) {
+  return trigger === 'tl'
+    && typeof sessionId === 'string'
+    && sessionId.startsWith(GROK_SESSION_PREFIX);
+}
+
+export function launchGrokContinueAfterTl({
+  sessionId,
+  cwd,
+  continueRun = runGrokContinue,
+}) {
+  return continueRun(['--session', sessionId], { cwd });
 }
 
 export async function run() {
@@ -143,8 +179,7 @@ export async function run() {
     process.stdin.on('end', resolve);
   });
 
-  const payload = JSON.parse(raw);
-  if (isUnsupportedNonClaudeEnvelope(payload)) return;
+  const payload = normalizeHookPayload(JSON.parse(raw));
   const { session_id, cwd, prompt } = payload;
 
   // VSCode 新規プロジェクトへの tasks.json 自動プロビジョニング。
@@ -173,7 +208,17 @@ export async function run() {
     });
     if (handoff.attempted) {
       if (handoff.injectionText) {
-        process.stdout.write(handoff.injectionText + '\n');
+        if (session_id.startsWith(GROK_SESSION_PREFIX)) {
+          const injected = injectGrokHandoffContext(
+            payload.transcript_path,
+            handoff.injectionText,
+          );
+          if (!injected.injected) {
+            process.stderr.write(`[prompt-submit] grok chat_history inject skipped: ${injected.reason}\n`);
+          }
+        } else {
+          process.stdout.write(handoff.injectionText + '\n');
+        }
       }
       logDecision({
         ts: new Date(now).toISOString(),
@@ -193,8 +238,17 @@ export async function run() {
     }
   }
 
-  const tlMatch = isBatonCommand(prompt);
-  const clearMatch = !tlMatch && isClearCommand(prompt);
+  let commandPrompt = prompt;
+  if (
+    typeof session_id === 'string'
+    && session_id.startsWith(GROK_SESSION_PREFIX)
+    && !isBatonCommand(commandPrompt)
+    && !isClearCommand(commandPrompt)
+  ) {
+    commandPrompt = lastUserPromptText(payload.transcript_path);
+  }
+  const tlMatch = isBatonCommand(commandPrompt);
+  const clearMatch = !tlMatch && isClearCommand(commandPrompt);
 
   // Phase 0-5 spike: real user prompt (not /tl, not /clear) で、marker file あり、
   // session 未 spike なら chain (b) で JSONL に inject する。失敗しても prompt 自体は
@@ -227,6 +281,19 @@ export async function run() {
     trigger: tlMatch ? 'tl' : 'clear',
   });
 
+  if (shouldLaunchGrokContinue({
+    sessionId: session_id,
+    trigger: tlMatch ? 'tl' : 'clear',
+  })) {
+    const code = launchGrokContinueAfterTl({
+      sessionId: session_id,
+      cwd: projectPath,
+    });
+    if (code !== 0) {
+      process.stderr.write(`[prompt-submit] grok-continue exited ${code}\n`);
+    }
+  }
+
   process.exit(0);
 }