throughline 0.4.9 → 0.4.11

package/src/cli/codex-handoff-start.mjs

@@ -3,7 +3,10 @@ import { buildHandoffRecord } from '../handoff-record.mjs';
 import { renderCodexNewThreadHandoff } from '../codex-handoff.mjs';
 import { buildCodexHandoffSmoke } from '../codex-handoff-smoke.mjs';
 import { buildCodexHandoffModelSmokePrompt } from '../codex-handoff-model-smoke.mjs';
+import { runCodexNewThreadHandoff } from '../codex-app-server.mjs';
 import { estimateTokens } from '../token-estimator.mjs';
+import { sameProjectPath } from '../project-path.mjs';
+import { spawnSync } from 'node:child_process';
 
 async function readStdin() {
   let raw = '';
@@ -43,6 +46,11 @@ function parseArgs(args) {
     maxDetailRefs: undefined,
     maxRecentBodies: undefined,
     maxBodyChars: undefined,
+    execute: false,
+    openHost: 'auto',
+    codexAppServerBin: null,
+    timeoutMs: 120_000,
+    requestTimeoutMs: 60_000,
   };
 
   for (let i = 0; i < args.length; i++) {
@@ -67,6 +75,24 @@ function parseArgs(args) {
       out.maxRecentBodies = parseNonNegativeInteger(args, ++i, '--max-recent-bodies');
     } else if (arg === '--max-body-chars') {
       out.maxBodyChars = parseNonNegativeInteger(args, ++i, '--max-body-chars');
+    } else if (arg === '--execute') {
+      out.execute = true;
+    } else if (arg === '--open-host') {
+      const value = args[++i];
+      if (!['auto', 'vscode', 'cli', 'none'].includes(value)) {
+        throw new Error('--open-host must be auto, vscode, cli, or none');
+      }
+      out.openHost = value;
+    } 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.codexAppServerBin = value;
+    } else if (arg === '--timeout-ms') {
+      out.timeoutMs = parsePositiveInteger(args, ++i, '--timeout-ms');
+    } else if (arg === '--request-timeout-ms') {
+      out.requestTimeoutMs = parsePositiveInteger(args, ++i, '--request-timeout-ms');
     } else if (!arg.startsWith('-') && !out.sessionId) {
       out.sessionId = arg;
     } else {
@@ -78,16 +104,15 @@ function parseArgs(args) {
 }
 
 function findLatestCodexSessionId(db, projectPath) {
-  const row = db
+  const rows = db
     .prepare(
-      `SELECT session_id
+      `SELECT session_id, project_path
        FROM sessions
-       WHERE lower(project_path) = lower(?)
-         AND session_id LIKE 'codex:%'
-       ORDER BY updated_at DESC
-       LIMIT 1`,
+       WHERE session_id LIKE 'codex:%'
+       ORDER BY updated_at DESC`,
     )
-    .get(projectPath);
+    .all();
+  const row = rows.find((candidate) => sameProjectPath(candidate.project_path, projectPath));
   return row?.session_id ?? null;
 }
 
@@ -170,7 +195,9 @@ function buildGuidance({ sessionId, parsed, handoffSmoke, handoffPrompt }) {
     reason: ready ? 'fresh_thread_handoff_start_ready' : 'handoff_smoke_not_ready',
     sessionId,
     mutatesCurrentThread: false,
-    startThreadManually: true,
+    startThreadManually: !parsed.execute,
+    execute: parsed.execute,
+    openHost: parsed.openHost,
     handoffSmoke,
     modelPromptChars: modelPrompt.length,
     estimatedModelPromptTokens: estimateTokens(modelPrompt),
@@ -187,7 +214,9 @@ function buildGuidance({ sessionId, parsed, handoffSmoke, handoffPrompt }) {
           ...(parsed.memoStdin
             ? ['When replaying individual commands, pipe the same memo because they include --memo-stdin.']
             : []),
-          'Start a new Codex thread and provide the handoff prompt as the opening context.',
+          parsed.execute
+            ? 'This command will start a new Codex thread through app-server, inject handoff memory, then open the selected host.'
+            : 'Start a new Codex thread and provide the handoff prompt as the opening context.',
         ]
       : [
           'Fix the failing handoff smoke checks before starting a new Codex thread.',
@@ -204,12 +233,23 @@ function renderTextResult(result) {
   lines.push(`  reason:            ${result.reason}`);
   lines.push(`  session:           ${result.sessionId}`);
   lines.push(`  mutates thread:    ${result.mutatesCurrentThread ? 'yes' : 'no'}`);
+  lines.push(`  execute:           ${result.execute ? 'yes' : 'no'}`);
+  lines.push(`  open host:         ${result.openHost}`);
   lines.push(`  handoff smoke:     ${result.handoffSmoke.status}`);
   lines.push(`  prompt chars:      ${result.handoffSmoke.promptChars}/${result.handoffSmoke.maxPromptChars}`);
   lines.push(`  model prompt:      ${result.modelPromptChars}`);
   if (result.memoReplayNote) {
     lines.push(`  memo replay:       ${result.memoReplayNote}`);
   }
+  if (result.newThread) {
+    lines.push(`  new thread:        ${result.newThread.threadId}`);
+    lines.push(`  turn status:       ${result.newThread.turnStatus}`);
+  }
+  if (result.open) {
+    lines.push(`  open status:       ${result.open.status}`);
+    lines.push(`  vscode url:        ${result.open.vscodeUrl}`);
+    lines.push(`  resume command:    ${result.open.resumeCommand}`);
+  }
   lines.push('');
   lines.push('  commands:');
   lines.push(`    structural smoke:    ${result.commands.structuralSmoke}`);
@@ -228,6 +268,114 @@ function renderTextResult(result) {
   return lines.join('\n');
 }
 
+function resolveOpenHost(host) {
+  if (host !== 'auto') return host;
+  if (
+    process.env.VSCODE_IPC_HOOK_CLI ||
+    process.env.VSCODE_IPC_HOOK ||
+    process.env.TERM_PROGRAM === 'vscode' ||
+    process.env.CODEX_INTERNAL_ORIGINATOR_OVERRIDE === 'codex_vscode'
+  ) {
+    return 'vscode';
+  }
+  return 'cli';
+}
+
+function openStartedCodexThread({ threadId, host, cwd }) {
+  const resolvedHost = resolveOpenHost(host);
+  const vscodeUrl = `vscode://openai.chatgpt/local/${encodeURIComponent(threadId)}`;
+  const resumeCommand = `codex resume ${threadId} --no-alt-screen`;
+  if (resolvedHost === 'none') {
+    return {
+      status: 'skipped',
+      reason: 'open_host_none',
+      host: resolvedHost,
+      vscodeUrl,
+      resumeCommand,
+    };
+  }
+
+  if (resolvedHost === 'vscode') {
+    const result =
+      process.platform === 'darwin'
+        ? spawnSync('open', [vscodeUrl], { encoding: 'utf8' })
+        : process.platform === 'win32'
+          ? spawnSync('cmd.exe', ['/c', 'start', '', vscodeUrl], { encoding: 'utf8' })
+          : spawnSync('xdg-open', [vscodeUrl], { encoding: 'utf8' });
+    if (result.status !== 0) {
+      return {
+        status: 'failed',
+        reason: 'vscode_deep_link_open_failed',
+        host: resolvedHost,
+        vscodeUrl,
+        resumeCommand,
+        error: (result.stderr || result.stdout || '').trim(),
+      };
+    }
+    return {
+      status: 'opened',
+      reason: 'vscode_deep_link_opened',
+      host: resolvedHost,
+      vscodeUrl,
+      resumeCommand,
+    };
+  }
+
+  if (resolvedHost === 'cli') {
+    if (process.platform === 'darwin') {
+      const shellCommand = `cd ${shQuote(cwd)} && TERM=xterm-256color codex resume ${shQuote(threadId)} --no-alt-screen`;
+      const result = spawnSync('osascript', [], {
+        input: `tell application "Terminal"
+  activate
+  do script ${appleString(shellCommand)}
+end tell
+`,
+        encoding: 'utf8',
+      });
+      if (result.status !== 0) {
+        return {
+          status: 'failed',
+          reason: 'terminal_open_failed',
+          host: resolvedHost,
+          vscodeUrl,
+          resumeCommand,
+          error: (result.stderr || result.stdout || '').trim(),
+        };
+      }
+      return {
+        status: 'opened',
+        reason: 'terminal_resume_opened',
+        host: resolvedHost,
+        vscodeUrl,
+        resumeCommand,
+      };
+    }
+    return {
+      status: 'manual',
+      reason: 'cli_auto_open_unsupported_on_platform',
+      host: resolvedHost,
+      vscodeUrl,
+      resumeCommand,
+    };
+  }
+
+  return {
+    status: 'failed',
+    reason: 'unsupported_open_host',
+    host: resolvedHost,
+    vscodeUrl,
+    resumeCommand,
+  };
+}
+
+function shQuote(value) {
+  return `'${String(value).replaceAll("'", "'\\''")}'`;
+}
+
+function appleString(value) {
+  return `"${String(value).replaceAll('\\', '\\\\').replaceAll('"', '\\"')}"`;
+}
+
 export async function run(args) {
   let parsed;
   try {
@@ -280,9 +428,35 @@ export async function run(args) {
     result.prompt = handoffPrompt;
   }
 
+  if (parsed.execute && result.status === 'ready') {
+    const startResult = await runCodexNewThreadHandoff({
+      cwd: process.cwd(),
+      prompt: handoffPrompt,
+      command: parsed.codexAppServerBin ?? 'codex',
+      commandArgs: parsed.codexAppServerBin ? [] : ['app-server', '--listen', 'stdio://'],
+      timeoutMs: parsed.timeoutMs,
+      requestTimeoutMs: parsed.requestTimeoutMs,
+      waitForTurn: false,
+      delivery: 'developer-item',
+    });
+    const openResult = openStartedCodexThread({
+      threadId: startResult.threadId,
+      host: parsed.openHost,
+      cwd: process.cwd(),
+    });
+    result.status = startResult.status === 'started' && openResult.status !== 'failed' ? 'started' : 'started-unverified';
+    result.reason =
+      startResult.status === 'started' && openResult.status !== 'failed'
+        ? 'new_thread_handoff_started'
+        : 'new_thread_handoff_started_but_open_unverified';
+    result.startThreadManually = openResult.status === 'manual';
+    result.newThread = startResult;
+    result.open = openResult;
+  }
+
   if (parsed.json) process.stdout.write(JSON.stringify(result, null, 2) + '\n');
   else process.stdout.write(renderTextResult(result) + '\n');
-  process.exit(result.status === 'ready' ? 0 : 1);
+  process.exit(result.status === 'ready' || result.status === 'started' ? 0 : 1);
 }
 
 export const _internal = {

package/src/cli/codex-handoff-start.test.mjs

@@ -1,7 +1,7 @@
 import { test } from 'node:test';
 import assert from 'node:assert/strict';
 import { spawnSync } from 'node:child_process';
-import { mkdtempSync, rmSync } from 'node:fs';
+import { chmodSync, mkdtempSync, readFileSync, rmSync, writeFileSync } from 'node:fs';
 import { tmpdir } from 'node:os';
 import { dirname, join } from 'node:path';
 import { fileURLToPath } from 'node:url';
@@ -16,6 +16,41 @@ function makeTempProject() {
   return mkdtempSync(join(tmpdir(), 'tl-codex-handoff-start-project-'));
 }
 
+function makeFakeCodexAppServer(dir) {
+  const script = join(dir, 'fake-codex-app-server.mjs');
+  const log = join(dir, 'fake-codex-app-server.log');
+  writeFileSync(
+    script,
+    `#!/usr/bin/env node
+import { appendFileSync } from 'node:fs';
+import { createInterface } from 'node:readline';
+const log = ${JSON.stringify(log)};
+const rl = createInterface({ input: process.stdin });
+function send(message) { process.stdout.write(JSON.stringify(message) + '\\n'); }
+rl.on('line', (line) => {
+  const msg = JSON.parse(line);
+  appendFileSync(log, JSON.stringify(msg) + '\\n');
+  if (msg.method === 'initialized') return;
+  if (msg.method === 'initialize') {
+    send({ id: msg.id, result: { userAgent: 'fake-codex' } });
+  } else if (msg.method === 'thread/start') {
+    send({ id: msg.id, result: { thread: { id: '019e2000-0000-7000-8000-000000000001', turns: [] } } });
+  } else if (msg.method === 'thread/inject_items') {
+    send({ id: msg.id, result: { thread: { id: msg.params.threadId, turns: [] } } });
+  } else if (msg.method === 'turn/start') {
+    send({ id: msg.id, result: { turn: { id: 'turn-handoff' } } });
+    send({ method: 'item/agentMessage/delta', params: { threadId: msg.params.threadId, turnId: 'turn-handoff', itemId: 'item-1', delta: 'OK' } });
+    send({ method: 'turn/completed', params: { threadId: msg.params.threadId, turnId: 'turn-handoff' } });
+  } else {
+    send({ id: msg.id, error: { code: -32601, message: 'unknown method' } });
+  }
+});
+`,
+  );
+  chmodSync(script, 0o755);
+  return { script, log };
+}
+
 async function seedDb(home, project) {
   const originalHome = process.env.HOME;
   const originalUserProfile = process.env.USERPROFILE;
@@ -192,3 +227,47 @@ test('codex-handoff-start propagates memo-stdin to replay commands in JSON guida
     rmSync(home, { recursive: true, force: true });
   }
 });
+
+test('codex-handoff-start execute creates a new app-server thread and can skip opening a host', async () => {
+  const home = makeTempHome();
+  const project = makeTempProject();
+  try {
+    await seedDb(home, project);
+    const { script, log } = makeFakeCodexAppServer(project);
+    const result = runStart(home, project, [
+      '--session',
+      'codex:thread-handoff-start',
+      '--execute',
+      '--open-host',
+      'none',
+      '--codex-app-server-bin',
+      script,
+      '--json',
+    ]);
+
+    assert.equal(result.status, 0, result.stderr);
+    const payload = JSON.parse(result.stdout);
+    assert.equal(payload.status, 'started');
+    assert.equal(payload.reason, 'new_thread_handoff_started');
+    assert.equal(payload.execute, true);
+    assert.equal(payload.startThreadManually, false);
+    assert.equal(payload.newThread.threadId, '019e2000-0000-7000-8000-000000000001');
+    assert.equal(payload.newThread.delivery, 'developer-item');
+    assert.equal(payload.newThread.injectSent, true);
+    assert.equal(payload.newThread.turnStatus, 'not-started');
+    assert.equal(payload.open.status, 'skipped');
+    assert.equal(payload.open.vscodeUrl, 'vscode://openai.chatgpt/local/019e2000-0000-7000-8000-000000000001');
+    assert.match(payload.open.resumeCommand, /codex resume 019e2000-0000-7000-8000-000000000001/);
+
+    const fakeLog = readFileSync(log, 'utf8');
+    assert.match(fakeLog, /"method":"thread\/start"/);
+    assert.match(fakeLog, /"sessionStartSource":"clear"/);
+    assert.match(fakeLog, /"method":"thread\/inject_items"/);
+    assert.doesNotMatch(fakeLog, /"method":"turn\/start"/);
+    assert.match(fakeLog, /## Throughline: New Codex Thread Handoff/);
+    assert.match(fakeLog, /latest handoff start body/);
+  } finally {
+    rmSync(project, { recursive: true, force: true });
+    rmSync(home, { recursive: true, force: true });
+  }
+});

package/src/cli/codex-hook.mjs

@@ -71,36 +71,11 @@ function suppressExperimentalWarnings() {
   });
 }
 
-export function codexContextOutput(text, eventName = 'UserPromptSubmit') {
-  return JSON.stringify({
-    hookSpecificOutput: {
-      hookEventName: eventName,
-      additionalContext: text,
-    },
-  });
-}
-
-function renderAutoRefreshContext({ usage, decision, threadId, eventName = 'UserPromptSubmit' }) {
-  const tokens = Number(usage?.tokens);
-  const contextWindowSize = Number(usage?.contextWindowSize);
-  const ratio = Number(decision?.ratio);
-  const percent = Number.isFinite(ratio) ? `${(ratio * 100).toFixed(1)}%` : 'unknown';
-  const timing =
-    eventName === 'PostToolUse'
-      ? 'Before continuing the current tool loop, run the installed $throughline workflow now.'
-      : 'Before answering the user prompt, run the installed $throughline workflow now.';
-  return [
-    '[throughline] Codex context refresh threshold reached for this current session.',
-    `Thread: ${threadId}`,
-    `Usage: ${Number.isFinite(tokens) ? tokens : 'unknown'} / ${Number.isFinite(contextWindowSize) ? contextWindowSize : 'unknown'} (${percent}); threshold ${(decision.threshold * 100).toFixed(0)}%.`,
-    '',
-    timing,
-    'Execute exactly:',
-    'throughline trim --execute --host codex --all --json',
-    '',
-    'Report only the execution status, whether rollback/inject were sent, durable evidence if present, and the selected memory session; then continue from the refreshed context.',
-    'This trigger was computed from the current Codex rollout token_count, not from token-monitor output.',
-  ].join('\n');
+function codexAutoRefreshDisabledResult() {
+  return {
+    status: 'skipped',
+    reason: 'codex_auto_refresh_disabled',
+  };
 }
 
 async function captureCodexHookSession({
@@ -236,20 +211,20 @@ export async function runCodexStopHook({
   ensureMonitorTask = null,
   buildMonitorUsage = null,
   runAutoRefresh = null,
+  autoRefreshStateStore = null,
 } = {}) {
-  const [{ runCodexAutoRefresh }, capturedState] = await Promise.all([
-    import('../codex-auto-refresh.mjs'),
-    captureCodexHookSession({
-      args,
-      payload,
-      env,
-      db,
-      writeMonitorState,
-      ensureMonitorTask,
-      buildMonitorUsage,
-      summarize: true,
-    }),
-  ]);
+  void runAutoRefresh;
+  void autoRefreshStateStore;
+  const capturedState = await captureCodexHookSession({
+    args,
+    payload,
+    env,
+    db,
+    writeMonitorState,
+    ensureMonitorTask,
+    buildMonitorUsage,
+    summarize: true,
+  });
 
   if (capturedState.status !== 'ok') {
     return {
@@ -261,28 +236,6 @@ export async function runCodexStopHook({
     };
   }
 
-  let autoRefresh = null;
-  try {
-    autoRefresh = await (runAutoRefresh ?? runCodexAutoRefresh)({
-      db: capturedState.db,
-      threadId: capturedState.identity.codexThreadId,
-      codexThreadIdSource: capturedState.identity.codexThreadIdSource,
-      codexHome: capturedState.codexHome,
-      projectPath: capturedState.captured.projectPath ?? capturedState.projectPath,
-      sessionId: capturedState.captured.sessionId,
-      usage: capturedState.usage,
-      command: env.THROUGHLINE_CODEX_APP_SERVER_BIN ?? process.env.THROUGHLINE_CODEX_APP_SERVER_BIN ?? 'codex',
-    });
-  } catch (err) {
-    const msg = err instanceof Error ? err.message : 'unknown';
-    autoRefresh = {
-      status: 'error',
-      reason: 'auto_refresh_failed',
-      message: msg,
-    };
-    process.stderr.write(`[codex-hook:auto-refresh] ${msg}\n`);
-  }
-
   return {
     status: 'ok',
     reason: 'codex_rollout_captured',
@@ -290,7 +243,7 @@ export async function runCodexStopHook({
     captured: capturedState.captured,
     summarized: capturedState.summarized,
     monitorState: capturedState.monitorState,
-    autoRefresh,
+    autoRefresh: codexAutoRefreshDisabledResult(),
   };
 }
 
@@ -302,6 +255,7 @@ export async function runCodexUserPromptSubmitHook({
   writeMonitorState = null,
   ensureMonitorTask = null,
   buildMonitorUsage = null,
+  autoRefreshStateStore = null,
 } = {}) {
   return runCodexContextRefreshInstructionHook({
     eventName: 'UserPromptSubmit',
@@ -312,6 +266,7 @@ export async function runCodexUserPromptSubmitHook({
     writeMonitorState,
     ensureMonitorTask,
     buildMonitorUsage,
+    autoRefreshStateStore,
   });
 }
 
@@ -323,6 +278,7 @@ export async function runCodexPostToolUseHook({
   writeMonitorState = null,
   ensureMonitorTask = null,
   buildMonitorUsage = null,
+  autoRefreshStateStore = null,
 } = {}) {
   return runCodexContextRefreshInstructionHook({
     eventName: 'PostToolUse',
@@ -333,6 +289,7 @@ export async function runCodexPostToolUseHook({
     writeMonitorState,
     ensureMonitorTask,
     buildMonitorUsage,
+    autoRefreshStateStore,
   });
 }
 
@@ -345,20 +302,20 @@ async function runCodexContextRefreshInstructionHook({
   writeMonitorState = null,
   ensureMonitorTask = null,
   buildMonitorUsage = null,
+  autoRefreshStateStore = null,
 } = {}) {
-  const [{ evaluateCodexAutoRefreshUsage }, capturedState] = await Promise.all([
-    import('../codex-auto-refresh.mjs'),
-    captureCodexHookSession({
-      args,
-      payload,
-      env,
-      db,
-      writeMonitorState,
-      ensureMonitorTask,
-      buildMonitorUsage,
-      summarize: false,
-    }),
-  ]);
+  void eventName;
+  void autoRefreshStateStore;
+  const capturedState = await captureCodexHookSession({
+    args,
+    payload,
+    env,
+    db,
+    writeMonitorState,
+    ensureMonitorTask,
+    buildMonitorUsage,
+    summarize: false,
+  });
 
   if (capturedState.status !== 'ok') {
     return {
@@ -371,41 +328,13 @@ async function runCodexContextRefreshInstructionHook({
     };
   }
 
-  const decision = evaluateCodexAutoRefreshUsage(capturedState.usage);
-  if (!decision.shouldRefresh) {
-    return {
-      status: 'ok',
-      reason: 'codex_rollout_captured',
-      codexThreadIdSource: capturedState.identity.codexThreadIdSource,
-      captured: capturedState.captured,
-      monitorState: capturedState.monitorState,
-      autoRefreshPrompt: {
-        status: 'skipped',
-        reason: decision.reason,
-        decision,
-      },
-    };
-  }
-
-  const context = renderAutoRefreshContext({
-    usage: capturedState.usage,
-    decision,
-    threadId: capturedState.identity.codexThreadId,
-    eventName,
-  });
   return {
     status: 'ok',
     reason: 'codex_rollout_captured',
     codexThreadIdSource: capturedState.identity.codexThreadIdSource,
     captured: capturedState.captured,
     monitorState: capturedState.monitorState,
-    autoRefreshPrompt: {
-      status: 'ready',
-      reason: 'threshold_reached',
-      decision,
-      context,
-      output: codexContextOutput(context, eventName),
-    },
+    autoRefreshPrompt: codexAutoRefreshDisabledResult(),
   };
 }
 
@@ -475,10 +404,8 @@ export async function run(argv = []) {
 
 export const _internal = {
   codexHomeFromTranscriptPath,
-  codexContextOutput,
   parseArgs,
   parsePayload,
-  renderAutoRefreshContext,
   resolveCodexHookThreadIdentity,
 };