throughline 0.9.1 → 0.10.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,7 +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 { isUnsupportedNonClaudeEnvelope } from './hook-envelope.mjs';
+import { normalizeHookPayload } from './hook-envelope.mjs';
 
 const ENV_DISABLE_AUTO_HANDOFF = 'THROUGHLINE_DISABLE_AUTO_HANDOFF';
 
@@ -62,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`,
     )
@@ -91,8 +92,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, 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,7 +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 { isUnsupportedNonClaudeEnvelope } from './hook-envelope.mjs';
+import { normalizeHookPayload } from './hook-envelope.mjs';
 
 /** 直近 N ターンは bodies を生で残し、それより古いものだけ L1 要約する。 */
 export const L2_WINDOW = 20;
@@ -191,8 +191,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, transcript_path, cwd, last_assistant_message } = payload;
   if (!session_id) throw new Error('Missing session_id in Stop payload');
 
@@ -206,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 の「アクティブ行」判定が
   // アシスタント応答終了時刻まで追従する