throughline 0.6.0 → 0.6.2

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

@@ -0,0 +1,279 @@
+import assert from 'node:assert/strict';
+import {
+  existsSync,
+  lstatSync,
+  mkdirSync,
+  mkdtempSync,
+  readFileSync,
+  rmSync,
+  symlinkSync,
+  writeFileSync,
+} from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import test from 'node:test';
+import { DatabaseSync } from 'node:sqlite';
+
+import { captureCodexRolloutToDb } from './codex-capture.mjs';
+import { runCodexUserPromptSubmitHook } from './cli/codex-hook.mjs';
+import { findCodexThreadCandidate } from './codex-thread-index.mjs';
+
+const THREAD_ID = '019dfaba-f87e-7f41-a144-d5ca7c6dd7f9';
+
+function makeCaptureDb() {
+  const db = new DatabaseSync(':memory:');
+  db.exec(`
+    CREATE TABLE sessions (
+      session_id TEXT PRIMARY KEY,
+      project_path TEXT NOT NULL,
+      status TEXT NOT NULL DEFAULT 'active',
+      created_at INTEGER NOT NULL,
+      updated_at INTEGER NOT NULL,
+      merged_into TEXT
+    );
+    CREATE TABLE skeletons (
+      id INTEGER PRIMARY KEY AUTOINCREMENT,
+      session_id TEXT NOT NULL,
+      origin_session_id TEXT,
+      turn_number INTEGER NOT NULL,
+      role TEXT NOT NULL,
+      summary TEXT NOT NULL,
+      created_at INTEGER NOT NULL
+    );
+    CREATE TABLE bodies (
+      id INTEGER PRIMARY KEY AUTOINCREMENT,
+      session_id TEXT NOT NULL,
+      origin_session_id TEXT NOT NULL,
+      turn_number INTEGER NOT NULL,
+      role TEXT NOT NULL,
+      text TEXT NOT NULL,
+      token_count INTEGER,
+      created_at INTEGER NOT NULL
+    );
+    CREATE TABLE details (
+      id INTEGER PRIMARY KEY AUTOINCREMENT,
+      session_id TEXT NOT NULL,
+      origin_session_id TEXT,
+      turn_number INTEGER,
+      tool_name TEXT NOT NULL,
+      input_text TEXT,
+      output_text TEXT,
+      token_count INTEGER NOT NULL DEFAULT 0,
+      created_at INTEGER NOT NULL,
+      kind TEXT,
+      source_id TEXT
+    );
+  `);
+  return db;
+}
+
+function event(type, payload = {}) {
+  return {
+    timestamp: '2026-07-13T00:00:00.000Z',
+    type: 'event_msg',
+    payload: { type, ...payload },
+  };
+}
+
+function developerMemory(text = '## Throughline: Active Work Context\ninternal memory') {
+  return {
+    timestamp: '2026-07-13T00:00:01.000Z',
+    type: 'response_item',
+    payload: {
+      type: 'message',
+      role: 'developer',
+      content: [{ type: 'input_text', text }],
+    },
+  };
+}
+
+function toolInput() {
+  return {
+    timestamp: '2026-07-13T00:00:01.000Z',
+    type: 'response_item',
+    payload: {
+      type: 'function_call',
+      name: 'exec_command',
+      arguments: '{"cmd":"pwd"}',
+      call_id: 'call_inflight',
+    },
+  };
+}
+
+function writeRollout(home, { cwd, id = THREAD_ID, events = [] }) {
+  const dir = join(home, 'sessions', '2026', '07', '13');
+  mkdirSync(dir, { recursive: true });
+  const path = join(dir, `rollout-2026-07-13T00-00-00-${id}.jsonl`);
+  const rows = [
+    {
+      timestamp: '2026-07-13T00:00:00.000Z',
+      type: 'session_meta',
+      payload: { id, cwd, source: 'vscode', cli_version: '0.128.0-alpha.1' },
+    },
+    ...events,
+  ];
+  writeFileSync(path, `${rows.map((row) => JSON.stringify(row)).join('\n')}\n`);
+  return path;
+}
+
+test('Phase 0: capture projection preserves one completed user/assistant pair and its Codex origin identity', () => {
+  const home = mkdtempSync(join(tmpdir(), 'tl-phase0-capture-home-'));
+  const project = mkdtempSync(join(tmpdir(), 'tl-phase0-capture-project-'));
+  const db = makeCaptureDb();
+  try {
+    writeRollout(home, {
+      cwd: project,
+      events: [
+        event('user_message', { message: 'completed user request' }),
+        event('task_started'),
+        event('agent_message', { message: 'completed assistant response' }),
+        event('task_complete'),
+        developerMemory(),
+      ],
+    });
+
+    const result = captureCodexRolloutToDb(db, { threadId: THREAD_ID, codexHome: home, projectPath: project });
+    assert.equal(result.status, 'captured');
+    assert.deepEqual(
+      db
+        .prepare('SELECT origin_session_id, turn_number, role, text FROM bodies ORDER BY id')
+        .all()
+        .map((row) => ({ ...row })),
+      [
+        { origin_session_id: `codex:${THREAD_ID}`, turn_number: 1, role: 'user', text: 'completed user request' },
+        {
+          origin_session_id: `codex:${THREAD_ID}`,
+          turn_number: 1,
+          role: 'assistant',
+          text: 'completed assistant response',
+        },
+      ],
+      'audit projection candidates are completed conversation pairs only',
+    );
+  } finally {
+    db.close();
+    rmSync(home, { recursive: true, force: true });
+    rmSync(project, { recursive: true, force: true });
+  }
+});
+
+test('Phase 0: read-only WAL audit harness sees committed data during a writer transaction without writing DB sidecars', () => {
+  const dir = mkdtempSync(join(tmpdir(), 'tl-phase0-wal-'));
+  const path = join(dir, 'throughline.db');
+  const writer = new DatabaseSync(path);
+  let reader;
+  try {
+    writer.exec('PRAGMA journal_mode = WAL; CREATE TABLE audit_probe (value TEXT); INSERT INTO audit_probe VALUES (\'committed\');');
+    writer.exec("BEGIN IMMEDIATE; UPDATE audit_probe SET value = 'uncommitted';");
+
+    const before = snapshotSqliteFiles(path);
+    reader = new DatabaseSync(path, { readOnly: true });
+    assert.equal(reader.prepare('SELECT value FROM audit_probe').get().value, 'committed');
+    assert.throws(() => reader.exec("INSERT INTO audit_probe VALUES ('forbidden')"));
+    assert.deepEqual(snapshotSqliteFiles(path), before, 'audit reader must not modify DB, -wal, or -shm');
+  } finally {
+    reader?.close();
+    writer.exec('ROLLBACK');
+    writer.close();
+    rmSync(dir, { recursive: true, force: true });
+  }
+});
+
+test('Phase 0: Spotter child environment prevents Throughline Codex hook re-entry before any capture side effect', async () => {
+  const home = mkdtempSync(join(tmpdir(), 'tl-phase0-spotter-home-'));
+  const project = mkdtempSync(join(tmpdir(), 'tl-phase0-spotter-project-'));
+  try {
+    writeRollout(home, {
+      cwd: project,
+      events: [
+        event('user_message', { message: 'must not be captured from Spotter child' }),
+        event('task_started'),
+        event('agent_message', { message: 'must not be captured from Spotter child' }),
+        event('task_complete'),
+      ],
+    });
+
+    for (const childEnv of ['SPOTTER_PARENT_PID', 'SPOTTER_BACKEND', 'SPOTTER_CHILD_BACKEND']) {
+      const db = makeCaptureDb();
+      let monitorWrites = 0;
+      let taskEnsures = 0;
+      try {
+        const result = await runCodexUserPromptSubmitHook({
+          args: { codexThreadId: THREAD_ID, codexHome: home, projectPath: project },
+          env: { [childEnv]: '1' },
+          db,
+          ensureMonitorTask: () => {
+            taskEnsures++;
+          },
+          writeMonitorState: () => {
+            monitorWrites++;
+          },
+          buildMonitorUsage: () => null,
+        });
+
+        assert.equal(result.status, 'skipped', childEnv);
+        assert.equal(result.reason, 'spotter_child_backend', childEnv);
+        assert.equal(taskEnsures, 0, childEnv);
+        assert.equal(monitorWrites, 0, childEnv);
+        assert.equal(db.prepare('SELECT COUNT(*) AS count FROM bodies').get().count, 0, childEnv);
+      } finally {
+        db.close();
+      }
+    }
+  } finally {
+    rmSync(home, { recursive: true, force: true });
+    rmSync(project, { recursive: true, force: true });
+  }
+});
+
+test('Phase 0: project identity accepts a rollout under a marker root subdirectory through symlink and Windows-style case', () => {
+  const home = mkdtempSync(join(tmpdir(), 'tl-phase0-identity-home-'));
+  const markerRoot = mkdtempSync(join(tmpdir(), 'tl-phase0-marker-root-'));
+  const aliasParent = mkdtempSync(join(tmpdir(), 'tl-phase0-marker-alias-'));
+  const child = join(markerRoot, 'packages', 'adapter');
+  const alias = join(aliasParent, 'spotter-link');
+  try {
+    mkdirSync(child, { recursive: true });
+    symlinkSync(markerRoot, alias);
+    assert.ok(lstatSync(alias).isSymbolicLink());
+
+    writeRollout(home, { cwd: child });
+    assert.equal(
+      findCodexThreadCandidate({ threadId: THREAD_ID, codexHome: home, projectPath: alias })?.id,
+      THREAD_ID,
+      'marker root must include rollout cwd descendants after symlink resolution',
+    );
+
+    const windowsThreadId = '019dfabb-1111-7111-8111-111111111111';
+    writeRollout(home, {
+      id: windowsThreadId,
+      cwd: 'C:\\Users\\Kite\\Developer\\Spotter\\packages\\adapter',
+    });
+    assert.equal(
+      findCodexThreadCandidate({
+        threadId: windowsThreadId,
+        codexHome: home,
+        projectPath: 'c:/users/kite/developer/spotter',
+      })?.id,
+      windowsThreadId,
+      'Windows-style path case must retain marker-root descendant identity',
+    );
+  } finally {
+    rmSync(home, { recursive: true, force: true });
+    rmSync(markerRoot, { recursive: true, force: true });
+    rmSync(aliasParent, { recursive: true, force: true });
+  }
+});
+
+function snapshotSqliteFiles(path) {
+  return [path, `${path}-wal`, `${path}-shm`].map((file) => {
+    if (!existsSync(file)) return { file, exists: false };
+    const stat = lstatSync(file);
+    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;
+}