throughline 0.4.10 → 0.4.11

package/docs/throughline-rollback-context-trim-insight.md

@@ -9,7 +9,7 @@
 | 文書 | 役割 |
 |---|---|
 | [THROUGHLINE_CODEX_FIRST_ROADMAP.md](THROUGHLINE_CODEX_FIRST_ROADMAP.md) | 2026-05-06 以降の次フェーズ計画。Codex primary と Codex Rewind 互換を先行する |
-| [THROUGHLINE_CODEX_TRIM_ROLLBACK_FIX_PLAN.md](THROUGHLINE_CODEX_TRIM_ROLLBACK_FIX_PLAN.md) | 2026-05-06 incident 後の修正計画。2026-05-08 の controlled smoke 後、automatic mutation は再有効化し、restore-safety / host primitive audit は diagnostics として残す |
+| [THROUGHLINE_CODEX_TRIM_ROLLBACK_FIX_PLAN.md](THROUGHLINE_CODEX_TRIM_ROLLBACK_FIX_PLAN.md) | 2026-05-06 incident 後の修正計画。2026-05-10 の live token_count 実験後、Codex automatic current-thread mutation は無効化し、通常 `$throughline` は新スレッド handoff に戻す |
 | [THROUGHLINE_CODEX_TRIM_IMPLEMENTATION_PLAN.md](THROUGHLINE_CODEX_TRIM_IMPLEMENTATION_PLAN.md) | この気づきと Claude / Codex 両対応計画を統合した旧計画と実装履歴。完了済み根拠として参照する |
 | [THROUGHLINE_CODEX_DUAL_SUPPORT.md](THROUGHLINE_CODEX_DUAL_SUPPORT.md) | Throughline を Claude primary のまま Codex adapter / sidecar に対応させる architecture brief |
 
@@ -23,7 +23,9 @@
 
 2026-05-09 update: rollout/app-server turn-count 不一致も mutation 前 blocker から外した。app-server `thread/read` / `thread/resume` が同じ count を返す場合、planned rollback turns に `readTurns - expectedTurns` を足して `thread/rollback.numTurns` を送る。`expectedTurns = 6` / `readTurns = resumedTurns = 7` / `--all` なら `numTurns = 7`。
 
-2026-05-09 skill UX: bare `$throughline` は diagnostics / dry-run / preflight を AI に順番実行させる surface ではなく、`throughline trim --execute --host codex --all --json` を直接走らせる scripted current-thread refresh とする。目的は rollback と、Throughline DB の L2 最新 20 full bodies + older L1 summaries + L3 references-only memory injection のみ。doctor / dry-run / preflight / fresh-thread handoff / restore-safety / host primitive audit は明示診断用であり、通常 `$throughline` の前段にはしない。
+2026-05-09 skill UX: bare `$throughline` は diagnostics / dry-run / preflight を AI に順番実行させる surface ではなく、`throughline trim --execute --host codex --all` を直接走らせる scripted current-thread refresh としていた。目的は rollback と、Throughline DB の L2 最新 20 full bodies + older L1 summaries + L3 references-only memory injection のみだった。2026-05-10 以降は `--json` の full plan / memory preview が tool output として context を再膨張させるため、通常 path では付けないようにした。
+
+2026-05-10 rollback UX correction: 追加 live 実験で、current-thread rollback / inject 後に token_count が一時的に下がっても同一 thread で戻る挙動を確認した。これを受け、Codex automatic current-thread refresh は無効化し、`UserPromptSubmit` / `PostToolUse` / `Stop` hooks は capture / monitor state write のみ行う。bare `$throughline` は `throughline codex-handoff-start --execute` による app-server 新スレッド handoff とし、明示 `trim --execute --host codex` は診断用 current-thread path として残す。
 
 2026-05-07 host primitive audit: `throughline codex-host-primitive-audit` で installed Codex app-server schema を機械監査した。`thread/rollback` / `thread/inject_items` / `thread/compact/start` / `thread/start` / `thread/fork` / `thread/resume` は存在するが、rollback 済み user text を current-thread の model-visible input へ復活させない deletion / isolation / projection primitive は見つからなかった。`thread/resume(history)` は schema 上 `[UNSTABLE] FOR CODEX CLOUD - DO NOT USE` で、`thread_id` も ignored になるため、Throughline の current-thread repair primitive には採用しない。
 
@@ -265,11 +267,13 @@ Codex で考えられる流れ:
 9. ユーザーは同じ Codex thread で続行する。
 ```
 
-現行実装では、Codex Stop hook 後の 75% automatic refresh は guarded rollback / inject
-mutation を試行する。明示 CLI の `throughline trim --execute --host codex --codex-thread-id <id>`
-も env gate なしで実行する。明示 Codex thread identity と injectable Throughline DB memory
-は live mutation の最低条件であり、rollout/app-server turn-count mismatch は診断と app-server count 由来の rollback `numTurns` 補正に使う。durable success は
-post-execute rollout evidence で `execute-durable-verified` として別判定する。
+現行実装では、Codex hooks からの 75% automatic refresh は無効化している。明示 CLI の
+`throughline trim --execute --host codex --codex-thread-id <id>` は診断用 current-thread
+path として env gate なしで実行できる。明示 Codex thread identity と injectable
+Throughline DB memory は live mutation の最低条件であり、rollout/app-server
+turn-count mismatch は診断と app-server count 由来の rollback `numTurns` 補正に使う。
+durable success は post-execute rollout evidence で `execute-durable-verified` として
+別判定する。
 
 重要な考え:
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "throughline",
-  "version": "0.4.10",
+  "version": "0.4.11",
   "type": "module",
   "description": "Claude Code hooks plugin for structured context compression (/clear-safe persistent memory)",
   "keywords": [
@@ -30,7 +30,7 @@
     "LICENSE"
   ],
   "scripts": {
-    "test": "node --test src/*.test.mjs src/cli/*.test.mjs"
+    "test": "node --import ./src/test-env.mjs --test src/*.test.mjs src/cli/*.test.mjs"
   },
   "engines": {
     "node": ">=22.5"

package/src/cli/codex-handoff-model-smoke.mjs

@@ -10,6 +10,7 @@ import {
   DEFAULT_CODEX_HANDOFF_MODEL_SMOKE_TIMEOUT_MS,
   runCodexHandoffModelSmoke,
 } from '../codex-handoff-model-smoke.mjs';
+import { sameProjectPath } from '../project-path.mjs';
 
 async function readStdin() {
   let raw = '';
@@ -104,16 +105,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;
 }
 

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

@@ -1,6 +1,7 @@
 import { getDb } from '../db.mjs';
 import { buildHandoffRecord } from '../handoff-record.mjs';
 import { buildCodexHandoffSmoke } from '../codex-handoff-smoke.mjs';
+import { sameProjectPath } from '../project-path.mjs';
 
 async function readStdin() {
   let raw = '';
@@ -75,16 +76,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;
 }
 

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 });
+  }
+});