throughline 0.9.0 → 0.10.0

package/src/prompt-submit.mjs

@@ -42,6 +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 { 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');
@@ -108,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() {
@@ -142,7 +179,7 @@ export async function run() {
     process.stdin.on('end', resolve);
   });
 
-  const payload = JSON.parse(raw);
+  const payload = normalizeHookPayload(JSON.parse(raw));
   const { session_id, cwd, prompt } = payload;
 
   // VSCode 新規プロジェクトへの tasks.json 自動プロビジョニング。
@@ -171,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(),
@@ -191,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 自体は
@@ -225,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);
 }
 

package/src/prompt-submit.test.mjs

@@ -1,6 +1,12 @@
 import { test } from 'node:test';
 import assert from 'node:assert/strict';
-import { isBatonCommand, isClearCommand } from './prompt-submit.mjs';
+import {
+  commandTextFromPrompt,
+  isBatonCommand,
+  isClearCommand,
+  launchGrokContinueAfterTl,
+  shouldLaunchGrokContinue,
+} from './prompt-submit.mjs';
 
 test('isBatonCommand: bare /tl', () => {
   assert.equal(isBatonCommand('/tl'), true);
@@ -64,3 +70,54 @@ test('isClearCommand: rejects empty / non-string', () => {
   assert.equal(isClearCommand(undefined), false);
   assert.equal(isClearCommand(42), false);
 });
+
+test('commandTextFromPrompt unwraps Grok user_query and leaves bare Claude text', () => {
+  assert.equal(commandTextFromPrompt('/tl'), '/tl');
+  assert.equal(
+    commandTextFromPrompt('<user_query>\n/tl\n</user_query>\n<skill_information>saved</skill_information>'),
+    '/tl',
+  );
+});
+
+test('shouldLaunchGrokContinue is only Grok /tl', () => {
+  assert.equal(shouldLaunchGrokContinue({ sessionId: 'grok:abc', trigger: 'tl' }), true);
+  assert.equal(shouldLaunchGrokContinue({ sessionId: 'grok:abc', trigger: 'clear' }), false);
+  assert.equal(shouldLaunchGrokContinue({ sessionId: 'old-session', trigger: 'tl' }), false);
+  assert.equal(shouldLaunchGrokContinue({ sessionId: 'codex:thread', trigger: 'tl' }), false);
+});
+
+test('launchGrokContinueAfterTl calls grok-continue with the source session', () => {
+  const calls = [];
+  const code = launchGrokContinueAfterTl({
+    sessionId: 'grok:abc',
+    cwd: '/work/Throughline',
+    continueRun: (argv, opts) => {
+      calls.push({ argv, opts });
+      return 0;
+    },
+  });
+  assert.equal(code, 0);
+  assert.deepEqual(calls, [{
+    argv: ['--session', 'grok:abc'],
+    opts: { cwd: '/work/Throughline' },
+  }]);
+});
+
+test('isBatonCommand: Grok user_query wrap around /tl', () => {
+  const wrapped =
+    '<user_query>\n/tl\n</user_query>\n<skill_information>\nThroughline saved the baton.\n</skill_information>';
+  assert.equal(isBatonCommand(wrapped), true);
+});
+
+test('isBatonCommand: Grok wrap does not treat skill body /tl as the command', () => {
+  const wrapped =
+    '<user_query>\n続けてくれ\n</user_query>\n<skill_information>\nType /tl to hand off.\n</skill_information>';
+  assert.equal(isBatonCommand(wrapped), false);
+});
+
+test('isClearCommand: Grok user_query wrap around /clear and /new', () => {
+  assert.equal(isClearCommand('<user_query>\n/clear\n</user_query>'), true);
+  assert.equal(isClearCommand('<user_query>\n/new\n</user_query>'), true);
+  assert.equal(isClearCommand('/new'), true);
+  assert.equal(isClearCommand('/newest'), false);
+});

package/src/session-start.mjs

@@ -32,6 +32,7 @@ import { logDecision } from './decision-log.mjs';
 import { existsSync } from 'node:fs';
 import { pathToFileURL } from 'node:url';
 import { recordRuntimeErrorBestEffort } from './runtime-error-store.mjs';
+import { normalizeHookPayload } from './hook-envelope.mjs';
 
 const ENV_DISABLE_AUTO_HANDOFF = 'THROUGHLINE_DISABLE_AUTO_HANDOFF';
 
@@ -61,6 +62,7 @@ function findLatestClaudePredecessor(db, projectPath, currentSessionId) {
          AND merged_into IS NULL
          AND session_id != ?
          AND session_id NOT LIKE 'codex:%'
+         AND session_id NOT LIKE 'grok:%'
        ORDER BY updated_at DESC
        LIMIT 5`,
     )
@@ -90,7 +92,7 @@ export async function run() {
     process.stdin.on('end', resolve);
   });
 
-  const payload = JSON.parse(raw);
+  const payload = normalizeHookPayload(JSON.parse(raw));
   const { session_id, cwd, source, transcript_path } = payload;
 
   if (!session_id) throw new Error('Missing session_id in SessionStart payload');

package/src/transcript-reader-grok.test.mjs

@@ -0,0 +1,37 @@
+import { test } from 'node:test';
+import assert from 'node:assert/strict';
+import { mkdtempSync, rmSync, writeFileSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+
+import { getLogicalTurnGroups, readTranscript } from './transcript-reader.mjs';
+
+test('readTranscript accepts Grok chat_history.jsonl user/assistant rows', () => {
+  const dir = mkdtempSync(join(tmpdir(), 'tl-grok-transcript-'));
+  const path = join(dir, 'chat_history.jsonl');
+  writeFileSync(
+    path,
+    [
+      JSON.stringify({ type: 'system', content: 'ignore' }),
+      JSON.stringify({ type: 'user', content: [{ type: 'text', text: 'hello grok' }] }),
+      JSON.stringify({ type: 'assistant', content: 'captured reply' }),
+      JSON.stringify({ type: 'tool_result', content: 'not a turn' }),
+    ].join('\n'),
+  );
+  try {
+    const turns = readTranscript(path);
+    assert.deepEqual(
+      turns.map((t) => ({ role: t.role, content: t.content })),
+      [
+        { role: 'user', content: 'hello grok' },
+        { role: 'assistant', content: 'captured reply' },
+      ],
+    );
+    const groups = getLogicalTurnGroups(path);
+    assert.equal(groups.length, 1);
+    assert.equal(groups[0].user.content, 'hello grok');
+    assert.equal(groups[0].representative.content, 'captured reply');
+  } finally {
+    rmSync(dir, { recursive: true, force: true });
+  }
+});

package/src/transcript-reader.mjs

@@ -59,14 +59,18 @@ export function readTranscript(transcriptPath) {
     if (entry.isSidechain === true) continue;
 
     const msg = entry.message;
-    if (!msg || !msg.role || msg.content == null) continue;
+    const grokContent = entry.content;
+    const role = msg?.role ?? entry.type;
+    const rawContent = msg?.content ?? grokContent;
+    if (!role || rawContent == null) continue;
 
-    const text = extractText(msg.content);
+    const text = extractText(rawContent);
     if (!text) continue;
 
     const ts = typeof entry.timestamp === 'string' ? Date.parse(entry.timestamp) : NaN;
+    // grok chat_history.jsonl は Claude の message 包みを持たず type/content 直置き。
     turns.push({
-      role: msg.role,
+      role,
       content: text,
       turn_number: turns.length,
       timestamp: Number.isNaN(ts) ? null : ts,

package/src/turn-processor.mjs

@@ -46,6 +46,7 @@ import { readLatestUsage } from './transcript-usage.mjs';
 import { pathToFileURL } from 'node:url';
 import { recordRuntimeErrorBestEffort } from './runtime-error-store.mjs';
 import { writeCompletedTurnReceipt } from './completed-turn-receipts.mjs';
+import { normalizeHookPayload } from './hook-envelope.mjs';
 
 /** 直近 N ターンは bodies を生で残し、それより古いものだけ L1 要約する。 */
 export const L2_WINDOW = 20;
@@ -190,7 +191,7 @@ export async function run() {
     process.stdin.on('end', resolve);
   });
 
-  const payload = JSON.parse(raw || '{}');
+  const payload = normalizeHookPayload(JSON.parse(raw || '{}'));
   const { session_id, transcript_path, cwd, last_assistant_message } = payload;
   if (!session_id) throw new Error('Missing session_id in Stop payload');
 
@@ -204,10 +205,12 @@ export async function run() {
     process.stderr.write(`[vscode-task] ${msg}\n`);
   }
 
-  await waitForClaudeStopTranscriptFlush({
-    transcriptPath: transcript_path,
-    lastAssistantMessage: last_assistant_message,
-  });
+  if (!session_id.startsWith('grok:')) {
+    await waitForClaudeStopTranscriptFlush({
+      transcriptPath: transcript_path,
+      lastAssistantMessage: last_assistant_message,
+    });
+  }
 
   // Stop hook 時点で state ファイルを更新 → token-monitor の「アクティブ行」判定が
   // アシスタント応答終了時刻まで追従する