throughline 0.3.24 → 0.4.0

package/src/cli/codex-hook.test.mjs

@@ -0,0 +1,293 @@
+import assert from 'node:assert/strict';
+import { mkdirSync, mkdtempSync, rmSync, 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 { runCodexStopHook, _internal } from './codex-hook.mjs';
+
+function makeDb() {
+  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;
+}
+
+test('codex-hook stop captures rollout using Codex stdin payload fields', async () => {
+  const codexHome = mkdtempSync(join(tmpdir(), 'tl-codex-hook-home-'));
+  const project = mkdtempSync(join(tmpdir(), 'tl-codex-hook-project-'));
+  const threadId = '019dfaba-f87e-7f41-a144-d5ca7c6dd7f9';
+  const db = makeDb();
+  let monitorState = null;
+  let monitorTaskCwd = null;
+  try {
+    const rolloutPath = writeRollout(codexHome, {
+      id: threadId,
+      cwd: project,
+      events: [
+        event('user_message', { message: 'hook request' }),
+        event('task_started'),
+        turnContext({ model: 'gpt-5.5', cwd: project }),
+        event('agent_message', { message: 'hook answer' }),
+        event('task_complete'),
+        tokenCountEvent({
+          inputTokens: 12345,
+          outputTokens: 67,
+          contextWindow: 258400,
+        }),
+      ],
+    });
+
+    const result = await runCodexStopHook({
+      payload: {
+        session_id: threadId,
+        transcript_path: rolloutPath,
+        cwd: project,
+      },
+      env: {},
+      db,
+      ensureMonitorTask: ({ cwd }) => {
+        monitorTaskCwd = cwd;
+      },
+      writeMonitorState: (state) => {
+        monitorState = state;
+      },
+    });
+
+    assert.equal(result.status, 'ok');
+    assert.equal(result.codexThreadIdSource, 'payload:session_id');
+    assert.equal(result.captured.sessionId, `codex:${threadId}`);
+    assert.equal(result.captured.capturedTurns, 1);
+    assert.equal(result.captured.capturedRows, 2);
+    assert.equal(result.summarized.status, 'skipped');
+    assert.equal(result.summarized.reason, 'within_l2_window');
+    assert.equal(monitorState.sessionId, `codex:${threadId}`);
+    assert.equal(monitorState.host, 'codex');
+    assert.equal(monitorState.projectPath, project);
+    assert.equal(monitorState.transcriptPath, null);
+    assert.equal(monitorState.rolloutPath, rolloutPath);
+    assert.equal(monitorState.usage.tokens, 12345);
+    assert.equal(monitorState.usage.model, 'gpt-5.5');
+    assert.equal(monitorState.usage.source, 'codex-rollout-token-count');
+    assert.equal(result.monitorState.sessionId, `codex:${threadId}`);
+    assert.equal(result.autoRefresh.status, 'skipped');
+    assert.equal(result.autoRefresh.reason, 'below_threshold');
+    assert.equal(monitorTaskCwd, project);
+  } finally {
+    db.close();
+    rmSync(codexHome, { recursive: true, force: true });
+    rmSync(project, { recursive: true, force: true });
+  }
+});
+
+test('codex-hook stop runs auto refresh when verified usage reaches 90%', async () => {
+  const codexHome = mkdtempSync(join(tmpdir(), 'tl-codex-hook-home-'));
+  const project = mkdtempSync(join(tmpdir(), 'tl-codex-hook-project-'));
+  const threadId = '019dfaba-f87e-7f41-a144-d5ca7c6dd7f9';
+  const db = makeDb();
+  let autoRefreshArgs = null;
+  try {
+    const rolloutPath = writeRollout(codexHome, {
+      id: threadId,
+      cwd: project,
+      events: [
+        event('user_message', { message: 'hook request' }),
+        event('task_started'),
+        turnContext({ model: 'gpt-5.5', cwd: project }),
+        event('agent_message', { message: 'hook answer' }),
+        event('task_complete'),
+        tokenCountEvent({
+          inputTokens: 240_000,
+          outputTokens: 67,
+          contextWindow: 258400,
+        }),
+      ],
+    });
+
+    const result = await runCodexStopHook({
+      payload: {
+        session_id: threadId,
+        transcript_path: rolloutPath,
+        cwd: project,
+      },
+      env: {},
+      db,
+      ensureMonitorTask: () => {},
+      writeMonitorState: () => {},
+      runAutoRefresh: async (args) => {
+        autoRefreshArgs = args;
+        return {
+          status: 'refreshed-live',
+          reason: 'rollback_and_inject_sent_live',
+        };
+      },
+    });
+
+    assert.equal(result.status, 'ok');
+    assert.equal(result.autoRefresh.status, 'refreshed-live');
+    assert.equal(autoRefreshArgs.threadId, threadId);
+    assert.equal(autoRefreshArgs.codexThreadIdSource, 'payload:session_id');
+    assert.equal(autoRefreshArgs.codexHome, codexHome);
+    assert.equal(autoRefreshArgs.projectPath, project);
+    assert.equal(autoRefreshArgs.sessionId, `codex:${threadId}`);
+    assert.equal(autoRefreshArgs.usage.tokens, 240_000);
+    assert.equal(autoRefreshArgs.usage.contextWindowSize, 258400);
+    assert.equal(autoRefreshArgs.usage.estimated, false);
+    assert.equal(autoRefreshArgs.command, 'codex');
+  } finally {
+    db.close();
+    rmSync(codexHome, { recursive: true, force: true });
+    rmSync(project, { recursive: true, force: true });
+  }
+});
+
+test('codex-hook stop reports camelCase payload thread id source', async () => {
+  const codexHome = mkdtempSync(join(tmpdir(), 'tl-codex-hook-home-'));
+  const project = mkdtempSync(join(tmpdir(), 'tl-codex-hook-project-'));
+  const threadId = '019dfaba-f87e-7f41-a144-d5ca7c6dd7f9';
+  const db = makeDb();
+  try {
+    const rolloutPath = writeRollout(codexHome, {
+      id: threadId,
+      cwd: project,
+      events: [
+        event('user_message', { message: 'hook request' }),
+        event('task_started'),
+        event('agent_message', { message: 'hook answer' }),
+        event('task_complete'),
+      ],
+    });
+
+    const result = await runCodexStopHook({
+      payload: {
+        sessionId: threadId,
+        transcriptPath: rolloutPath,
+        cwd: project,
+      },
+      env: {},
+      db,
+      ensureMonitorTask: () => {},
+      writeMonitorState: () => {},
+    });
+
+    assert.equal(result.status, 'ok');
+    assert.equal(result.codexThreadIdSource, 'payload:sessionId');
+    assert.equal(result.captured.sessionId, `codex:${threadId}`);
+  } finally {
+    db.close();
+    rmSync(codexHome, { recursive: true, force: true });
+    rmSync(project, { recursive: true, force: true });
+  }
+});
+
+test('codex-hook stop skips cleanly when Codex thread id is unavailable', async () => {
+  const db = makeDb();
+  try {
+    const result = await runCodexStopHook({
+      payload: { cwd: process.cwd() },
+      env: {},
+      db,
+    });
+    assert.equal(result.status, 'skipped');
+    assert.equal(result.reason, 'codex_thread_id_not_available');
+  } finally {
+    db.close();
+  }
+});
+
+test('codexHomeFromTranscriptPath infers CODEX_HOME from rollout path', () => {
+  const path = '/tmp/codex-home/sessions/2026/05/06/rollout-2026-05-06T09-40-50-id.jsonl';
+  assert.equal(_internal.codexHomeFromTranscriptPath(path), '/tmp/codex-home');
+});
+
+function writeRollout(home, { id, cwd, events }) {
+  const dir = join(home, 'sessions', '2026', '05', '06');
+  mkdirSync(dir, { recursive: true });
+  const path = join(dir, `rollout-2026-05-06T09-40-50-${id}.jsonl`);
+  writeFileSync(path, [sessionMeta(id, cwd), ...events].map((row) => JSON.stringify(row)).join('\n') + '\n');
+  return path;
+}
+
+function sessionMeta(id, cwd) {
+  return {
+    timestamp: '2026-05-06T00:40:50.000Z',
+    type: 'session_meta',
+    payload: {
+      id,
+      timestamp: '2026-05-06T00:40:50.000Z',
+      cwd,
+      source: 'vscode',
+      cli_version: '0.128.0-alpha.1',
+    },
+  };
+}
+
+function event(type, payload = {}) {
+  return {
+    timestamp: '2026-05-06T00:41:00.000Z',
+    type: 'event_msg',
+    payload: { type, ...payload },
+  };
+}
+
+function turnContext(payload = {}) {
+  return {
+    timestamp: '2026-05-06T00:41:00.000Z',
+    type: 'turn_context',
+    payload,
+  };
+}
+
+function tokenCountEvent({ inputTokens, outputTokens, contextWindow }) {
+  return event('token_count', {
+    info: {
+      last_token_usage: {
+        input_tokens: inputTokens,
+        output_tokens: outputTokens,
+        total_tokens: inputTokens + outputTokens,
+      },
+      model_context_window: contextWindow,
+    },
+  });
+}

package/src/cli/codex-host-primitive-audit.mjs

@@ -0,0 +1,110 @@
+import { runCodexHostPrimitiveAudit } from '../codex-host-primitive-audit.mjs';
+
+function parseArgs(args) {
+  const out = {
+    json: false,
+    command: process.env.THROUGHLINE_CODEX_APP_SERVER_BIN ?? 'codex',
+    schemaDir: null,
+    keepGeneratedSchema: false,
+  };
+
+  for (let i = 0; i < args.length; i++) {
+    const arg = args[i];
+    if (arg === '--json') {
+      out.json = true;
+    } else if (arg === '--codex-app-server-bin') {
+      const value = args[++i];
+      if (!value || value.startsWith('-')) throw new Error('--codex-app-server-bin requires a command path');
+      out.command = value;
+    } else if (arg === '--schema-dir') {
+      const value = args[++i];
+      if (!value || value.startsWith('-')) throw new Error('--schema-dir requires a path');
+      out.schemaDir = value;
+    } else if (arg === '--keep-generated-schema') {
+      out.keepGeneratedSchema = true;
+    } else {
+      throw new Error(`unknown argument: ${arg}`);
+    }
+  }
+
+  return out;
+}
+
+function renderTextResult(result) {
+  const lines = [];
+  lines.push('throughline codex host primitive audit');
+  lines.push('');
+  lines.push(`  status:       ${result.status}`);
+  lines.push(`  reason:       ${result.reason}`);
+  lines.push(`  proof scope:  ${result.proofScope ?? 'none'}`);
+  lines.push(`  restart safe: ${result.restartSafePrimitive ? 'yes' : 'no'}`);
+  if (result.generation?.outDir) {
+    lines.push(
+      `  schema:       ${result.generation.outDir}${result.schemaRetained ? '' : ' (temporary, removed)'}`,
+    );
+  } else if (result.schemaDir) {
+    lines.push(`  schema:       ${result.schemaDir}`);
+  }
+  if (result.facts) {
+    const hasNonResurrection =
+      result.facts.hasCurrentThreadNonResurrectionPrimitive ??
+      result.facts.hasCurrentThreadRemediationPrimitive;
+    lines.push('');
+    lines.push(`  thread/rollback:        ${result.facts.threadRollback ? 'present' : 'absent'}`);
+    lines.push(`  thread/inject_items:    ${result.facts.threadInjectItems ? 'present' : 'absent'}`);
+    lines.push(`  thread/compact/start:   ${result.facts.threadCompactStart ? 'present' : 'absent'}`);
+    lines.push(`  thread/read:            ${result.facts.threadRead ? 'present' : 'absent'}`);
+    lines.push(`  thread/turns/list:      ${result.facts.threadTurnsList ? 'present' : 'absent'}`);
+    lines.push(`  thread/resume(history): ${result.facts.threadResumeHistory?.reason ?? 'unknown'}`);
+    lines.push(
+      `  current-thread non-resurrection: ${hasNonResurrection ? 'candidate' : 'absent'}`,
+    );
+  }
+  if (result.repairContract) {
+    lines.push('');
+    lines.push(`  repair contract: ${result.repairContract.status}`);
+    lines.push(`  repair scope:    ${result.repairContract.scope}`);
+    for (const criterion of result.repairContract.criteria ?? []) {
+      const evidence =
+        Array.isArray(criterion.evidence) && criterion.evidence.length > 0
+          ? ` (${criterion.evidence.join(', ')})`
+          : '';
+      lines.push(`  repair criterion: ${criterion.id} = ${criterion.status}${evidence}`);
+    }
+  }
+  for (const decision of result.decisions ?? []) {
+    lines.push(`  decision: ${decision.id} = ${decision.status}`);
+  }
+  if (result.recommendation) {
+    lines.push('');
+    lines.push(`  recommendation: ${result.recommendation.status}`);
+    lines.push(`  next: ${result.recommendation.nextAction}`);
+  }
+  return lines.join('\n');
+}
+
+export async function run(args) {
+  let parsed;
+  try {
+    parsed = parseArgs(args);
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : 'unknown';
+    process.stderr.write(`[codex-host-primitive-audit] ${msg}\n`);
+    process.exit(1);
+  }
+
+  const result = runCodexHostPrimitiveAudit(parsed);
+  if (parsed.json) process.stdout.write(JSON.stringify(result, null, 2) + '\n');
+  else process.stdout.write(renderTextResult(result) + '\n');
+  process.exit(
+    result.status === 'host-primitive-audit-blocked' ||
+      result.status === 'host-primitive-audit-needs-live-validation'
+      ? 0
+      : 1,
+  );
+}
+
+export const _internal = {
+  parseArgs,
+  renderTextResult,
+};

package/src/cli/codex-host-primitive-audit.test.mjs

@@ -0,0 +1,75 @@
+import assert from 'node:assert/strict';
+import test from 'node:test';
+
+import { _internal } from './codex-host-primitive-audit.mjs';
+
+test('codex-host-primitive-audit CLI parses schema and output options', () => {
+  assert.deepEqual(
+    _internal.parseArgs([
+      '--json',
+      '--codex-app-server-bin',
+      '/tmp/codex',
+      '--schema-dir',
+      '/tmp/schema',
+      '--keep-generated-schema',
+    ]),
+    {
+      json: true,
+      command: '/tmp/codex',
+      schemaDir: '/tmp/schema',
+      keepGeneratedSchema: true,
+    },
+  );
+});
+
+test('codex-host-primitive-audit text output shows diagnostic recommendation', () => {
+  const text = _internal.renderTextResult({
+    status: 'host-primitive-audit-blocked',
+    reason: 'no_current_thread_restore_non_resurrection_primitive',
+    proofScope: 'codex_app_server_protocol_schema_only',
+    restartSafePrimitive: false,
+    schemaRetained: true,
+    schemaDir: '/tmp/schema',
+    facts: {
+      threadRollback: true,
+      threadInjectItems: true,
+      threadCompactStart: true,
+      threadRead: false,
+      threadTurnsList: true,
+      threadResumeHistory: { reason: 'thread_resume_history_is_marked_do_not_use' },
+      hasCurrentThreadRemediationPrimitive: false,
+      hasCurrentThreadNonResurrectionPrimitive: false,
+    },
+    repairContract: {
+      status: 'blocked-missing-current-thread-non-resurrection-guarantee',
+      scope: 'host_agnostic_same_thread_repair_contract',
+      criteria: [
+        {
+          id: 'same_current_thread_repair_primitive',
+          status: 'missing',
+          evidence: [],
+        },
+        {
+          id: 'restore_source_non_resurrection_guarantee',
+          status: 'missing',
+          evidence: [],
+        },
+      ],
+    },
+    decisions: [{ id: 'non_resurrection_guarantee_absent', status: 'blocking' }],
+    recommendation: {
+      status: 'diagnostic-only',
+      nextAction: 'do not enable',
+    },
+  });
+
+  assert.match(text, /status:\s+host-primitive-audit-blocked/);
+  assert.match(text, /current-thread non-resurrection:\s+absent/);
+  assert.match(text, /repair contract: blocked-missing-current-thread-non-resurrection-guarantee/);
+  assert.match(text, /repair criterion: same_current_thread_repair_primitive = missing/);
+  assert.match(
+    text,
+    /repair criterion: restore_source_non_resurrection_guarantee = missing/,
+  );
+  assert.match(text, /decision: non_resurrection_guarantee_absent = blocking/);
+});