throughline 0.6.1 → 0.6.2

package/src/factory-diagnostics.test.mjs

@@ -0,0 +1,97 @@
+import { test } from 'node:test';
+import assert from 'node:assert/strict';
+
+import {
+  FACTORY_DIAGNOSTICS_SCHEMA,
+  buildFactoryDiagnostics,
+} from './factory-diagnostics.mjs';
+
+test('factory diagnostics: 未設定の native factory は not_applicable を成功へ丸めない', () => {
+  const result = buildFactoryDiagnostics({
+    version: '0.6.1',
+    database: { status: 'not_applicable', reason: 'db_not_found', schemaVersion: null, handoffMemory: false },
+    hooks: { status: 'not_applicable', claudeStatus: 'not_applicable', reason: 'hooks_not_registered', events: {} },
+    thread: { status: 'not_applicable', reason: 'codex_thread_not_detected', rolloutAvailable: false },
+  });
+
+  assert.equal(result.schema, FACTORY_DIAGNOSTICS_SCHEMA);
+  assert.equal(result.overall.status, 'not_applicable');
+  assert.equal(result.readiness.capture.status, 'not_applicable');
+  assert.equal(result.readiness.restore.status, 'not_applicable');
+  assert.equal(result.readiness.handoff.status, 'not_applicable');
+});
+
+test('factory diagnostics: restore は実行していない smoke を ready にしない', () => {
+  const result = buildFactoryDiagnostics({
+    version: '0.6.1',
+    database: { status: 'ready', reason: 'db_schema_supported', schemaVersion: 8, handoffMemory: true },
+    hooks: {
+      status: 'ready',
+      claudeStatus: 'ready',
+      reason: 'managed_hooks_ready',
+      events: {
+        userPromptSubmit: 'ready',
+        postToolUse: 'ready',
+        stop: 'ready',
+      },
+    },
+    thread: { status: 'ready', reason: 'thread_and_rollout_detected', rolloutAvailable: true },
+  });
+
+  assert.equal(result.readiness.capture.status, 'ready');
+  assert.equal(result.readiness.handoff.status, 'ready');
+  assert.equal(result.readiness.restore.status, 'ready');
+  assert.equal(result.evidence.restoreSmoke.status, 'unverified');
+  assert.equal(result.overall.status, 'ready');
+});
+
+test('factory diagnostics: JSON に本文、秘密、絶対 path、生 state を含めない', () => {
+  const secret = 'sk-test-very-secret';
+  const body = 'ユーザーの prompt 本文';
+  const absolutePath = '/Users/example/.throughline/state/session.json';
+  const result = buildFactoryDiagnostics({
+    version: '0.6.1',
+    database: {
+      status: 'unverified',
+      reason: `db_open_failed:${secret}:${absolutePath}`,
+      schemaVersion: 8,
+      handoffMemory: false,
+      rawState: { body, secret, absolutePath },
+    },
+    hooks: { status: 'unverified', claudeStatus: 'unverified', reason: `config_unreadable:${absolutePath}`, events: {} },
+    thread: { status: 'unverified', reason: `rollout_unreadable:${body}`, rolloutAvailable: false },
+  });
+
+  const json = JSON.stringify(result);
+  assert.doesNotMatch(json, new RegExp(secret));
+  assert.doesNotMatch(json, new RegExp(body));
+  assert.doesNotMatch(json, new RegExp(absolutePath.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')));
+  assert.equal(result.databaseSchema.reason, 'diagnostic_unverified');
+  assert.equal(result.hooks.reason, 'diagnostic_unverified');
+  assert.equal(result.readiness.capture.reason, 'diagnostic_unverified');
+});
+
+test('factory diagnostics: known not_readyをunverifiedで隠さずDB schemaをoverallへ含める', () => {
+  const result = buildFactoryDiagnostics({
+    version: '0.6.1',
+    database: { status: 'not_ready', schemaVersion: 7, handoffMemory: false },
+    hooks: { status: 'ready', claudeStatus: 'ready', events: {} },
+    thread: { status: 'ready', rolloutAvailable: true },
+  });
+
+  assert.equal(result.databaseSchema.status, 'not_ready');
+  assert.equal(result.readiness.restore.status, 'not_ready');
+  assert.equal(result.overall.status, 'not_ready');
+});
+
+test('factory diagnostics: project不一致threadのmemoryをhandoff readyにしない', () => {
+  const result = buildFactoryDiagnostics({
+    version: '0.6.1',
+    database: { status: 'ready', schemaVersion: 8, supportedSchemaVersion: 8, handoffMemory: true },
+    hooks: { status: 'ready', claudeStatus: 'ready', events: {} },
+    thread: { status: 'not_ready', rolloutAvailable: false },
+  });
+
+  assert.equal(result.readiness.handoff.status, 'not_ready');
+  assert.equal(result.overall.status, 'not_ready');
+});

package/src/haiku-summarizer.mjs

@@ -36,7 +36,6 @@
  *   2. それでも失敗したら L2 全文を L1 に入れる（情報欠損ゼロ）
  */
 
-import { spawnSync } from 'child_process';
 import { mkdtempSync, mkdirSync, rmSync, writeFileSync } from 'fs';
 import { join } from 'path';
 import { homedir, tmpdir } from 'os';
@@ -45,6 +44,7 @@ import {
   CODEX_SIDECAR_STATUS,
   runCodexSidecarCommand,
 } from './codex-sidecar.mjs';
+import { spawnPortableSync } from './portable-spawn-sync.mjs';
 
 const MODEL = 'claude-haiku-4-5-20251001';
 const MAX_RETRIES = 2;
@@ -206,11 +206,10 @@ function summarizeWithHaiku(l2Text, prompt, env) {
 
   for (let attempt = 0; attempt <= MAX_RETRIES; attempt++) {
     try {
-      const result = spawnSync('claude', ['-p', '--model', MODEL, prompt], {
+      const result = spawnPortableSync('claude', ['-p', '--model', MODEL, prompt], {
         input: l2Text,
         encoding: 'utf8',
         timeout: TIMEOUT_MS,
-        shell: process.platform === 'win32', // Windows は claude.cmd ラッパー
         env: childEnv,
         cwd: HAIKU_WORKDIR, // ← これが再帰防止の本丸
       });
@@ -247,7 +246,7 @@ function summarizeWithCodexCli(l2Text, { projectPath, env }) {
   const command = env.THROUGHLINE_CODEX_CLI_BIN ?? 'codex';
   const prompt = buildCodexPrompt(l2Text);
   const childEnv = { ...env, [CODEX_SUMMARIZER_GUARD_ENV]: '1' };
-  const result = spawnSync(
+  const result = spawnPortableSync(
     command,
     [
       'exec',
@@ -265,7 +264,6 @@ function summarizeWithCodexCli(l2Text, { projectPath, env }) {
       input: l2Text,
       encoding: 'utf8',
       timeout: CODEX_CLI_TIMEOUT_MS,
-      shell: process.platform === 'win32',
       env: childEnv,
       cwd: projectPath,
     },

package/src/haiku-summarizer.test.mjs

@@ -2,14 +2,29 @@ import { test } from 'node:test';
 import assert from 'node:assert/strict';
 import { chmodSync, mkdtempSync, readFileSync, rmSync, writeFileSync } from 'node:fs';
 import { tmpdir } from 'node:os';
-import { join } from 'node:path';
+import { delimiter, join } from 'node:path';
 import { summarizeToL1 } from './haiku-summarizer.mjs';
 
 function makeBin(dir, name, body) {
-  const path = join(dir, name);
-  writeFileSync(path, body);
-  chmodSync(path, 0o755);
-  return path;
+  const script = join(dir, `${name}.mjs`);
+  writeFileSync(script, body);
+  if (process.platform === 'win32') {
+    const command = join(dir, `${name}.cmd`);
+    writeFileSync(command, `@echo off\r\n${JSON.stringify(process.execPath)} ${JSON.stringify(script)} %*\r\n`);
+    writeFileSync(join(dir, `${name}.ps1`), `& ${JSON.stringify(process.execPath)} ${JSON.stringify(script)} @args\nexit $LASTEXITCODE\n`);
+    return command;
+  }
+  const command = join(dir, name);
+  writeFileSync(command, `#!/bin/sh\nexec ${JSON.stringify(process.execPath)} ${JSON.stringify(script)} "$@"\n`);
+  chmodSync(command, 0o755);
+  return command;
+}
+
+function envWithPrependedPath(dir) {
+  const env = { ...process.env };
+  const pathKey = Object.keys(env).find((key) => key.toLowerCase() === 'path') ?? 'PATH';
+  env[pathKey] = `${dir}${delimiter}${env[pathKey] ?? ''}`;
+  return env;
 }
 
 test('summarizeToL1: returns empty fallback for blank input', () => {
@@ -44,13 +59,11 @@ test('summarizeToL1: uses codex-sidecar when diagnostics and run both succeed',
     const sidecar = makeBin(
       dir,
       'codex-sidecar',
-      `#!/usr/bin/env bash
-if [ "$1" = "diagnostics" ]; then
-  printf '{"status":"ok"}\\n'
-  exit 0
-fi
-printf '{"status":"ok","summary":"sidecar summary"}\\n'
-exit 0
+      `if (process.argv[2] === 'diagnostics') {
+  process.stdout.write('{"status":"ok"}\\n');
+} else {
+  process.stdout.write('{"status":"ok","summary":"sidecar summary"}\\n');
+}
 `,
     );
 
@@ -78,13 +91,11 @@ test('summarizeToL1: accepts stable SidecarResult summary without status field',
     const sidecar = makeBin(
       dir,
       'codex-sidecar',
-      `#!/usr/bin/env bash
-if [ "$1" = "diagnostics" ]; then
-  printf '{"status":"ok"}\\n'
-  exit 0
-fi
-printf '{"summary":"stable sidecar summary","confidence":{"level":"high"},"recommendedNextAction":"continue"}\\n'
-exit 0
+      `if (process.argv[2] === 'diagnostics') {
+  process.stdout.write('{"status":"ok"}\\n');
+} else {
+  process.stdout.write('{"summary":"stable sidecar summary","confidence":{"level":"high"},"recommendedNextAction":"continue"}\\n');
+}
 `,
     );
 
@@ -112,9 +123,8 @@ test('summarizeToL1: when sidecar is disabled, keeps current Haiku-compatible pa
     makeBin(
       dir,
       'claude',
-      `#!/usr/bin/env bash
-cat >/dev/null
-printf 'haiku summary\\n'
+      `for await (const _chunk of process.stdin) {}
+process.stdout.write('haiku summary\\n');
 `,
     );
 
@@ -122,8 +132,7 @@ printf 'haiku summary\\n'
       hostMode: 'claude-primary',
       projectPath: '/repo',
       env: {
-        ...process.env,
-        PATH: `${dir}:${process.env.PATH ?? ''}`,
+        ...envWithPrependedPath(dir),
         THROUGHLINE_CODEX_SIDECAR_DISABLED: '1',
       },
     });
@@ -143,21 +152,19 @@ test('summarizeToL1: sidecar run failure keeps current Haiku-compatible path', (
     const sidecar = makeBin(
       dir,
       'codex-sidecar',
-      `#!/usr/bin/env bash
-if [ "$1" = "diagnostics" ]; then
-  printf '{"status":"ok"}\\n'
-  exit 0
-fi
-printf 'sidecar failed\\n' >&2
-exit 42
+      `if (process.argv[2] === 'diagnostics') {
+  process.stdout.write('{"status":"ok"}\\n');
+} else {
+  process.stderr.write('sidecar failed\\n');
+  process.exit(42);
+}
 `,
     );
     makeBin(
       dir,
       'claude',
-      `#!/usr/bin/env bash
-cat >/dev/null
-printf 'haiku after sidecar failure\\n'
+      `for await (const _chunk of process.stdin) {}
+process.stdout.write('haiku after sidecar failure\\n');
 `,
     );
 
@@ -165,8 +172,7 @@ printf 'haiku after sidecar failure\\n'
       hostMode: 'claude-primary',
       projectPath: '/repo',
       env: {
-        ...process.env,
-        PATH: `${dir}:${process.env.PATH ?? ''}`,
+        ...envWithPrependedPath(dir),
         THROUGHLINE_CODEX_SIDECAR_BIN: sidecar,
       },
     });
@@ -199,10 +205,12 @@ test('summarizeToL1: codex-primary uses Codex CLI backend', () => {
     const codex = makeBin(
       dir,
       'codex',
-      `#!/usr/bin/env bash
-printf '%s\\n' "$@" > "${argsFile}"
-cat > "${stdinFile}"
-printf 'codex summary\\n'
+      `import { writeFileSync } from 'node:fs';
+writeFileSync(${JSON.stringify(argsFile)}, process.argv.slice(2).join('\\n') + '\\n');
+let input = '';
+for await (const chunk of process.stdin) input += chunk;
+writeFileSync(${JSON.stringify(stdinFile)}, input);
+process.stdout.write('codex summary\\n');
 `,
     );
 
@@ -244,16 +252,14 @@ test('summarizeToL1: codex-primary failure is not hidden by fallback', () => {
     const codex = makeBin(
       dir,
       'codex',
-      `#!/usr/bin/env bash
-printf 'codex failed\\n' >&2
-exit 42
+      `process.stderr.write('codex failed\\n');
+process.exit(42);
 `,
     );
     makeBin(
       dir,
       'claude',
-      `#!/usr/bin/env bash
-printf 'should not run\\n'
+      `process.stdout.write('should not run\\n');
 `,
     );
 
@@ -263,8 +269,7 @@ printf 'should not run\\n'
           hostMode: 'codex-primary',
           projectPath: dir,
           env: {
-            ...process.env,
-            PATH: `${dir}:${process.env.PATH ?? ''}`,
+            ...envWithPrependedPath(dir),
             THROUGHLINE_CODEX_CLI_BIN: codex,
           },
         }),

package/src/hook-entrypoints.test.mjs

@@ -408,7 +408,9 @@ test('process-turn subprocess backfills all completed logical turns from a multi
   }
 });
 
-test('session-start backfills a derived predecessor transcript without a state file', () => {
+test('session-start backfills a derived predecessor transcript without a state file', {
+  skip: process.platform === 'win32' ? 'Windowsはstate file transcriptPath fallback契約' : undefined,
+}, () => {
   const home = makeTempHome();
   const project = makeTempProject();
   const predecessorId = 'missing-stop-predecessor';

package/src/phase0-spotter-contract.test.mjs

@@ -269,12 +269,11 @@ function snapshotSqliteFiles(path) {
   return [path, `${path}-wal`, `${path}-shm`].map((file) => {
     if (!existsSync(file)) return { file, exists: false };
     const stat = lstatSync(file);
-    return {
-      file,
-      exists: true,
-      size: stat.size,
-      mtimeMs: stat.mtimeMs,
-      bytes: readFileSync(file).toString('hex'),
-    };
+    try {
+      return { file, exists: true, size: stat.size, mtimeMs: stat.mtimeMs, bytes: readFileSync(file).toString('hex') };
+    } catch (error) {
+      if (error?.code === 'EBUSY') return { file, exists: true, size: stat.size, mtimeMs: stat.mtimeMs, readError: 'EBUSY' };
+      throw error;
+    }
   });
 }

package/src/portable-spawn-sync.mjs

@@ -0,0 +1,58 @@
+import { spawnSync } from 'node:child_process';
+import { existsSync } from 'node:fs';
+import { basename, delimiter, dirname, extname, isAbsolute, join } from 'node:path';
+
+function windowsPath(env) {
+  return Object.entries(env).find(([key]) => key.toLowerCase() === 'path')?.[1] ?? '';
+}
+
+function pairedPowerShellShim(command) {
+  const extension = extname(command).toLowerCase();
+  if (extension !== '.cmd' && extension !== '.bat') return null;
+  const sibling = join(dirname(command), `${basename(command, extension)}.ps1`);
+  return existsSync(sibling) ? sibling : null;
+}
+
+function resolveWindowsCommand(command, env) {
+  const extension = extname(command).toLowerCase();
+  if (isAbsolute(command) || command.includes('\\') || command.includes('/')) {
+    return pairedPowerShellShim(command) ?? command;
+  }
+  for (const directory of windowsPath(env).split(delimiter).filter(Boolean)) {
+    for (const suffix of ['.exe', '.ps1', '.cmd', '.bat', '']) {
+      const candidate = join(directory, `${command}${suffix}`);
+      if (!existsSync(candidate)) continue;
+      return pairedPowerShellShim(candidate) ?? candidate;
+    }
+  }
+  return command;
+}
+
+export function spawnPortableSync(command, args, options = {}) {
+  const platform = options.platform ?? process.platform;
+  const spawnOptions = { ...options };
+  delete spawnOptions.platform;
+  spawnOptions.shell = false;
+
+  if (platform !== 'win32') return spawnSync(command, args, spawnOptions);
+
+  const env = spawnOptions.env ?? process.env;
+  const resolved = resolveWindowsCommand(command, env);
+  const extension = extname(resolved).toLowerCase();
+  if (['.js', '.cjs', '.mjs'].includes(extension)) {
+    return spawnSync(process.execPath, [resolved, ...args], spawnOptions);
+  }
+  if (extension === '.ps1') {
+    return spawnSync('powershell.exe', [
+      '-NoLogo',
+      '-NoProfile',
+      '-NonInteractive',
+      '-ExecutionPolicy',
+      'Bypass',
+      '-File',
+      resolved,
+      ...args,
+    ], spawnOptions);
+  }
+  return spawnSync(resolved, args, spawnOptions);
+}

package/src/portable-spawn-sync.test.mjs

@@ -0,0 +1,40 @@
+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 { spawnPortableSync } from './portable-spawn-sync.mjs';
+
+test('spawnPortableSync: Windows cmd shim preserves argv boundaries and stdin', {
+  skip: process.platform !== 'win32' ? 'Windows cmd shim contract' : undefined,
+}, () => {
+  const dir = mkdtempSync(join(tmpdir(), 'tl-portable-spawn-'));
+  try {
+    const child = join(dir, 'child.mjs');
+    const command = join(dir, 'child.cmd');
+    const powerShellShim = join(dir, 'child.ps1');
+    writeFileSync(child, `
+process.stdin.setEncoding('utf8');
+let input = '';
+process.stdin.on('data', (chunk) => { input += chunk; });
+process.stdin.on('end', () => {
+  process.stdout.write(JSON.stringify({ args: process.argv.slice(2), input }));
+});
+`);
+    writeFileSync(command, `@echo off\r\n${JSON.stringify(process.execPath)} ${JSON.stringify(child)} %*\r\n`);
+    writeFileSync(powerShellShim, `& ${JSON.stringify(process.execPath)} ${JSON.stringify(child)} @args\nexit $LASTEXITCODE\n`);
+
+    const result = spawnPortableSync(command, ['review prompt', 'a&b', '100%'], {
+      encoding: 'utf8',
+      input: 'stdin body',
+    });
+
+    assert.equal(result.status, 0, result.stderr || result.error?.message);
+    assert.deepEqual(JSON.parse(result.stdout), {
+      args: ['review prompt', 'a&b', '100%'],
+      input: 'stdin body',
+    });
+  } finally {
+    rmSync(dir, { recursive: true, force: true });
+  }
+});

package/src/prompt-submit.mjs

@@ -32,6 +32,7 @@ import { appendFileSync, existsSync, mkdirSync, readFileSync, writeFileSync } fr
 import { join, dirname } from 'node:path';
 import { homedir } from 'node:os';
 import { pathToFileURL } from 'node:url';
+import { recordRuntimeErrorBestEffort } from './runtime-error-store.mjs';
 
 // Phase 0-5 spike marker (SessionStart の spike-inject.flag とは別)
 const PROMPT_SPIKE_MARKER_PATH = join(homedir(), '.throughline', 'spike-prompt.flag');
@@ -243,6 +244,7 @@ async function maybeRunPromptSpike({ payload, sessionId, projectPath }) {
 
 if (process.argv[1] && import.meta.url === pathToFileURL(process.argv[1]).href) {
   run().catch((err) => {
+    recordRuntimeErrorBestEffort('HOOK_PROMPT_SUBMIT_FAILED');
     const msg = err instanceof Error ? err.message : 'unknown';
     process.stderr.write(`[prompt-submit] error: ${msg}\n`);
     process.exit(1);

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

@@ -0,0 +1,106 @@
+import { test } from 'node:test';
+import assert from 'node:assert/strict';
+import { execFileSync, spawnSync } from 'node:child_process';
+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 { applyWindowsPrivateAcl } from './windows-acl-test-helper.mjs';
+
+const BIN = fileURLToPath(new URL('../bin/throughline.mjs', import.meta.url));
+
+function createEnabledEnvironment(prefix) {
+  const root = mkdtempSync(join(tmpdir(), prefix));
+  const env = {
+    ...process.env,
+    HOME: root,
+    USERPROFILE: root,
+    LOCALAPPDATA: root,
+    XDG_CONFIG_HOME: join(root, 'config'),
+    XDG_STATE_HOME: join(root, 'state'),
+  };
+  const configPath = defaultFactoryReporterConfigPath(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' },
+    collection: { enabled: true },
+    reporting: { enabled: false },
+  }));
+  applyWindowsPrivateAcl(configPath);
+  return { root, env };
+}
+
+test('top-level hook owners record one fixed aggregate per failure without replacing hook failure', () => {
+  const { env } = createEnabledEnvironment('throughline-runtime-hook-');
+  const cases = [
+    ['session-start'],
+    ['prompt-submit'],
+    ['process-turn'],
+    ['codex-hook', 'stop'],
+  ];
+  for (const args of cases) {
+    const result = spawnSync(process.execPath, [BIN, ...args], {
+      env,
+      input: '{invalid-json',
+      encoding: 'utf8',
+    });
+    assert.notEqual(result.status, 0, args.join(' '));
+    assert.notEqual(result.stderr, '', args.join(' '));
+    assert.doesNotMatch(result.stderr, /store_unavailable/);
+  }
+
+  const storePath = defaultRuntimeErrorStorePath(env);
+  let store = JSON.parse(readFileSync(storePath, 'utf8'));
+  assert.equal(store.records.length, 4);
+  assert.deepEqual(store.records.map((record) => record.error_code).sort(), [
+    'HOOK_CODEX_FAILED',
+    'HOOK_PROCESS_TURN_FAILED',
+    'HOOK_PROMPT_SUBMIT_FAILED',
+    'HOOK_SESSION_START_FAILED',
+  ]);
+  assert.ok(store.records.every((record) => record.count === 1));
+
+  spawnSync(process.execPath, [BIN, 'process-turn'], {
+    env,
+    input: '{invalid-json',
+    encoding: 'utf8',
+  });
+  store = JSON.parse(readFileSync(storePath, 'utf8'));
+  assert.equal(store.records.find((record) => record.error_code === 'HOOK_PROCESS_TURN_FAILED').count, 2);
+});
+
+test('store failure preserves product failure and emits only fixed storage diagnostic', () => {
+  const { env } = createEnabledEnvironment('throughline-runtime-hook-store-fail-');
+  const storePath = defaultRuntimeErrorStorePath(env);
+  mkdirSync(dirname(storePath), { recursive: true });
+  writeFileSync(storePath, '{broken');
+
+  const result = spawnSync(process.execPath, [BIN, 'prompt-submit'], {
+    env,
+    input: '{invalid-json',
+    encoding: 'utf8',
+  });
+  assert.notEqual(result.status, 0);
+  assert.match(result.stderr, /store_unavailable/);
+  assert.match(result.stderr, /SyntaxError|JSON/);
+  assert.doesNotMatch(result.stderr, /runtime error store schema invalid/);
+});
+
+test('FIFO config cannot block the original hook failure', { skip: process.platform === 'win32' }, () => {
+  const { env } = createEnabledEnvironment('throughline-runtime-hook-fifo-');
+  const config = defaultFactoryReporterConfigPath(env);
+  execFileSync('rm', ['-f', config]);
+  execFileSync('mkfifo', [config]);
+  const started = Date.now();
+  const result = spawnSync(process.execPath, [BIN, 'prompt-submit'], {
+    env,
+    input: '{invalid-json',
+    encoding: 'utf8',
+    timeout: 2_000,
+  });
+  assert.notEqual(result.status, 0);
+  assert(Date.now() - started < 1_500);
+  assert.match(result.stderr, /SyntaxError|JSON/);
+});

package/src/runtime-error-observer.mjs

@@ -0,0 +1,8 @@
+import { observeRuntimeError } from './runtime-error-store.mjs';
+
+try {
+  const result = observeRuntimeError({ code: process.argv[2] });
+  process.exitCode = result.status === 'disabled' ? 3 : 0;
+} catch {
+  process.exitCode = 1;
+}