throughline 0.10.1 → 0.10.3

package/src/hosts/cursor.mjs

@@ -0,0 +1,128 @@
+/**
+ * hosts/cursor.mjs — Cursor host 境界 (envelope 正規化 + hook adapter)
+ *
+ * Cursor は Claude PascalCase でも Grok camelCase wire でもない。
+ * hook_event_name は sessionStart / beforeSubmitPrompt / stop などの
+ * Cursor envelope。session 識別は conversation_id（sessionStart では
+ * session_id と同じ）。L2 は ~/.cursor/projects/<slug>/agent-transcripts/<id>/<id>.jsonl。
+ *
+ * beforeSubmitPrompt の stdout は continue だけ（additional_context なし）。
+ * 引き継ぎ注入は sessionStart の additional_context が公式口。
+ * /tl 後継の自動起動はしない（次の新規 Cursor 会話の sessionStart が飲む）。
+ */
+import { homedir } from 'node:os';
+import { join } from 'node:path';
+
+import {
+  CURSOR_HOST,
+  CURSOR_SESSION_PREFIX,
+  cursorBareSessionId,
+  isCursorSessionId,
+} from './identity.mjs';
+
+const CURSOR_HOOK_EVENTS = new Set([
+  'sessionStart',
+  'sessionEnd',
+  'beforeSubmitPrompt',
+  'stop',
+  'preToolUse',
+  'postToolUse',
+  'postToolUseFailure',
+  'subagentStart',
+  'subagentStop',
+  'beforeShellExecution',
+  'afterShellExecution',
+  'beforeMCPExecution',
+  'afterMCPExecution',
+  'beforeReadFile',
+  'afterFileEdit',
+  'preCompact',
+  'afterAgentResponse',
+  'afterAgentThought',
+  'beforeTabFileRead',
+  'afterTabFileEdit',
+  'workspaceOpen',
+]);
+
+export function isCursorEnvelope(payload) {
+  if (payload === null || typeof payload !== 'object') return false;
+  if (typeof payload.cursor_version === 'string' && payload.cursor_version.length > 0) {
+    return true;
+  }
+  return typeof payload.hook_event_name === 'string'
+    && CURSOR_HOOK_EVENTS.has(payload.hook_event_name);
+}
+
+export function encodeCursorProjectDir(projectPath) {
+  if (typeof projectPath !== 'string' || projectPath.length === 0) return null;
+  const posix = projectPath.replace(/\\/g, '/').replace(/^\/+/, '');
+  const encoded = posix.replace(/:/g, '').replace(/\//g, '-');
+  return encoded.length > 0 ? encoded : null;
+}
+
+export function deriveCursorTranscriptPath(projectPath, sessionId, { home = homedir() } = {}) {
+  const bare = cursorBareSessionId(sessionId);
+  const slug = encodeCursorProjectDir(projectPath);
+  if (!bare || !slug) return null;
+  return join(home, '.cursor', 'projects', slug, 'agent-transcripts', bare, `${bare}.jsonl`);
+}
+
+function cursorCwd(payload) {
+  if (typeof payload.cwd === 'string' && payload.cwd.length > 0) return payload.cwd;
+  const roots = payload.workspace_roots;
+  if (Array.isArray(roots) && typeof roots[0] === 'string' && roots[0].length > 0) {
+    return roots[0];
+  }
+  return undefined;
+}
+
+function cursorRawSessionId(payload) {
+  if (typeof payload.conversation_id === 'string' && payload.conversation_id.length > 0) {
+    return payload.conversation_id;
+  }
+  if (typeof payload.session_id === 'string' && payload.session_id.length > 0) {
+    return payload.session_id;
+  }
+  return null;
+}
+
+export function normalizeCursorHookPayload(payload, { home = homedir() } = {}) {
+  if (!isCursorEnvelope(payload)) return payload;
+  const rawId = cursorRawSessionId(payload);
+  const cwd = cursorCwd(payload);
+  const prefixed = rawId ? `${CURSOR_SESSION_PREFIX}${cursorBareSessionId(rawId)}` : undefined;
+  const givenTranscript = typeof payload.transcript_path === 'string' && payload.transcript_path.length > 0
+    ? payload.transcript_path
+    : null;
+  const transcriptPath = givenTranscript ?? deriveCursorTranscriptPath(cwd, prefixed, { home });
+  return {
+    ...payload,
+    session_id: prefixed,
+    cwd,
+    source: typeof payload.source === 'string' && payload.source.length > 0
+      ? payload.source
+      : 'startup',
+    prompt: payload.prompt,
+    hook_event_name: payload.hook_event_name,
+    transcript_path: transcriptPath,
+    last_assistant_message: payload.last_assistant_message ?? payload.text,
+    is_background_agent: payload.is_background_agent === true,
+  };
+}
+
+export const cursorHostAdapter = Object.freeze({
+  host: CURSOR_HOST,
+  matchesSessionId: isCursorSessionId,
+  waitsForStopTranscriptFlush: false,
+  consumesHandoffAtSessionStart: true,
+  deliverHandoffInjection({ text, stdout = process.stdout }) {
+    stdout.write(`${JSON.stringify({ additional_context: text })}\n`);
+    return { delivered: true };
+  },
+  resolveCommandPrompt({ prompt }) {
+    return prompt;
+  },
+  afterBatonWrite() {
+    return { launched: false };
+  },
+});

package/src/hosts/cursor.test.mjs

@@ -0,0 +1,104 @@
+import { test } from 'node:test';
+import assert from 'node:assert/strict';
+import { join } from 'node:path';
+
+import {
+  deriveCursorTranscriptPath,
+  encodeCursorProjectDir,
+  isCursorEnvelope,
+  normalizeHookPayload,
+} from './index.mjs';
+
+test('isCursorEnvelope detects Cursor events and cursor_version', () => {
+  assert.equal(
+    isCursorEnvelope({
+      hook_event_name: 'sessionStart',
+      session_id: '7face712-ef58-40d7-b71e-b71091dfee5c',
+      workspace_roots: ['/Users/kite/Developer/dotagents'],
+    }),
+    true,
+  );
+  assert.equal(
+    isCursorEnvelope({
+      cursor_version: '1.7.2',
+      conversation_id: '7face712-ef58-40d7-b71e-b71091dfee5c',
+    }),
+    true,
+  );
+  assert.equal(
+    isCursorEnvelope({
+      session_id: 'claude-session',
+      hook_event_name: 'SessionStart',
+    }),
+    false,
+  );
+  assert.equal(
+    isCursorEnvelope({
+      sessionId: '01a00aa2-dead-beef',
+      hookEventName: 'session_start',
+    }),
+    false,
+  );
+});
+
+test('normalizeHookPayload prefixes cursor: and derives agent-transcripts path', () => {
+  const home = '/tmp/tl-home';
+  const cwd = '/Users/kite/Developer/dotagents';
+  const payload = normalizeHookPayload(
+    {
+      conversation_id: '7face712-ef58-40d7-b71e-b71091dfee5c',
+      hook_event_name: 'beforeSubmitPrompt',
+      workspace_roots: [cwd],
+      prompt: '/tl',
+      cursor_version: '1.7.2',
+    },
+    { home },
+  );
+  assert.equal(payload.session_id, 'cursor:7face712-ef58-40d7-b71e-b71091dfee5c');
+  assert.equal(payload.cwd, cwd);
+  assert.equal(payload.prompt, '/tl');
+  assert.equal(
+    payload.transcript_path,
+    join(
+      home,
+      '.cursor',
+      'projects',
+      'Users-kite-Developer-dotagents',
+      'agent-transcripts',
+      '7face712-ef58-40d7-b71e-b71091dfee5c',
+      '7face712-ef58-40d7-b71e-b71091dfee5c.jsonl',
+    ),
+  );
+  assert.equal(
+    deriveCursorTranscriptPath(cwd, 'cursor:7face712-ef58-40d7-b71e-b71091dfee5c', { home }),
+    payload.transcript_path,
+  );
+});
+
+test('normalizeHookPayload strips bc- prefix and keeps payload transcript_path', () => {
+  const home = '/tmp/tl-home';
+  const given = '/tmp/given.jsonl';
+  const payload = normalizeHookPayload(
+    {
+      conversation_id: 'bc-7face712-ef58-40d7-b71e-b71091dfee5c',
+      hook_event_name: 'stop',
+      cwd: '/Users/kite/Developer/dotagents',
+      transcript_path: given,
+      status: 'completed',
+    },
+    { home },
+  );
+  assert.equal(payload.session_id, 'cursor:7face712-ef58-40d7-b71e-b71091dfee5c');
+  assert.equal(payload.transcript_path, given);
+});
+
+test('encodeCursorProjectDir matches ~/.cursor/projects slug', () => {
+  assert.equal(
+    encodeCursorProjectDir('/Users/kite/Developer/dotagents'),
+    'Users-kite-Developer-dotagents',
+  );
+  assert.equal(
+    encodeCursorProjectDir(String.raw`C:\Users\kite_\Developer\dotagents`),
+    'C-Users-kite_-Developer-dotagents',
+  );
+});

package/src/hosts/grok.mjs

@@ -88,6 +88,7 @@ export const grokHostAdapter = Object.freeze({
     return lastUserPromptText(payload.transcript_path);
   },
   // Grok `/tl` 成功後だけ、源セッションの project_path で後継の対話 grok を立てる。
+  consumesHandoffAtSessionStart: false,
   afterBatonWrite({ trigger, sessionId, cwd, continueRun = runGrokContinue }) {
     if (trigger !== 'tl') return { launched: false };
     const code = continueRun(['--session', sessionId], { cwd });

package/src/hosts/identity.mjs

@@ -1,7 +1,7 @@
 /**
- * hosts/identity.mjs — ベンダー (hook host) 識別の唯一の正本
+ * hosts/identity.mjs — harness (hook host) 識別の唯一の正本
  *
- * Throughline は Claude / Codex / Grok の 3 hook host を同じ SQLite に保存する。
+ * Throughline は Claude / Codex / Grok / Cursor の hook host を同じ SQLite に保存する。
  * host の見分け方は session_id prefix だけであり、その prefix 定義と判定関数を
  * このファイルに一元化する。共有コード (hook 入口・monitor・state-file・
  * predecessor 検索) は文字列リテラルを直接持たず、必ずここを参照する。
@@ -13,9 +13,11 @@
 export const CLAUDE_HOST = 'claude';
 export const CODEX_HOST = 'codex';
 export const GROK_HOST = 'grok';
+export const CURSOR_HOST = 'cursor';
 
 export const CODEX_SESSION_PREFIX = 'codex:';
 export const GROK_SESSION_PREFIX = 'grok:';
+export const CURSOR_SESSION_PREFIX = 'cursor:';
 
 /**
  * Claude session は prefix を持たない。auto handoff の前任検索 (Claude 専用) は
@@ -24,6 +26,7 @@ export const GROK_SESSION_PREFIX = 'grok:';
 export const NON_CLAUDE_SESSION_PREFIXES = Object.freeze([
   CODEX_SESSION_PREFIX,
   GROK_SESSION_PREFIX,
+  CURSOR_SESSION_PREFIX,
 ]);
 
 /**
@@ -40,14 +43,19 @@ export function isGrokSessionId(sessionId) {
   return typeof sessionId === 'string' && sessionId.startsWith(GROK_SESSION_PREFIX);
 }
 
+export function isCursorSessionId(sessionId) {
+  return typeof sessionId === 'string' && sessionId.startsWith(CURSOR_SESSION_PREFIX);
+}
+
 /**
  * session_id から hook host を返す。prefix なしは Claude。
  * @param {string} sessionId
- * @returns {'claude'|'codex'|'grok'}
+ * @returns {'claude'|'codex'|'grok'|'cursor'}
  */
 export function hostOfSessionId(sessionId) {
   if (isCodexSessionId(sessionId)) return CODEX_HOST;
   if (isGrokSessionId(sessionId)) return GROK_HOST;
+  if (isCursorSessionId(sessionId)) return CURSOR_HOST;
   return CLAUDE_HOST;
 }
 
@@ -69,3 +77,12 @@ export function grokBareSessionId(sessionId) {
     ? sessionId.slice(GROK_SESSION_PREFIX.length)
     : sessionId;
 }
+
+export function cursorBareSessionId(sessionId) {
+  if (typeof sessionId !== 'string' || sessionId.length === 0) return null;
+  let bare = sessionId.startsWith(CURSOR_SESSION_PREFIX)
+    ? sessionId.slice(CURSOR_SESSION_PREFIX.length)
+    : sessionId;
+  if (bare.startsWith('bc-')) bare = bare.slice(3);
+  return bare.length > 0 ? bare : null;
+}

package/src/hosts/identity.test.mjs

@@ -3,13 +3,16 @@ import assert from 'node:assert/strict';
 
 import {
   CODEX_SESSION_PREFIX,
+  CURSOR_SESSION_PREFIX,
   GROK_SESSION_PREFIX,
   NON_CLAUDE_SESSION_PREFIXES,
   buildCodexThroughlineSessionId,
   codexSessionIdToThreadId,
+  cursorBareSessionId,
   grokBareSessionId,
   hostOfSessionId,
   isCodexSessionId,
+  isCursorSessionId,
   isGrokSessionId,
 } from './identity.mjs';
 import { hostAdapterForSessionId } from './index.mjs';
@@ -17,12 +20,14 @@ import { hostAdapterForSessionId } from './index.mjs';
 test('session prefixes are the canonical wire values', () => {
   assert.equal(CODEX_SESSION_PREFIX, 'codex:');
   assert.equal(GROK_SESSION_PREFIX, 'grok:');
-  assert.deepEqual([...NON_CLAUDE_SESSION_PREFIXES], ['codex:', 'grok:']);
+  assert.equal(CURSOR_SESSION_PREFIX, 'cursor:');
+  assert.deepEqual([...NON_CLAUDE_SESSION_PREFIXES], ['codex:', 'grok:', 'cursor:']);
 });
 
 test('hostOfSessionId maps prefixes to hosts and defaults to claude', () => {
   assert.equal(hostOfSessionId('codex:0199aa'), 'codex');
   assert.equal(hostOfSessionId('grok:0199aa'), 'grok');
+  assert.equal(hostOfSessionId('cursor:0199aa'), 'cursor');
   assert.equal(hostOfSessionId('0199aa-claude'), 'claude');
   assert.equal(hostOfSessionId(undefined), 'claude');
 });
@@ -41,25 +46,43 @@ test('grokBareSessionId strips only the grok prefix', () => {
   assert.equal(grokBareSessionId(''), null);
 });
 
-test('isCodexSessionId / isGrokSessionId reject non-strings', () => {
+test('cursorBareSessionId strips cursor: and optional bc- prefix', () => {
+  assert.equal(cursorBareSessionId('cursor:abc'), 'abc');
+  assert.equal(cursorBareSessionId('bc-abc'), 'abc');
+  assert.equal(cursorBareSessionId('cursor:bc-abc'), 'abc');
+  assert.equal(cursorBareSessionId('abc'), 'abc');
+  assert.equal(cursorBareSessionId(''), null);
+});
+
+test('isCodexSessionId / isGrokSessionId / isCursorSessionId reject non-strings', () => {
   assert.equal(isCodexSessionId(null), false);
   assert.equal(isGrokSessionId(undefined), false);
+  assert.equal(isCursorSessionId(undefined), false);
 });
 
 test('every host adapter satisfies the shared hook contract', () => {
-  for (const sessionId of ['claude-session', 'codex:t1', 'grok:t1']) {
+  for (const sessionId of ['claude-session', 'codex:t1', 'grok:t1', 'cursor:t1']) {
     const adapter = hostAdapterForSessionId(sessionId);
     assert.equal(typeof adapter.host, 'string');
     assert.equal(adapter.matchesSessionId(sessionId), true);
     assert.equal(typeof adapter.waitsForStopTranscriptFlush, 'boolean');
+    assert.equal(typeof adapter.consumesHandoffAtSessionStart, 'boolean');
     assert.equal(typeof adapter.deliverHandoffInjection, 'function');
     assert.equal(typeof adapter.resolveCommandPrompt, 'function');
     assert.equal(typeof adapter.afterBatonWrite, 'function');
   }
 });
 
-test('flush barrier applies to claude and codex sessions, not grok', () => {
+test('flush barrier applies to claude and codex sessions, not grok or cursor', () => {
   assert.equal(hostAdapterForSessionId('claude-session').waitsForStopTranscriptFlush, true);
   assert.equal(hostAdapterForSessionId('codex:t1').waitsForStopTranscriptFlush, true);
   assert.equal(hostAdapterForSessionId('grok:t1').waitsForStopTranscriptFlush, false);
+  assert.equal(hostAdapterForSessionId('cursor:t1').waitsForStopTranscriptFlush, false);
+});
+
+test('only Cursor consumes handoff at sessionStart', () => {
+  assert.equal(hostAdapterForSessionId('claude-session').consumesHandoffAtSessionStart, false);
+  assert.equal(hostAdapterForSessionId('codex:t1').consumesHandoffAtSessionStart, false);
+  assert.equal(hostAdapterForSessionId('grok:t1').consumesHandoffAtSessionStart, false);
+  assert.equal(hostAdapterForSessionId('cursor:t1').consumesHandoffAtSessionStart, true);
 });

package/src/hosts/index.mjs

@@ -5,26 +5,35 @@
  * `normalizeHookPayload` と `hostAdapterForSessionId` だけを使い、
  * ベンダー分岐を直接書かない。
  */
-import { hostOfSessionId, CLAUDE_HOST, CODEX_HOST, GROK_HOST } from './identity.mjs';
+import { hostOfSessionId, CLAUDE_HOST, CODEX_HOST, GROK_HOST, CURSOR_HOST } from './identity.mjs';
 import { claudeHostAdapter } from './claude.mjs';
 import { codexHostAdapter } from './codex.mjs';
 import { grokHostAdapter, isGrokEnvelope, normalizeGrokHookPayload } from './grok.mjs';
+import { cursorHostAdapter, isCursorEnvelope, normalizeCursorHookPayload } from './cursor.mjs';
 
 export * from './identity.mjs';
 export { isGrokEnvelope, deriveGrokChatHistoryPath, normalizeGrokHookPayload } from './grok.mjs';
+export {
+  isCursorEnvelope,
+  encodeCursorProjectDir,
+  deriveCursorTranscriptPath,
+  normalizeCursorHookPayload,
+} from './cursor.mjs';
 
 const ADAPTERS = Object.freeze({
   [CLAUDE_HOST]: claudeHostAdapter,
   [CODEX_HOST]: codexHostAdapter,
   [GROK_HOST]: grokHostAdapter,
+  [CURSOR_HOST]: cursorHostAdapter,
 });
 
 /**
  * hook stdin payload を Claude snake_case 契約へ正規化する。
- * 現状 camelCase envelope を送るのは Grok だけ (v0.10.0 / ADR 0021)。
+ * Grok は camelCase wire、Cursor は hook_event_name が sessionStart 等。
  */
 export function normalizeHookPayload(payload, options = {}) {
   if (isGrokEnvelope(payload)) return normalizeGrokHookPayload(payload, options);
+  if (isCursorEnvelope(payload)) return normalizeCursorHookPayload(payload, options);
   return payload;
 }
 

package/src/os/app-dirs.mjs

@@ -0,0 +1,25 @@
+/**
+ * os/app-dirs.mjs — OS別のユーザー設定/状態ベースディレクトリ解決
+ *
+ * LOCALAPPDATA（Windows）と XDG_CONFIG_HOME / XDG_STATE_HOME（POSIX）の
+ * フォールバック組み立てが runtime-error-store と completed-turn-receipts に
+ * 別々に書かれていたため、ここへ集約する。最終的なアプリ別 join は呼び出し側が持つ。
+ */
+import { homedir } from 'node:os';
+import { join } from 'node:path';
+
+function homeOf(env) {
+  return env.HOME || env.USERPROFILE || homedir();
+}
+
+export function windowsLocalAppData(env = process.env) {
+  return env.LOCALAPPDATA || join(homeOf(env), 'AppData', 'Local');
+}
+
+export function xdgConfigHome(env = process.env) {
+  return env.XDG_CONFIG_HOME || join(homeOf(env), '.config');
+}
+
+export function xdgStateHome(env = process.env) {
+  return env.XDG_STATE_HOME || join(homeOf(env), '.local', 'state');
+}

package/src/os/paths.mjs

@@ -10,3 +10,7 @@ import { platform } from 'node:os';
 export function foldPathCaseForPlatform(path, { hostPlatform = platform() } = {}) {
   return hostPlatform === 'win32' ? path.toLowerCase() : path;
 }
+
+export function isWin32Platform(hostPlatform = platform()) {
+  return hostPlatform === 'win32';
+}

package/src/runtime-error-store.mjs

@@ -10,12 +10,13 @@ import {
   writeFileSync,
 } from 'node:fs';
 import childProcess from 'node:child_process';
-import { arch as hostArch, homedir, platform as hostPlatform } from 'node:os';
+import { arch as hostArch, platform as hostPlatform } from 'node:os';
 import { dirname, join } from 'node:path';
 import { createRequire } from 'node:module';
 import { fileURLToPath } from 'node:url';
 import { DatabaseSync } from 'node:sqlite';
 import { applyAndVerifyWindowsAcl, isWindows, verifyWindowsAcl } from './os/windows-acl.mjs';
+import { windowsLocalAppData, xdgConfigHome, xdgStateHome } from './os/app-dirs.mjs';
 
 const require = createRequire(import.meta.url);
 const PACKAGE_VERSION = require('../package.json').version;
@@ -53,19 +54,17 @@ const DEFINITIONS = Object.freeze({
 });
 
 export function defaultFactoryReporterConfigPath(env = process.env) {
-  const home = env.HOME || env.USERPROFILE || homedir();
   if (isWindows(env)) {
-    return join(env.LOCALAPPDATA || join(home, 'AppData', 'Local'), 'dotagents', 'factory-reporter', 'config.json');
+    return join(windowsLocalAppData(env), 'dotagents', 'factory-reporter', 'config.json');
   }
-  return join(env.XDG_CONFIG_HOME || join(home, '.config'), 'dotagents', 'factory-reporter.json');
+  return join(xdgConfigHome(env), 'dotagents', 'factory-reporter.json');
 }
 
 export function defaultRuntimeErrorStorePath(env = process.env) {
-  const home = env.HOME || env.USERPROFILE || homedir();
   if (isWindows(env)) {
-    return join(env.LOCALAPPDATA || join(home, 'AppData', 'Local'), 'throughline', 'runtime-errors.json');
+    return join(windowsLocalAppData(env), 'throughline', 'runtime-errors.json');
   }
-  return join(env.XDG_STATE_HOME || join(home, '.local', 'state'), 'throughline', 'runtime-errors.json');
+  return join(xdgStateHome(env), 'throughline', 'runtime-errors.json');
 }
 
 export function isRuntimeErrorCollectionEnabled({ env = process.env, configPath } = {}) {

package/src/session-start.mjs

@@ -32,7 +32,8 @@ import { logDecision } from './decision-log.mjs';
 import { existsSync } from 'node:fs';
 import { pathToFileURL } from 'node:url';
 import { recordRuntimeErrorBestEffort } from './runtime-error-store.mjs';
-import { NON_CLAUDE_SESSION_PREFIXES, normalizeHookPayload } from './hosts/index.mjs';
+import { hostAdapterForSessionId, NON_CLAUDE_SESSION_PREFIXES, normalizeHookPayload } from './hosts/index.mjs';
+import { executeFirstPromptHandoff } from './handoff-executor.mjs';
 
 const ENV_DISABLE_AUTO_HANDOFF = 'THROUGHLINE_DISABLE_AUTO_HANDOFF';
 
@@ -161,6 +162,28 @@ export async function run() {
     pending_registered: true,
   });
 
+  // Cursor は beforeSubmitPrompt が additional_context を持たない。
+  // 新規 composer 会話の sessionStart が公式の注入口なので、ここで第二相を実行する。
+  // Claude の幽霊 SessionStart 問題はこの host では sessionStart = 会話作成のため適用しない。
+  // クラウド / background agent は baton を奪わない。
+  const hostAdapter = hostAdapterForSessionId(session_id);
+  if (hostAdapter.consumesHandoffAtSessionStart === true && payload.is_background_agent !== true) {
+    const handoff = executeFirstPromptHandoff(db, {
+      sessionId: session_id,
+      projectPath,
+      now,
+    });
+    if (handoff.attempted && handoff.injectionText) {
+      const delivery = hostAdapter.deliverHandoffInjection({
+        payload,
+        text: handoff.injectionText,
+      });
+      if (!delivery.delivered) {
+        process.stderr.write(`[session-start] ${delivery.reason}\n`);
+      }
+    }
+  }
+
   process.exit(0);
 }
 

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

@@ -0,0 +1,43 @@
+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, sliceCurrentTurnEntries, readRawEntries } from './transcript-reader.mjs';
+
+test('readTranscript accepts Cursor agent-transcripts role-first jsonl', () => {
+  const dir = mkdtempSync(join(tmpdir(), 'tl-cursor-transcript-'));
+  const path = join(dir, '7face712.jsonl');
+  writeFileSync(
+    path,
+    [
+      JSON.stringify({
+        role: 'user',
+        message: { content: [{ type: 'text', text: 'hello cursor' }] },
+      }),
+      JSON.stringify({
+        role: 'assistant',
+        message: { content: [{ type: 'text', text: 'captured reply' }] },
+      }),
+    ].join('\n'),
+  );
+  try {
+    const turns = readTranscript(path);
+    assert.deepEqual(
+      turns.map((t) => ({ role: t.role, content: t.content })),
+      [
+        { role: 'user', content: 'hello cursor' },
+        { role: 'assistant', content: 'captured reply' },
+      ],
+    );
+    const groups = getLogicalTurnGroups(path);
+    assert.equal(groups.length, 1);
+    assert.equal(groups[0].user.content, 'hello cursor');
+    assert.equal(groups[0].representative.content, 'captured reply');
+    const sliced = sliceCurrentTurnEntries(readRawEntries(path));
+    assert.equal(sliced.length, 2);
+  } finally {
+    rmSync(dir, { recursive: true, force: true });
+  }
+});

package/src/transcript-reader.mjs

@@ -11,6 +11,12 @@
 import { readFileSync, existsSync } from 'fs';
 import { DETAIL_KIND } from './constants.mjs';
 
+function entryKind(entry) {
+  if (typeof entry?.type === 'string' && entry.type.length > 0) return entry.type;
+  if (typeof entry?.role === 'string' && entry.role.length > 0) return entry.role;
+  return undefined;
+}
+
 /**
  * content 配列からテキスト部分だけを結合する。
  * thinking ブロックは除外。
@@ -51,8 +57,9 @@ export function readTranscript(transcriptPath) {
       continue;
     }
 
-    // user / assistant エントリのみ対象
-    if (entry.type !== 'user' && entry.type !== 'assistant') continue;
+    // user / assistant エントリのみ対象。Claude は type、Cursor jsonl は role。
+    const kind = entryKind(entry);
+    if (kind !== 'user' && kind !== 'assistant') continue;
 
     // subagent の sidechain エントリは主会話ではないので除外。現行 CC は主 transcript に
     // 書かない（400 transcript 実測ゼロ件）が、将来変更への安価な防御 (docs/12 B-1)
@@ -60,7 +67,7 @@ export function readTranscript(transcriptPath) {
 
     const msg = entry.message;
     const grokContent = entry.content;
-    const role = msg?.role ?? entry.type;
+    const role = msg?.role ?? kind;
     const rawContent = msg?.content ?? grokContent;
     if (!role || rawContent == null) continue;
 
@@ -258,7 +265,7 @@ export function sliceCurrentTurnEntries(entries) {
   let lastAssistantTextIdx = -1;
   for (let i = entries.length - 1; i >= 0; i--) {
     const e = entries[i];
-    if (e.type !== 'assistant') continue;
+    if (entryKind(e) !== 'assistant') continue;
     const blocks = e.message?.content;
     if (!Array.isArray(blocks)) continue;
     if (blocks.some((b) => b && b.type === 'text' && typeof b.text === 'string' && b.text.length > 0)) {
@@ -272,7 +279,7 @@ export function sliceCurrentTurnEntries(entries) {
   let userTextIdx = -1;
   for (let i = lastAssistantTextIdx - 1; i >= 0; i--) {
     const e = entries[i];
-    if (e.type !== 'user') continue;
+    if (entryKind(e) !== 'user') continue;
     const blocks = e.message?.content;
     if (Array.isArray(blocks)) {
       if (blocks.some((b) => b && b.type === 'text' && typeof b.text === 'string' && b.text.length > 0)) {
@@ -319,7 +326,7 @@ export function extractDetailBlocks(turnEntries) {
   const toolNameById = new Map();
 
   for (const e of turnEntries) {
-    if (e.type === 'assistant') {
+    if (entryKind(e) === 'assistant') {
       const blocks = e.message?.content;
       if (!Array.isArray(blocks)) continue;
       for (let i = 0; i < blocks.length; i++) {
@@ -355,7 +362,7 @@ export function extractDetailBlocks(turnEntries) {
         }
         // text は扱わない
       }
-    } else if (e.type === 'user') {
+    } else if (entryKind(e) === 'user') {
       const blocks = e.message?.content;
       if (!Array.isArray(blocks)) continue;
       for (const b of blocks) {