throughline 0.10.2 → 0.10.5

package/src/hosts/claude.mjs

@@ -21,6 +21,7 @@ export const claudeHostAdapter = Object.freeze({
   resolveCommandPrompt({ prompt }) {
     return prompt;
   },
+  consumesHandoffAtSessionStart: false,
   afterBatonWrite() {
     return { launched: false };
   },

package/src/hosts/codex.mjs

@@ -22,6 +22,7 @@ export const codexHostAdapter = Object.freeze({
   resolveCommandPrompt({ prompt }) {
     return prompt;
   },
+  consumesHandoffAtSessionStart: false,
   afterBatonWrite() {
     return { launched: false };
   },

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 — 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/product-ci-contract.test.mjs

@@ -0,0 +1,14 @@
+import assert from 'node:assert/strict';
+import { readFileSync } from 'node:fs';
+import { test } from 'node:test';
+
+test('windows-native product CI uses PowerShell 7 only', () => {
+  const source = readFileSync(new URL('../.github/workflows/product-full-ci.yml', import.meta.url), 'utf8');
+  const windowsBlocks = source
+    .split(/\n(?= {6}- name:)/)
+    .filter((block) => block.includes("matrix.environment == 'windows-native'"));
+  assert.equal(windowsBlocks.length, 3);
+  for (const block of windowsBlocks) assert.match(block, /\n        shell: pwsh\n/);
+  assert.match(windowsBlocks[0], /\$env:GITHUB_ENV/);
+  assert.doesNotMatch(source, /Git\\bin\\bash|Git\/bin\/bash|shell:\s*(?:powershell|cmd)\b/i);
+});

package/src/prompt-submit.mjs

@@ -1,6 +1,6 @@
 #!/usr/bin/env node
 /**
- * UserPromptSubmit hook — 二相ハンドオフ第二相 + /tl & /clear バトン書き込み + Phase 0-5 spike
+ * UserPromptSubmit hook — 二相ハンドオフ第二相 + /tl バトン書き込み + Phase 0-5 spike
  *
  * stdin: { session_id, cwd, prompt, transcript_path, hook_event_name, ... }
  *
@@ -13,23 +13,21 @@
  *     注入がこの hook に移ったため、SessionStart 側の注入は廃止済み
  *     (旧「二重注入回避」制約はこの構成では発生しない)。
  *   - prompt が /tl (単独 or /tl ... 形式) で始まっていればバトンを書き込んで終了
- *   - prompt が /clear (単独 or /clear ... 形式) で始まっていれば、現セッションの
- *     session_id をバトンに書き込んで終了。
- *     (これにより SessionStart 側の findLatestClaudePredecessor heuristic に頼らず、
- *      確定的に「/clear が打たれたセッション」を新セッションに引き継げる。複数
- *      VSCode ウィンドウ等で「最新更新セッション = clear されたセッション」が
- *      成立しない multi-window シナリオで誤った前任を選ばないための確定的指名)
+ *   - `/clear` 文字列を受け取った場合の互換バトン分岐は残す。ただし、実測した
+ *     Claude Code の組み込み `/clear` はこの hook に届かない。VS Code は
+ *     SessionStart source='clear' の auto path、Desktop は事前 `/tl` を使う。
  *   - それ以外は何もせず exit 0（プロンプトはそのまま Claude に渡る）
- *   - 本 hook は引き継ぎ注入を行わない (SessionStart の stdout 注入と二重にならないため)
+ *   - pending intent がある最初のプロンプトでは、本 hook が引き継ぎ注入を行う。
  *
  *   - **Phase 0-5 spike (SPIKE ONLY)**: marker file `~/.throughline/spike-prompt.flag`
  *     が存在し、当該セッションでまだ spike を打っていなければ、JSONL に user/assistant
  *     行を chain-reachable (= 直前の attachment uuid を parent に取る) で append する。
  *     SessionStart 経路の spike (chain (a) = orphan) ではモデルに届かなかったため、
  *     UserPromptSubmit 経路で chain (b) を成立させて再検証する。
- *     docs/10_transcript_injection_plan.md Phase 0-5 参照。
+ *     docs/archive/10_transcript_injection_plan.md Phase 0-5 参照。
  *
- * 設計背景: docs/03_inheritance_on_clear_only.md バトン方式
+ * 設計背景: docs/archive/03_inheritance_on_clear_only.md バトン方式
+ * 現行契約: docs/02_clear_auto_handoff_plan.md
  */
 
 import { getDb } from './db.mjs';

package/src/resume-context.mjs

@@ -2,16 +2,16 @@
  * resume-context.mjs — 引継ぎ注入テキストを組み立てる共有モジュール
  *
  * 呼び出し元:
- *   - session-start.mjs (auto path / baton path どちらでも同じ注入)
+ *   - handoff-executor.mjs（最初のUserPromptSubmitでauto path / baton path共通注入）
  *
  * 設計 (docs/02_clear_auto_handoff_plan.md):
- *   - 注入順: ヘッダ + 読み方 → 現在地アンカー → L1 要約 → L2 本文（一番下）
+ *   - 予算付き注入: ヘッダ + 現在地アンカー + pull案内を固定部とし、残りへ
+ *     直近L2ターン全文を新しい順にターン原子で詰める。L1は直接注入しない。
  *   - 「現在地」アンカーは直前の user / assistant turn をヘッダ直下に再掲して
  *     最初の注意を最新ターンに固定する。L2 末尾アンカーは補強として残す。
  *     （L2 が長くなると末尾アンカーだけでは前半の古いターンに注意が固着し、
  *      話の流れを取り違える事例があった）
- *   - L3 は別セクションを設けず、対応する L1 / L2 行にインラインで
- *     `[→ throughline detail HH:MM:SS (kind …)]` ヒントを付ける
+ *   - L3は本文を注入せず、`throughline detail HH:MM:SS`でpullする
  *   - L2 全文があれば最後の assistant turn 自体に「次に何をしようとしていたか」が
  *     含まれるため、memo / thinking / 末尾の再開指示は注入しない
  *   - 各行頭に [HH:MM:SS] 時刻プレフィックス（L2 は body の created_at、

package/src/runtime-error-hook.test.mjs

@@ -5,7 +5,7 @@ import { mkdirSync, mkdtempSync, readFileSync, writeFileSync } from 'node:fs';
 import { tmpdir } from 'node:os';
 import { dirname, join } from 'node:path';
 import { fileURLToPath } from 'node:url';
-import { defaultFactoryReporterConfigPath, defaultRuntimeErrorStorePath } from './runtime-error-store.mjs';
+import { defaultRuntimeErrorConfigPath, defaultRuntimeErrorStorePath } from './runtime-error-store.mjs';
 import { applyWindowsPrivateAcl } from './os/windows-acl-test-helper.mjs';
 
 const BIN = fileURLToPath(new URL('../bin/throughline.mjs', import.meta.url));
@@ -20,13 +20,11 @@ function createEnabledEnvironment(prefix) {
     XDG_CONFIG_HOME: join(root, 'config'),
     XDG_STATE_HOME: join(root, 'state'),
   };
-  const configPath = defaultFactoryReporterConfigPath(env);
+  const configPath = defaultRuntimeErrorConfigPath(env);
   mkdirSync(dirname(configPath), { recursive: true });
   writeFileSync(configPath, JSON.stringify({
-    schema_version: '1.0',
-    host: { id: 'test-host', profile: process.platform === 'win32' ? 'windows-native' : 'mac' },
+    schema: 'throughline.runtime_error_config.v1',
     collection: { enabled: true },
-    reporting: { enabled: false },
   }));
   applyWindowsPrivateAcl(configPath);
   return { root, env };
@@ -90,7 +88,7 @@ test('store failure preserves product failure and emits only fixed storage diagn
 
 test('FIFO config cannot block the original hook failure', { skip: process.platform === 'win32' }, () => {
   const { env } = createEnabledEnvironment('throughline-runtime-hook-fifo-');
-  const config = defaultFactoryReporterConfigPath(env);
+  const config = defaultRuntimeErrorConfigPath(env);
   execFileSync('rm', ['-f', config]);
   execFileSync('mkfifo', [config]);
   const started = Date.now();

package/src/runtime-error-store.mjs

@@ -22,6 +22,7 @@ const require = createRequire(import.meta.url);
 const PACKAGE_VERSION = require('../package.json').version;
 
 export const RUNTIME_ERROR_STORE_SCHEMA = 'throughline.runtime_errors.v1';
+export const RUNTIME_ERROR_CONFIG_SCHEMA = 'throughline.runtime_error_config.v1';
 export const RUNTIME_ERROR_STATE_SCHEMA_VERSION = '1.0';
 export const RUNTIME_ERROR_DIAGNOSTIC = '[throughline:runtime-errors] store_unavailable\n';
 const DEFAULT_SNAPSHOT_LIMIT = 256;
@@ -53,11 +54,11 @@ const DEFINITIONS = Object.freeze({
   }),
 });
 
-export function defaultFactoryReporterConfigPath(env = process.env) {
+export function defaultRuntimeErrorConfigPath(env = process.env) {
   if (isWindows(env)) {
-    return join(windowsLocalAppData(env), 'dotagents', 'factory-reporter', 'config.json');
+    return join(windowsLocalAppData(env), 'throughline', 'runtime-errors.config.json');
   }
-  return join(xdgConfigHome(env), 'dotagents', 'factory-reporter.json');
+  return join(xdgConfigHome(env), 'throughline', 'runtime-errors.config.json');
 }
 
 export function defaultRuntimeErrorStorePath(env = process.env) {
@@ -69,16 +70,46 @@ export function defaultRuntimeErrorStorePath(env = process.env) {
 
 export function isRuntimeErrorCollectionEnabled({ env = process.env, configPath } = {}) {
   try {
-    const path = configPath || defaultFactoryReporterConfigPath(env);
+    const path = configPath || defaultRuntimeErrorConfigPath(env);
     const info = lstatSync(path);
     if (!info.isFile() || info.isSymbolicLink()) return false;
     const parsed = JSON.parse(readFileSync(path, 'utf8'));
-    return isCanonicalFactoryReporterConfig(parsed) && parsed.collection.enabled === true;
+    return isCanonicalRuntimeErrorConfig(parsed) && parsed.collection.enabled === true;
   } catch {
     return false;
   }
 }
 
+export function setRuntimeErrorCollectionEnabled(enabled, options = {}) {
+  assertExactOptions(options, ['env', 'configPath']);
+  if (typeof enabled !== 'boolean') throw new TypeError('enabled は boolean が必要です');
+  const env = options.env ?? process.env;
+  const path = options.configPath || defaultRuntimeErrorConfigPath(env);
+  const directory = dirname(path);
+  ensurePrivateStoreDirectory(directory, env);
+  const temporary = join(directory, `.runtime-errors-config.${process.pid}.${randomBytes(6).toString('hex')}.tmp`);
+  const config = {
+    schema: RUNTIME_ERROR_CONFIG_SCHEMA,
+    collection: { enabled },
+  };
+  try {
+    writeFileSync(temporary, `${JSON.stringify(config)}\n`, { encoding: 'utf8', mode: 0o600, flag: 'wx' });
+    if (isWindows(env)) {
+      applyAndVerifyWindowsAcl(temporary, false);
+      assertPrivateStoreFileShape(lstatSync(temporary));
+    } else {
+      chmodSync(temporary, 0o600);
+      assertPrivateStoreFile(lstatSync(temporary), env, temporary);
+    }
+    renameSync(temporary, path);
+    if (isWindows(env)) assertPrivateStoreFileShape(lstatSync(path));
+    else assertPrivateStoreFile(lstatSync(path), env, path);
+    return config;
+  } finally {
+    rmSync(temporary, { force: true });
+  }
+}
+
 export function observeRuntimeError(input, options = {}) {
   assertExactInput(input, ['code', 'now']);
   assertExactOptions(options, ['env', 'configPath', 'storePath', 'version', 'platform', 'arch']);
@@ -410,20 +441,11 @@ function assertPrivateStoreFileShape(info) {
   }
 }
 
-function isCanonicalFactoryReporterConfig(value) {
-  if (!isPlainObject(value) || !exactKeys(value, ['schema_version', 'host', 'collection', 'reporting']) || value.schema_version !== '1.0') return false;
-  if (!isPlainObject(value.host) || !exactKeys(value.host, ['id', 'profile']) ||
-    typeof value.host.id !== 'string' || !/^[a-z0-9][a-z0-9._-]{0,63}$/.test(value.host.id) ||
-    !['server', 'mac', 'wsl', 'windows-native'].includes(value.host.profile)) return false;
+function isCanonicalRuntimeErrorConfig(value) {
+  if (!isPlainObject(value) || !exactKeys(value, ['schema', 'collection']) ||
+    value.schema !== RUNTIME_ERROR_CONFIG_SCHEMA) return false;
   if (!isPlainObject(value.collection) || !exactKeys(value.collection, ['enabled']) || typeof value.collection.enabled !== 'boolean') return false;
-  if (!isPlainObject(value.reporting) || !exactKeys(value.reporting, ['enabled', 'endpoint', 'credential_file'], true) || typeof value.reporting.enabled !== 'boolean') return false;
-  if (value.reporting.endpoint !== undefined) {
-    if (typeof value.reporting.endpoint !== 'string' || value.reporting.endpoint.length > 2048) return false;
-    try { if (!['http:', 'https:'].includes(new URL(value.reporting.endpoint).protocol)) return false; } catch { return false; }
-  }
-  if (value.reporting.credential_file !== undefined &&
-    (typeof value.reporting.credential_file !== 'string' || value.reporting.credential_file.length < 1 || value.reporting.credential_file.length > 4096)) return false;
-  return !value.reporting.enabled || (value.reporting.endpoint !== undefined && value.reporting.credential_file !== undefined);
+  return true;
 }
 
 function isPlainObject(value) { return value !== null && typeof value === 'object' && !Array.isArray(value); }