throughline 0.3.23 → 0.3.25

package/src/handoff-record.test.mjs

@@ -0,0 +1,226 @@
+import { test } from 'node:test';
+import assert from 'node:assert/strict';
+import { DatabaseSync } from 'node:sqlite';
+import { buildHandoffRecord } from './handoff-record.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;
+}
+
+function insertSession(db, sessionId = 'new') {
+  db.prepare(
+    `INSERT INTO sessions (session_id, project_path, status, created_at, updated_at)
+     VALUES (?, '/repo', 'active', 1, 2)`,
+  ).run(sessionId);
+}
+
+function insertSkeleton(db, row) {
+  db.prepare(
+    `INSERT INTO skeletons (session_id, origin_session_id, turn_number, role, summary, created_at)
+     VALUES (?, ?, ?, ?, ?, ?)`,
+  ).run(row.session, row.origin, row.turn, row.role, row.summary, row.createdAt);
+}
+
+function insertBody(db, row) {
+  db.prepare(
+    `INSERT INTO bodies (session_id, origin_session_id, turn_number, role, text, token_count, created_at)
+     VALUES (?, ?, ?, ?, ?, 1, ?)`,
+  ).run(row.session, row.origin, row.turn, row.role, row.text, row.createdAt);
+}
+
+function insertDetail(db, row) {
+  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 (?, ?, ?, ?, ?, ?, 1, ?, ?, ?)`,
+  ).run(
+    row.session,
+    row.origin,
+    row.turn,
+    row.toolName,
+    row.inputText ?? null,
+    row.outputText ?? null,
+    row.createdAt,
+    row.kind,
+    row.sourceId ?? null,
+  );
+}
+
+test('buildHandoffRecord: returns stable projection with memo, L1, L2, thinking, and L3 refs', () => {
+  const db = makeDb();
+  insertSession(db);
+  insertSkeleton(db, {
+    session: 'new',
+    origin: 'old',
+    turn: 1,
+    role: 'assistant',
+    summary: 'old summary',
+    createdAt: 1000,
+  });
+  insertBody(db, {
+    session: 'new',
+    origin: 'old',
+    turn: 2,
+    role: 'user',
+    text: 'recent user body',
+    createdAt: 2000,
+  });
+  insertBody(db, {
+    session: 'new',
+    origin: 'old',
+    turn: 2,
+    role: 'assistant',
+    text: 'recent assistant body',
+    createdAt: 2100,
+  });
+  insertDetail(db, {
+    session: 'new',
+    origin: 'old',
+    turn: 2,
+    kind: 'thinking',
+    toolName: 'thinking',
+    outputText: 'latest thought',
+    createdAt: 2200,
+    sourceId: 'asst:thinking:0',
+  });
+  insertDetail(db, {
+    session: 'new',
+    origin: 'old',
+    turn: 2,
+    kind: 'tool_input',
+    toolName: 'Bash',
+    inputText: '{"command":"pwd"}',
+    createdAt: 2300,
+    sourceId: 'toolu_1',
+  });
+
+  const record = buildHandoffRecord(db, {
+    sessionId: 'new',
+    isInheritance: true,
+    inflightMemo: 'Next: continue',
+  });
+
+  assert.ok(record);
+  assert.equal(record.kind, 'handoff_record');
+  assert.equal(record.version, 1);
+  assert.equal(record.session.id, 'new');
+  assert.equal(record.session.projectPath, '/repo');
+  assert.equal(record.source.adapter, 'claude');
+  assert.equal(record.source.inheritance, true);
+  assert.deepEqual(record.source.originSessionIds, ['old']);
+  assert.equal(record.intent, 'continue implementation');
+  assert.ok(record.constraints.some((c) => c.includes('preserve existing Claude Code')));
+  assert.equal(record.memory.inflightMemo, 'Next: continue');
+  assert.equal(record.memory.latestThinking[0].text, 'latest thought');
+  assert.equal(record.memory.latestThinking[0].sourceId, 'asst:thinking:0');
+  assert.equal(record.memory.l1Summaries[0].summary, 'old summary');
+  assert.deepEqual(record.memory.recentBodies.map((r) => r.role), ['user', 'assistant']);
+  assert.equal(record.references.l3.length, 2);
+  assert.deepEqual(record.references.l3.map((r) => r.kind), ['thinking', 'tool_input']);
+  assert.match(record.references.l3[0].detailCommand, /^throughline detail \d{2}:\d{2}:\d{2}$/);
+  assert.equal(record.stats.preservedContextRows, 3);
+});
+
+test('buildHandoffRecord: excludes current origin rows', () => {
+  const db = makeDb();
+  insertSession(db);
+  insertBody(db, {
+    session: 'new',
+    origin: 'old',
+    turn: 1,
+    role: 'assistant',
+    text: 'old body',
+    createdAt: 1000,
+  });
+  insertBody(db, {
+    session: 'new',
+    origin: 'new',
+    turn: 1,
+    role: 'assistant',
+    text: 'current body',
+    createdAt: 2000,
+  });
+
+  const record = buildHandoffRecord(db, {
+    sessionId: 'new',
+    excludeOriginId: 'new',
+  });
+
+  assert.ok(record);
+  assert.deepEqual(record.source.originSessionIds, ['old']);
+  assert.deepEqual(record.memory.recentBodies.map((r) => r.text), ['old body']);
+});
+
+test('buildHandoffRecord: keeps L2 bodies from the latest 20 turns, not 40 turns', () => {
+  const db = makeDb();
+  insertSession(db);
+  for (let turn = 1; turn <= 22; turn++) {
+    insertBody(db, {
+      session: 'new',
+      origin: 'new',
+      turn,
+      role: 'assistant',
+      text: `body ${turn}`,
+      createdAt: turn * 1000,
+    });
+  }
+
+  const record = buildHandoffRecord(db, { sessionId: 'new' });
+
+  assert.ok(record);
+  assert.equal(record.memory.recentBodies.length, 20);
+  assert.deepEqual(
+    record.memory.recentBodies.map((r) => r.turnNumber),
+    Array.from({ length: 20 }, (_, index) => index + 3),
+  );
+});
+
+test('buildHandoffRecord: returns null when no projected memory exists', () => {
+  const db = makeDb();
+  insertSession(db);
+  assert.equal(buildHandoffRecord(db, { sessionId: 'empty' }), null);
+});

package/src/hook-entrypoints.test.mjs

@@ -0,0 +1,326 @@
+import { test } from 'node:test';
+import assert from 'node:assert/strict';
+import { spawnSync } from 'node:child_process';
+import {
+  existsSync,
+  mkdtempSync,
+  rmSync,
+  writeFileSync,
+} from 'node:fs';
+import { tmpdir } from 'node:os';
+import { dirname, join } from 'node:path';
+import { DatabaseSync } from 'node:sqlite';
+import { fileURLToPath } from 'node:url';
+
+const REPO_ROOT = dirname(dirname(fileURLToPath(import.meta.url)));
+
+function makeTempHome() {
+  return mkdtempSync(join(tmpdir(), 'tl-hooks-home-'));
+}
+
+function makeTempProject() {
+  return mkdtempSync(join(tmpdir(), 'tl-hooks-project-'));
+}
+
+function childEnv(home) {
+  return {
+    ...process.env,
+    HOME: home,
+    USERPROFILE: home,
+    THROUGHLINE_NO_VSCODE: '1',
+  };
+}
+
+function runNode(args, { home, cwd = REPO_ROOT, input = '' }) {
+  return spawnSync(process.execPath, args, {
+    cwd,
+    env: childEnv(home),
+    input,
+    encoding: 'utf8',
+  });
+}
+
+function openDb(home) {
+  return new DatabaseSync(join(home, '.throughline', 'throughline.db'));
+}
+
+test('hook modules can be imported without executing their hook body', () => {
+  const home = makeTempHome();
+  try {
+    const result = runNode(
+      [
+        '--input-type=module',
+        '-e',
+        [
+          "await import('./src/prompt-submit.mjs');",
+          "await import('./src/session-start.mjs');",
+          "await import('./src/turn-processor.mjs');",
+        ].join('\n'),
+      ],
+      { home },
+    );
+
+    assert.equal(result.status, 0, result.stderr);
+    assert.equal(
+      existsSync(join(home, '.throughline')),
+      false,
+      'importing hook modules should not create the real hook DB or state dir',
+    );
+  } finally {
+    rmSync(home, { recursive: true, force: true });
+  }
+});
+
+test('prompt-submit subprocess writes a /tl baton into an isolated DB', () => {
+  const home = makeTempHome();
+  const project = makeTempProject();
+  try {
+    const result = runNode([join(REPO_ROOT, 'src/prompt-submit.mjs')], {
+      home,
+      cwd: project,
+      input: JSON.stringify({
+        session_id: 'old-session',
+        cwd: project,
+        prompt: '/tl',
+      }),
+    });
+
+    assert.equal(result.status, 0, result.stderr);
+
+    const db = openDb(home);
+    const row = db.prepare('SELECT project_path, session_id FROM handoff_batons').get();
+    assert.equal(row.project_path, project);
+    assert.equal(row.session_id, 'old-session');
+    db.close();
+  } finally {
+    rmSync(project, { recursive: true, force: true });
+    rmSync(home, { recursive: true, force: true });
+  }
+});
+
+test('save-inflight subprocess stores memo on the current project baton', () => {
+  const home = makeTempHome();
+  const project = makeTempProject();
+  try {
+    const baton = runNode([join(REPO_ROOT, 'src/prompt-submit.mjs')], {
+      home,
+      cwd: project,
+      input: JSON.stringify({
+        session_id: 'old-session',
+        cwd: project,
+        prompt: '/tl',
+      }),
+    });
+    assert.equal(baton.status, 0, baton.stderr);
+
+    const memo = 'Next: keep the handoff precise';
+    const saved = runNode([join(REPO_ROOT, 'bin/throughline.mjs'), 'save-inflight'], {
+      home,
+      cwd: project,
+      input: memo,
+    });
+    assert.equal(saved.status, 0, saved.stderr);
+    assert.match(saved.stdout, /in-flight memo saved/);
+
+    const db = openDb(home);
+    const row = db.prepare('SELECT memo_text FROM handoff_batons').get();
+    assert.equal(row.memo_text, memo);
+    db.close();
+  } finally {
+    rmSync(project, { recursive: true, force: true });
+    rmSync(home, { recursive: true, force: true });
+  }
+});
+
+test('session-start subprocess consumes baton and injects inherited resume context', () => {
+  const home = makeTempHome();
+  const project = makeTempProject();
+  try {
+    const baton = runNode([join(REPO_ROOT, 'src/prompt-submit.mjs')], {
+      home,
+      cwd: project,
+      input: JSON.stringify({
+        session_id: 'old-session',
+        cwd: project,
+        prompt: '/tl',
+      }),
+    });
+    assert.equal(baton.status, 0, baton.stderr);
+
+    const db = openDb(home);
+    db.prepare(
+      `INSERT INTO sessions (session_id, project_path, status, created_at, updated_at)
+       VALUES ('old-session', ?, 'active', 1, 1)`,
+    ).run(project);
+    db.prepare(
+      `INSERT INTO bodies
+         (session_id, origin_session_id, turn_number, role, text, token_count, created_at)
+       VALUES ('old-session', 'old-session', 1, 'assistant', 'old assistant body', 4, 2)`,
+    ).run();
+    db.prepare(
+      `UPDATE handoff_batons
+       SET memo_text = 'handoff memo'
+       WHERE project_path = ?`,
+    ).run(project);
+    db.close();
+
+    const started = runNode([join(REPO_ROOT, 'src/session-start.mjs')], {
+      home,
+      cwd: project,
+      input: JSON.stringify({
+        session_id: 'new-session',
+        cwd: project,
+        source: 'startup',
+      }),
+    });
+
+    assert.equal(started.status, 0, started.stderr);
+    assert.match(started.stdout, /handoff memo/);
+    assert.match(started.stdout, /old assistant body/);
+
+    const after = openDb(home);
+    const old = after
+      .prepare("SELECT merged_into FROM sessions WHERE session_id = 'old-session'")
+      .get();
+    const batons = after.prepare('SELECT COUNT(*) AS c FROM handoff_batons').get();
+    assert.equal(old.merged_into, 'new-session');
+    assert.equal(batons.c, 0);
+    after.close();
+  } finally {
+    rmSync(project, { recursive: true, force: true });
+    rmSync(home, { recursive: true, force: true });
+  }
+});
+
+test('session-start subprocess does not inject context when no baton exists', () => {
+  const home = makeTempHome();
+  const project = makeTempProject();
+  try {
+    const started = runNode([join(REPO_ROOT, 'src/session-start.mjs')], {
+      home,
+      cwd: project,
+      input: JSON.stringify({
+        session_id: 'new-session',
+        cwd: project,
+        source: 'startup',
+      }),
+    });
+
+    assert.equal(started.status, 0, started.stderr);
+    assert.equal(started.stdout, '');
+
+    const db = openDb(home);
+    const row = db
+      .prepare("SELECT session_id, project_path FROM sessions WHERE session_id = 'new-session'")
+      .get();
+    assert.equal(row.session_id, 'new-session');
+    assert.equal(row.project_path, project);
+    db.close();
+  } finally {
+    rmSync(project, { recursive: true, force: true });
+    rmSync(home, { recursive: true, force: true });
+  }
+});
+
+test('process-turn subprocess stores L2 bodies and L3 details in an isolated DB', () => {
+  const home = makeTempHome();
+  const project = makeTempProject();
+  const transcriptPath = join(project, 'transcript.jsonl');
+  try {
+    const entries = [
+      {
+        type: 'user',
+        message: {
+          role: 'user',
+          content: [{ type: 'text', text: 'run the check' }],
+        },
+      },
+      {
+        type: 'assistant',
+        uuid: 'asst-tool',
+        message: {
+          role: 'assistant',
+          content: [
+            { type: 'thinking', thinking: 'I should inspect the output first' },
+            {
+              type: 'tool_use',
+              id: 'toolu_check',
+              name: 'Bash',
+              input: { command: 'echo ok' },
+            },
+          ],
+        },
+      },
+      {
+        type: 'user',
+        message: {
+          role: 'user',
+          content: [
+            {
+              type: 'tool_result',
+              tool_use_id: 'toolu_check',
+              content: 'ok\n',
+            },
+          ],
+        },
+      },
+      {
+        type: 'assistant',
+        message: {
+          role: 'assistant',
+          model: 'claude-opus-4-6',
+          usage: {
+            input_tokens: 100,
+            cache_creation_input_tokens: 20,
+            cache_read_input_tokens: 5,
+            output_tokens: 10,
+          },
+          content: [{ type: 'text', text: 'check passed' }],
+        },
+      },
+    ];
+    writeFileSync(transcriptPath, entries.map((e) => JSON.stringify(e)).join('\n'));
+
+    const result = runNode([join(REPO_ROOT, 'src/turn-processor.mjs')], {
+      home,
+      cwd: project,
+      input: JSON.stringify({
+        session_id: 'turn-session',
+        cwd: project,
+        transcript_path: transcriptPath,
+      }),
+    });
+
+    assert.equal(result.status, 0, result.stderr);
+
+    const db = openDb(home);
+    const bodies = db
+      .prepare('SELECT role, text FROM bodies ORDER BY role')
+      .all()
+      .map((row) => ({ role: row.role, text: row.text }));
+    assert.deepEqual(bodies, [
+      { role: 'assistant', text: 'check passed' },
+      { role: 'user', text: 'run the check' },
+    ]);
+
+    const details = db
+      .prepare('SELECT kind, tool_name, source_id, input_text, output_text FROM details ORDER BY id')
+      .all();
+    assert.equal(details.length, 3);
+    assert.deepEqual(details.map((d) => d.kind), [
+      'thinking',
+      'tool_input',
+      'tool_output',
+    ]);
+    assert.equal(details[0].source_id, 'asst-tool:thinking:0');
+    assert.equal(details[0].output_text, 'I should inspect the output first');
+    assert.equal(details[1].tool_name, 'Bash');
+    assert.match(details[1].input_text, /echo ok/);
+    assert.equal(details[2].tool_name, 'Bash');
+    assert.equal(details[2].output_text, 'ok\n');
+    db.close();
+  } finally {
+    rmSync(project, { recursive: true, force: true });
+    rmSync(home, { recursive: true, force: true });
+  }
+});

package/src/package-files.test.mjs

@@ -0,0 +1,19 @@
+import { test } from 'node:test';
+import assert from 'node:assert/strict';
+import { readFileSync } from 'node:fs';
+
+const packageJson = JSON.parse(readFileSync(new URL('../package.json', import.meta.url), 'utf8'));
+
+test('npm package files include Claude and Codex agent surfaces', () => {
+  assert.deepEqual(packageJson.files, [
+    'bin/',
+    'src/',
+    'codex/skills/',
+    '.claude/commands/',
+    '.codex-sidecar.yml',
+    'docs/',
+    'CHANGELOG.md',
+    'README.md',
+    'LICENSE',
+  ]);
+});

package/src/prompt-submit.mjs

@@ -18,6 +18,7 @@ import { ensureMonitorTaskFile } from './vscode-task.mjs';
 import { appendFileSync, mkdirSync } from 'node:fs';
 import { join, dirname } from 'node:path';
 import { homedir } from 'node:os';
+import { pathToFileURL } from 'node:url';
 
 function logBaton(entry) {
   const path = join(homedir(), '.throughline', 'logs', 'baton-write.log');
@@ -42,7 +43,7 @@ export function isBatonCommand(prompt) {
   return false;
 }
 
-async function main() {
+export async function run() {
   let raw = '';
   await new Promise((resolve) => {
     process.stdin.setEncoding('utf8');
@@ -91,8 +92,10 @@ async function main() {
   process.exit(0);
 }
 
-main().catch((err) => {
-  const msg = err instanceof Error ? err.message : 'unknown';
-  process.stderr.write(`[prompt-submit] error: ${msg}\n`);
-  process.exit(1);
-});
+if (process.argv[1] && import.meta.url === pathToFileURL(process.argv[1]).href) {
+  run().catch((err) => {
+    const msg = err instanceof Error ? err.message : 'unknown';
+    process.stderr.write(`[prompt-submit] error: ${msg}\n`);
+    process.exit(1);
+  });
+}