throughline 0.3.24 → 0.3.25

package/src/haiku-summarizer.test.mjs

@@ -0,0 +1,282 @@
+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 { summarizeToL1 } from './haiku-summarizer.mjs';
+
+function makeBin(dir, name, body) {
+  const path = join(dir, name);
+  writeFileSync(path, body);
+  chmodSync(path, 0o755);
+  return path;
+}
+
+test('summarizeToL1: returns empty fallback for blank input', () => {
+  const result = summarizeToL1('', {
+    projectPath: '/repo',
+    env: { ...process.env, THROUGHLINE_CODEX_SIDECAR_DISABLED: '1' },
+  });
+
+  assert.equal(result.summary, '(no content)');
+  assert.equal(result.fromFallback, true);
+  assert.equal(result.source, 'empty');
+});
+
+test('summarizeToL1: recursion guard returns raw L2 without spawning sidecar or haiku', () => {
+  const result = summarizeToL1('raw turn text', {
+    hostMode: 'claude-primary',
+    projectPath: '/repo',
+    env: {
+      ...process.env,
+      THROUGHLINE_IN_HAIKU_SUBPROCESS: '1',
+    },
+  });
+
+  assert.equal(result.summary, 'raw turn text');
+  assert.equal(result.fromFallback, true);
+  assert.equal(result.source, 'recursion_guard');
+});
+
+test('summarizeToL1: uses codex-sidecar when diagnostics and run both succeed', () => {
+  const dir = mkdtempSync(join(tmpdir(), 'tl-l1-sidecar-ok-'));
+  try {
+    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
+`,
+    );
+
+    const result = summarizeToL1('long enough turn text', {
+      hostMode: 'claude-primary',
+      projectPath: '/repo',
+      env: {
+        ...process.env,
+        THROUGHLINE_CODEX_SIDECAR_BIN: sidecar,
+      },
+    });
+
+    assert.equal(result.summary, 'sidecar summary');
+    assert.equal(result.fromFallback, false);
+    assert.equal(result.source, 'codex-sidecar');
+    assert.equal(result.sidecarReason, 'sidecar_ok');
+  } finally {
+    rmSync(dir, { recursive: true, force: true });
+  }
+});
+
+test('summarizeToL1: accepts stable SidecarResult summary without status field', () => {
+  const dir = mkdtempSync(join(tmpdir(), 'tl-l1-sidecar-result-'));
+  try {
+    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
+`,
+    );
+
+    const result = summarizeToL1('long enough turn text', {
+      hostMode: 'claude-primary',
+      projectPath: '/repo',
+      env: {
+        ...process.env,
+        THROUGHLINE_CODEX_SIDECAR_BIN: sidecar,
+      },
+    });
+
+    assert.equal(result.summary, 'stable sidecar summary');
+    assert.equal(result.fromFallback, false);
+    assert.equal(result.source, 'codex-sidecar');
+    assert.equal(result.sidecarReason, 'sidecar_ok');
+  } finally {
+    rmSync(dir, { recursive: true, force: true });
+  }
+});
+
+test('summarizeToL1: when sidecar is disabled, keeps current Haiku-compatible path', () => {
+  const dir = mkdtempSync(join(tmpdir(), 'tl-l1-haiku-'));
+  try {
+    makeBin(
+      dir,
+      'claude',
+      `#!/usr/bin/env bash
+cat >/dev/null
+printf 'haiku summary\\n'
+`,
+    );
+
+    const result = summarizeToL1('long enough turn text', {
+      hostMode: 'claude-primary',
+      projectPath: '/repo',
+      env: {
+        ...process.env,
+        PATH: `${dir}:${process.env.PATH ?? ''}`,
+        THROUGHLINE_CODEX_SIDECAR_DISABLED: '1',
+      },
+    });
+
+    assert.equal(result.summary, 'haiku summary');
+    assert.equal(result.fromFallback, false);
+    assert.equal(result.source, 'haiku');
+    assert.equal(result.sidecarReason, 'sidecar_disabled');
+  } finally {
+    rmSync(dir, { recursive: true, force: true });
+  }
+});
+
+test('summarizeToL1: sidecar run failure keeps current Haiku-compatible path', () => {
+  const dir = mkdtempSync(join(tmpdir(), 'tl-l1-sidecar-fail-'));
+  try {
+    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
+`,
+    );
+    makeBin(
+      dir,
+      'claude',
+      `#!/usr/bin/env bash
+cat >/dev/null
+printf 'haiku after sidecar failure\\n'
+`,
+    );
+
+    const result = summarizeToL1('long enough turn text', {
+      hostMode: 'claude-primary',
+      projectPath: '/repo',
+      env: {
+        ...process.env,
+        PATH: `${dir}:${process.env.PATH ?? ''}`,
+        THROUGHLINE_CODEX_SIDECAR_BIN: sidecar,
+      },
+    });
+
+    assert.equal(result.summary, 'haiku after sidecar failure');
+    assert.equal(result.fromFallback, false);
+    assert.equal(result.source, 'haiku');
+    assert.equal(result.sidecarReason, 'sidecar_run_failed');
+  } finally {
+    rmSync(dir, { recursive: true, force: true });
+  }
+});
+
+test('summarizeToL1: unknown host mode is an explicit error', () => {
+  assert.throws(
+    () =>
+      summarizeToL1('long enough turn text', {
+        projectPath: '/repo',
+        env: { ...process.env, THROUGHLINE_CODEX_SIDECAR_DISABLED: '1' },
+      }),
+    /requires hostMode/,
+  );
+});
+
+test('summarizeToL1: codex-primary uses Codex CLI backend', () => {
+  const dir = mkdtempSync(join(tmpdir(), 'tl-l1-codex-'));
+  try {
+    const argsFile = join(dir, 'args.txt');
+    const stdinFile = join(dir, 'stdin.txt');
+    const codex = makeBin(
+      dir,
+      'codex',
+      `#!/usr/bin/env bash
+printf '%s\\n' "$@" > "${argsFile}"
+cat > "${stdinFile}"
+printf 'codex summary\\n'
+`,
+    );
+
+    const result = summarizeToL1('long enough turn text', {
+      hostMode: 'codex-primary',
+      projectPath: dir,
+      env: {
+        ...process.env,
+        THROUGHLINE_CODEX_CLI_BIN: codex,
+      },
+    });
+
+    assert.equal(result.summary, 'codex summary');
+    assert.equal(result.fromFallback, false);
+    assert.equal(result.source, 'codex-cli');
+    const argsText = readFileSync(argsFile, 'utf8').trim();
+    const argv = argsText.split('\n');
+    assert.deepEqual(argv.slice(0, 8), [
+      'exec',
+      '--ephemeral',
+      '--ignore-user-config',
+      '--ignore-rules',
+      '--skip-git-repo-check',
+      '--sandbox',
+      'read-only',
+      '-C',
+    ]);
+    assert.equal(argv[8], dir);
+    assert.match(argsText, /Output contract/);
+    assert.equal(readFileSync(stdinFile, 'utf8'), 'long enough turn text');
+  } finally {
+    rmSync(dir, { recursive: true, force: true });
+  }
+});
+
+test('summarizeToL1: codex-primary failure is not hidden by fallback', () => {
+  const dir = mkdtempSync(join(tmpdir(), 'tl-l1-codex-fail-'));
+  try {
+    const codex = makeBin(
+      dir,
+      'codex',
+      `#!/usr/bin/env bash
+printf 'codex failed\\n' >&2
+exit 42
+`,
+    );
+    makeBin(
+      dir,
+      'claude',
+      `#!/usr/bin/env bash
+printf 'should not run\\n'
+`,
+    );
+
+    assert.throws(
+      () =>
+        summarizeToL1('long enough turn text', {
+          hostMode: 'codex-primary',
+          projectPath: dir,
+          env: {
+            ...process.env,
+            PATH: `${dir}:${process.env.PATH ?? ''}`,
+            THROUGHLINE_CODEX_CLI_BIN: codex,
+          },
+        }),
+      (err) => {
+        assert.equal(err.source, 'codex-cli');
+        assert.equal(err.reason, 'codex_cli_failed');
+        assert.equal(err.exitCode, 42);
+        assert.match(err.stderr, /codex failed/);
+        return true;
+      },
+    );
+  } finally {
+    rmSync(dir, { recursive: true, force: true });
+  }
+});

package/src/handoff-preview.test.mjs

@@ -0,0 +1,108 @@
+import { test } from 'node:test';
+import assert from 'node:assert/strict';
+import { spawnSync } from 'node:child_process';
+import { mkdtempSync, rmSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { dirname, join } from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+const REPO_ROOT = dirname(dirname(fileURLToPath(import.meta.url)));
+
+function makeTempHome() {
+  return mkdtempSync(join(tmpdir(), 'tl-handoff-preview-home-'));
+}
+
+function makeTempProject() {
+  return mkdtempSync(join(tmpdir(), 'tl-handoff-preview-project-'));
+}
+
+async function seedDb(home, project) {
+  const originalHome = process.env.HOME;
+  const originalUserProfile = process.env.USERPROFILE;
+  process.env.HOME = home;
+  process.env.USERPROFILE = home;
+  try {
+    const mod = await import(`./db.mjs?handoffPreview=${Date.now()}-${Math.random()}`);
+    const db = mod.getDb();
+    db.prepare(
+      `INSERT INTO sessions (session_id, project_path, status, created_at, updated_at)
+       VALUES ('sess-preview', ?, 'active', 1, 2)`,
+    ).run(project);
+    db.prepare(
+      `INSERT INTO bodies
+         (session_id, origin_session_id, turn_number, role, text, token_count, created_at)
+       VALUES ('sess-preview', 'sess-preview', 1, 'assistant', 'preview body', 3, 1000)`,
+    ).run();
+    db.prepare(
+      `INSERT INTO details
+         (session_id, origin_session_id, turn_number, tool_name, input_text, output_text,
+          token_count, created_at, kind, source_id)
+       VALUES ('sess-preview', 'sess-preview', 1, 'Bash', '{"command":"pwd"}',
+               NULL, 3, 1000, 'tool_input', 'toolu_preview')`,
+    ).run();
+    db.close();
+  } finally {
+    if (originalHome === undefined) delete process.env.HOME;
+    else process.env.HOME = originalHome;
+    if (originalUserProfile === undefined) delete process.env.USERPROFILE;
+    else process.env.USERPROFILE = originalUserProfile;
+  }
+}
+
+function runPreview(home, project, args = []) {
+  return spawnSync(
+    process.execPath,
+    [join(REPO_ROOT, 'bin/throughline.mjs'), 'handoff-preview', ...args],
+    {
+      cwd: project,
+      env: {
+        ...process.env,
+        HOME: home,
+        USERPROFILE: home,
+      },
+      encoding: 'utf8',
+    },
+  );
+}
+
+test('handoff-preview prints throughline_handoff JSON for explicit session', async () => {
+  const home = makeTempHome();
+  const project = makeTempProject();
+  try {
+    await seedDb(home, project);
+    const result = runPreview(home, project, [
+      '--session',
+      'sess-preview',
+      '--host-mode',
+      'unknown',
+    ]);
+
+    assert.equal(result.status, 0, result.stderr);
+    const block = JSON.parse(result.stdout);
+    assert.equal(block.kind, 'throughline_handoff');
+    assert.equal(block.data.sessionId, 'sess-preview');
+    assert.equal(block.data.projectPath, project);
+    assert.equal(block.data.hostMode, 'unknown');
+    assert.equal(block.data.memory.recentBodies[0].text, 'preview body');
+    assert.equal(block.data.detailReferences[0].sourceId, 'toolu_preview');
+  } finally {
+    rmSync(project, { recursive: true, force: true });
+    rmSync(home, { recursive: true, force: true });
+  }
+});
+
+test('handoff-preview uses latest session for cwd when --session is omitted', async () => {
+  const home = makeTempHome();
+  const project = makeTempProject();
+  try {
+    await seedDb(home, project);
+    const result = runPreview(home, project);
+
+    assert.equal(result.status, 0, result.stderr);
+    const block = JSON.parse(result.stdout);
+    assert.equal(block.data.sessionId, 'sess-preview');
+  } finally {
+    rmSync(project, { recursive: true, force: true });
+    rmSync(home, { recursive: true, force: true });
+  }
+});

package/src/handoff-record.mjs

@@ -0,0 +1,294 @@
+/**
+ * Agent-neutral handoff projection.
+ *
+ * This module reads the same persisted memory that Claude resume-context uses,
+ * but returns a stable object instead of Claude-facing Markdown. It is not
+ * persisted to DB; adapters can render it for Claude, Codex, or diagnostics.
+ */
+
+export const HANDOFF_RECORD_VERSION = 1;
+export const N_RECENT_L2 = 20;
+export const CODEX_SESSION_PREFIX = 'codex:';
+
+const DEFAULT_INTENT = 'continue implementation';
+const DEFAULT_CONSTRAINTS = [
+  'preserve existing Claude Code hook, slash command, transcript, baton, and resume behavior',
+  'add Codex support as adapter/projection; do not rename Claude-facing DB fields or commands',
+  'do not treat unverified rollback/inject host behavior as a confirmed implementation contract',
+];
+
+/**
+ * Unix ms を HH:MM:SS 形式に変換する。
+ */
+export function formatTime(unixMs) {
+  const d = new Date(unixMs);
+  const hh = String(d.getHours()).padStart(2, '0');
+  const mm = String(d.getMinutes()).padStart(2, '0');
+  const ss = String(d.getSeconds()).padStart(2, '0');
+  return `${hh}:${mm}:${ss}`;
+}
+
+function loadSession(db, sessionId) {
+  try {
+    return db
+      .prepare(
+        `SELECT session_id, project_path, status, created_at, updated_at, merged_into
+         FROM sessions
+         WHERE session_id = ?`,
+      )
+      .get(sessionId) ?? null;
+  } catch {
+    return null;
+  }
+}
+
+function buildBodySet(rows) {
+  return new Set(rows.map((r) => `${r.origin_session_id}\x00${r.turn_number}`));
+}
+
+function distinctOriginSessionIds(...rowGroups) {
+  const ids = new Set();
+  for (const rows of rowGroups) {
+    for (const r of rows) {
+      if (r.origin_session_id) ids.add(r.origin_session_id);
+    }
+  }
+  return [...ids].sort();
+}
+
+function inferSourceAdapter(sessionId, originSessionIds) {
+  const ids = [sessionId, ...originSessionIds].filter(Boolean);
+  if (ids.length > 0 && ids.every((id) => String(id).startsWith(CODEX_SESSION_PREFIX))) {
+    return 'codex';
+  }
+  return 'claude';
+}
+
+function loadBodies(db, { sessionId, excludeOriginId, recentTurnLimit }) {
+  const hasExclude = Boolean(excludeOriginId);
+  const bodiesQuery = hasExclude
+    ? `SELECT origin_session_id, turn_number, role, text, created_at
+       FROM bodies
+       WHERE session_id = ? AND origin_session_id != ?
+       ORDER BY created_at DESC`
+    : `SELECT origin_session_id, turn_number, role, text, created_at
+       FROM bodies
+       WHERE session_id = ?
+       ORDER BY created_at DESC`;
+
+  let desc = [];
+  try {
+    desc = hasExclude
+      ? db.prepare(bodiesQuery).all(sessionId, excludeOriginId)
+      : db.prepare(bodiesQuery).all(sessionId);
+  } catch {
+    desc = [];
+  }
+
+  const selectedTurns = new Set();
+  const selectedRows = [];
+  for (const row of desc) {
+    const key = `${row.origin_session_id}\x00${row.turn_number}`;
+    if (!selectedTurns.has(key)) {
+      if (selectedTurns.size >= recentTurnLimit) continue;
+      selectedTurns.add(key);
+    }
+    selectedRows.push(row);
+  }
+
+  return selectedRows.reverse();
+}
+
+function loadL1Summaries(db, { sessionId, excludeOriginId, bodyRows }) {
+  const hasExclude = Boolean(excludeOriginId);
+  const skelQuery = hasExclude
+    ? `SELECT origin_session_id, turn_number, role, summary, created_at
+       FROM skeletons
+       WHERE session_id = ? AND origin_session_id != ?
+       ORDER BY created_at ASC`
+    : `SELECT origin_session_id, turn_number, role, summary, created_at
+       FROM skeletons
+       WHERE session_id = ?
+       ORDER BY created_at ASC`;
+
+  let all = [];
+  try {
+    all = hasExclude
+      ? db.prepare(skelQuery).all(sessionId, excludeOriginId)
+      : db.prepare(skelQuery).all(sessionId);
+  } catch {
+    all = [];
+  }
+  const bodySet = buildBodySet(bodyRows);
+  return all.filter((s) => !bodySet.has(`${s.origin_session_id}\x00${s.turn_number}`));
+}
+
+function loadLatestThinking(db, { sessionId, excludeOriginId }) {
+  const hasExclude = Boolean(excludeOriginId);
+  const latestQuery = hasExclude
+    ? `SELECT origin_session_id, turn_number, created_at
+       FROM bodies
+       WHERE session_id = ? AND origin_session_id != ? AND role = 'assistant'
+       ORDER BY created_at DESC
+       LIMIT 1`
+    : `SELECT origin_session_id, turn_number, created_at
+       FROM bodies
+       WHERE session_id = ? AND role = 'assistant'
+       ORDER BY created_at DESC
+       LIMIT 1`;
+
+  let latest;
+  try {
+    latest = hasExclude
+      ? db.prepare(latestQuery).get(sessionId, excludeOriginId)
+      : db.prepare(latestQuery).get(sessionId);
+  } catch {
+    return [];
+  }
+  if (!latest) return [];
+
+  try {
+    return db
+      .prepare(
+        `SELECT origin_session_id, turn_number, output_text, created_at, source_id
+         FROM details
+         WHERE session_id = ? AND origin_session_id = ? AND turn_number = ? AND kind = 'thinking'
+         ORDER BY created_at ASC`,
+      )
+      .all(sessionId, latest.origin_session_id, latest.turn_number)
+      .filter((r) => typeof r.output_text === 'string' && r.output_text.length > 0);
+  } catch {
+    return [];
+  }
+}
+
+function loadL3References(db, { sessionId, bodyRows }) {
+  const turnKeys = [...buildBodySet(bodyRows)];
+  if (turnKeys.length === 0) return [];
+
+  const tuples = turnKeys.map((k) => k.split('\x00'));
+  const placeholders = tuples.map(() => '(?, ?, ?)').join(', ');
+  const params = tuples.flatMap(([origin, turn]) => [sessionId, origin, Number(turn)]);
+
+  try {
+    return db
+      .prepare(
+        `SELECT kind, tool_name, source_id, origin_session_id, turn_number, created_at
+         FROM details
+         WHERE (session_id, origin_session_id, turn_number) IN (VALUES ${placeholders})
+         ORDER BY created_at ASC, id ASC`,
+      )
+      .all(...params)
+      .map((r) => ({
+        kind: r.kind,
+        toolName: r.tool_name,
+        sourceId: r.source_id ?? null,
+        originSessionId: r.origin_session_id,
+        turnNumber: r.turn_number,
+        createdAt: r.created_at,
+        detailCommand: `throughline detail ${formatTime(r.created_at)}`,
+      }));
+  } catch {
+    return [];
+  }
+}
+
+/**
+ * @param {import('node:sqlite').DatabaseSync} db
+ * @param {{
+ *   sessionId: string,
+ *   isInheritance?: boolean,
+ *   excludeOriginId?: string | null,
+ *   inflightMemo?: string | null,
+ *   intent?: string,
+ *   constraints?: string[],
+ *   recentTurnLimit?: number,
+ * }} params
+ */
+export function buildHandoffRecord(
+  db,
+  {
+    sessionId,
+    isInheritance = false,
+    excludeOriginId = null,
+    inflightMemo = null,
+    intent = DEFAULT_INTENT,
+    constraints = DEFAULT_CONSTRAINTS,
+    recentTurnLimit = N_RECENT_L2,
+  },
+) {
+  if (!sessionId) return null;
+
+  const session = loadSession(db, sessionId);
+  const bodyRows = loadBodies(db, { sessionId, excludeOriginId, recentTurnLimit });
+  const l1Rows = loadL1Summaries(db, { sessionId, excludeOriginId, bodyRows });
+  const thinkingRows = loadLatestThinking(db, { sessionId, excludeOriginId });
+
+  if (
+    bodyRows.length === 0 &&
+    l1Rows.length === 0 &&
+    thinkingRows.length === 0 &&
+    !inflightMemo
+  ) {
+    return null;
+  }
+
+  const l3References = loadL3References(db, { sessionId, bodyRows });
+  const originSessionIds = distinctOriginSessionIds(bodyRows, l1Rows, thinkingRows);
+
+  return {
+    kind: 'handoff_record',
+    version: HANDOFF_RECORD_VERSION,
+    session: {
+      id: sessionId,
+      projectPath: session?.project_path ?? null,
+      status: session?.status ?? null,
+      mergedInto: session?.merged_into ?? null,
+    },
+    source: {
+      adapter: inferSourceAdapter(sessionId, originSessionIds),
+      inheritance: Boolean(isInheritance),
+      excludeOriginId: excludeOriginId ?? null,
+      originSessionIds,
+    },
+    intent,
+    constraints: [...constraints],
+    memory: {
+      inflightMemo: inflightMemo && inflightMemo.trim().length > 0 ? inflightMemo.trim() : null,
+      latestThinking: thinkingRows.map((r) => ({
+        originSessionId: r.origin_session_id,
+        turnNumber: r.turn_number,
+        text: r.output_text,
+        createdAt: r.created_at,
+        time: formatTime(r.created_at),
+        sourceId: r.source_id ?? null,
+      })),
+      l1Summaries: l1Rows.map((r) => ({
+        originSessionId: r.origin_session_id,
+        turnNumber: r.turn_number,
+        role: r.role,
+        summary: r.summary,
+        createdAt: r.created_at,
+        time: formatTime(r.created_at),
+      })),
+      recentBodies: bodyRows.map((r) => ({
+        originSessionId: r.origin_session_id,
+        turnNumber: r.turn_number,
+        role: r.role,
+        text: r.text,
+        createdAt: r.created_at,
+        time: formatTime(r.created_at),
+      })),
+    },
+    references: {
+      l3: l3References,
+    },
+    stats: {
+      l1Rows: l1Rows.length,
+      l2Rows: bodyRows.length,
+      thinkingRows: thinkingRows.length,
+      l3References: l3References.length,
+      preservedContextRows: bodyRows.length + l1Rows.length,
+    },
+  };
+}