throughline 0.3.23 → 0.3.25

package/src/codex-auto-refresh.test.mjs

@@ -0,0 +1,182 @@
+import assert from 'node:assert/strict';
+import { test } from 'node:test';
+
+import {
+  CODEX_AUTO_REFRESH_THRESHOLD,
+  evaluateCodexAutoRefreshUsage,
+  runCodexAutoRefresh,
+} from './codex-auto-refresh.mjs';
+
+test('evaluateCodexAutoRefreshUsage: default threshold is 90%', () => {
+  assert.equal(CODEX_AUTO_REFRESH_THRESHOLD, 0.9);
+  const below = evaluateCodexAutoRefreshUsage({
+    tokens: 232_559,
+    contextWindowSize: 258_400,
+    estimated: false,
+    contextWindowEstimated: false,
+  });
+  assert.equal(below.shouldRefresh, false);
+  assert.equal(below.reason, 'below_threshold');
+
+  const atThreshold = evaluateCodexAutoRefreshUsage({
+    tokens: 232_560,
+    contextWindowSize: 258_400,
+    estimated: false,
+    contextWindowEstimated: false,
+  });
+  assert.equal(atThreshold.shouldRefresh, true);
+  assert.equal(atThreshold.reason, 'threshold_reached');
+});
+
+test('evaluateCodexAutoRefreshUsage: estimate does not trigger mutation', () => {
+  const estimatedUsage = evaluateCodexAutoRefreshUsage({
+    tokens: 250_000,
+    contextWindowSize: 258_400,
+    estimated: true,
+    contextWindowEstimated: false,
+  });
+  assert.equal(estimatedUsage.shouldRefresh, false);
+  assert.equal(estimatedUsage.reason, 'estimated_usage_not_allowed');
+
+  const estimatedWindow = evaluateCodexAutoRefreshUsage({
+    tokens: 250_000,
+    contextWindowSize: 258_400,
+    estimated: false,
+    contextWindowEstimated: true,
+  });
+  assert.equal(estimatedWindow.shouldRefresh, false);
+  assert.equal(estimatedWindow.reason, 'estimated_context_window_not_allowed');
+});
+
+test('runCodexAutoRefresh: below threshold skips before building trim source', async () => {
+  let buildTrimSourceCalled = false;
+  const result = await runCodexAutoRefresh({
+    db: {},
+    threadId: '019dfaba-thread',
+    projectPath: '/repo',
+    usage: {
+      tokens: 100_000,
+      contextWindowSize: 258_400,
+      estimated: false,
+      contextWindowEstimated: false,
+    },
+    deps: {
+      buildTrimSource: () => {
+        buildTrimSourceCalled = true;
+        return null;
+      },
+    },
+  });
+
+  assert.equal(result.status, 'skipped');
+  assert.equal(result.reason, 'below_threshold');
+  assert.equal(buildTrimSourceCalled, false);
+});
+
+test('runCodexAutoRefresh: threshold reached rolls back and injects Throughline memory', async () => {
+  let buildTrimSourceCalled = false;
+  let runTrimExecutionArgs = null;
+  const result = await runCodexAutoRefresh({
+    db: {},
+    threadId: '019dfaba-thread',
+    codexThreadIdSource: 'payload:session_id',
+    projectPath: '/repo',
+    sessionId: 'codex:019dfaba-thread',
+    usage: {
+      tokens: 240_000,
+      contextWindowSize: 258_400,
+      estimated: false,
+      contextWindowEstimated: false,
+    },
+    deps: {
+      buildTrimSource: (args) => {
+        buildTrimSourceCalled = true;
+        assert.equal(args.threadId, '019dfaba-thread');
+        assert.equal(args.sourceReason, 'payload_codex_thread_rollout');
+        return {
+          source: 'codex-rollout',
+          capturedTurns: 2,
+          memoryPreview: { text: 'rollout preview' },
+        };
+      },
+      buildTrimPlan: (db, args) => {
+        assert.equal(args.sessionId, 'codex:019dfaba-thread');
+        assert.equal(args.trimAll, true);
+        assert.equal(args.host, 'codex');
+        return {
+          status: 'ready',
+          trim: {
+            source: 'codex-rollout',
+            capturedTurns: 2,
+            rollbackTurns: 2,
+          },
+          memoryPreview: {
+            text: '## Throughline: Active Work Context\n\nrecent work',
+            stats: { source: 'throughline-db' },
+          },
+        };
+      },
+      runTrimExecution: async (args) => {
+        runTrimExecutionArgs = args;
+        return {
+          rollbackSent: true,
+          injectSent: true,
+          postInjectVisibilityCheck: { status: 'match' },
+        };
+      },
+    },
+  });
+
+  assert.equal(result.status, 'refreshed-live');
+  assert.equal(result.reason, 'rollback_and_inject_sent_live');
+  assert.equal(buildTrimSourceCalled, true);
+  assert.equal(runTrimExecutionArgs.threadId, '019dfaba-thread');
+  assert.equal(runTrimExecutionArgs.cwd, '/repo');
+  assert.equal(runTrimExecutionArgs.rollbackTurns, 2);
+  assert.equal(runTrimExecutionArgs.expectedTurns, 2);
+  assert.match(runTrimExecutionArgs.memoryText, /Throughline: Active Work Context/);
+});
+
+test('runCodexAutoRefresh: threshold reached skips when injectable DB memory is missing', async () => {
+  let runTrimExecutionCalled = false;
+  const result = await runCodexAutoRefresh({
+    db: {},
+    threadId: '019dfaba-thread',
+    projectPath: '/repo',
+    usage: {
+      tokens: 240_000,
+      contextWindowSize: 258_400,
+      estimated: false,
+      contextWindowEstimated: false,
+    },
+    deps: {
+      buildTrimSource: () => ({
+        source: 'codex-rollout',
+        capturedTurns: 2,
+        memoryPreview: { text: 'rollout preview' },
+      }),
+      buildTrimPlan: () => {
+        return {
+          status: 'ready',
+          trim: {
+            source: 'codex-rollout',
+            capturedTurns: 2,
+            rollbackTurns: 2,
+          },
+          memoryPreview: {
+            text: 'rollout preview only',
+            stats: { source: 'codex-rollout' },
+          },
+        };
+      },
+      runTrimExecution: async () => {
+        runTrimExecutionCalled = true;
+        return {};
+      },
+    },
+  });
+
+  assert.equal(result.status, 'skipped');
+  assert.equal(result.reason, 'injectable_memory_required');
+  assert.equal(runTrimExecutionCalled, false);
+});

package/src/codex-capture.mjs

@@ -0,0 +1,235 @@
+import { parseCodexRolloutFile } from './codex-rollout-memory.mjs';
+import { defaultCodexHome, findCodexThreadCandidate } from './codex-thread-index.mjs';
+
+export const CODEX_SESSION_PREFIX = 'codex:';
+
+export function buildCodexThroughlineSessionId(threadId) {
+  if (typeof threadId !== 'string' || threadId.trim().length === 0) {
+    throw new Error('threadId is required');
+  }
+  return `${CODEX_SESSION_PREFIX}${threadId.trim()}`;
+}
+
+export function isCodexThroughlineSessionId(sessionId) {
+  return typeof sessionId === 'string' && sessionId.startsWith(CODEX_SESSION_PREFIX);
+}
+
+export function codexSessionIdToThreadId(sessionId) {
+  if (!isCodexThroughlineSessionId(sessionId)) return null;
+  return sessionId.slice(CODEX_SESSION_PREFIX.length) || null;
+}
+
+export function captureCodexRolloutToDb(
+  db,
+  {
+    threadId,
+    codexHome = defaultCodexHome(),
+    projectPath = process.cwd(),
+    now = Date.now(),
+  } = {},
+) {
+  if (!db) throw new Error('db is required');
+  if (typeof threadId !== 'string' || threadId.trim().length === 0) {
+    throw new Error('threadId is required');
+  }
+
+  const candidate = findCodexThreadCandidate({
+    threadId: threadId.trim(),
+    codexHome,
+    projectPath,
+    requireProjectMatch: true,
+  });
+  if (!candidate) {
+    return {
+      status: 'unavailable',
+      reason: 'codex_rollout_not_found_for_project',
+      threadId: threadId.trim(),
+      sessionId: buildCodexThroughlineSessionId(threadId),
+      projectPath,
+      capturedTurns: 0,
+      capturedRows: 0,
+    };
+  }
+
+  const parsed = parseCodexRolloutFile(candidate.rolloutPath);
+  const sessionId = buildCodexThroughlineSessionId(candidate.id);
+  const rows = buildBodyRowsFromActiveTurns(parsed.activeTurns, {
+    sessionId,
+    now,
+  });
+  const detailRows = buildDetailRowsFromActiveTurns(parsed.activeTurns, {
+    sessionId,
+    now,
+  });
+
+  db.exec('BEGIN IMMEDIATE');
+  try {
+    db.prepare(
+      `INSERT INTO sessions (session_id, project_path, status, created_at, updated_at)
+       VALUES (?, ?, 'active', ?, ?)
+       ON CONFLICT(session_id) DO UPDATE SET
+         project_path = excluded.project_path,
+         status = 'active',
+         updated_at = excluded.updated_at`,
+    ).run(sessionId, candidate.cwd ?? projectPath, now, now);
+
+    // Codex rollout is the source of truth for this namespaced session. Rebuild
+    // it so rolled-back tail turns from a previous capture cannot survive.
+    db.prepare('DELETE FROM skeletons WHERE session_id = ?').run(sessionId);
+    db.prepare('DELETE FROM bodies WHERE session_id = ?').run(sessionId);
+    db.prepare('DELETE FROM details WHERE session_id = ?').run(sessionId);
+
+    const insertBody = db.prepare(
+      `INSERT INTO bodies
+         (session_id, origin_session_id, turn_number, role, text, token_count, created_at)
+       VALUES (?, ?, ?, ?, ?, ?, ?)`,
+    );
+    const insertDetail = db.prepare(
+      `INSERT OR IGNORE INTO details
+         (session_id, origin_session_id, turn_number, tool_name, input_text, output_text,
+          token_count, created_at, kind, source_id)
+       VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`,
+    );
+
+    for (const row of rows) {
+      insertBody.run(
+        row.sessionId,
+        row.originSessionId,
+        row.turnNumber,
+        row.role,
+        row.text,
+        row.tokenCount,
+        row.createdAt,
+      );
+    }
+    for (const row of detailRows) {
+      insertDetail.run(
+        row.sessionId,
+        row.originSessionId,
+        row.turnNumber,
+        row.toolName,
+        row.inputText,
+        row.outputText,
+        row.tokenCount,
+        row.createdAt,
+        row.kind,
+        row.sourceId,
+      );
+    }
+
+    db.exec('COMMIT');
+  } catch (err) {
+    db.exec('ROLLBACK');
+    throw err;
+  }
+
+  return {
+    status: 'captured',
+    source: 'codex-rollout',
+    sourceAgent: 'codex',
+    threadId: candidate.id,
+    sessionId,
+    projectPath: candidate.cwd ?? projectPath,
+    rolloutPath: candidate.rolloutPath,
+    capturedTurns: parsed.activeTurnCount,
+    capturedRows: rows.length,
+    capturedDetails: detailRows.length,
+    stats: parsed.stats,
+  };
+}
+
+export function buildBodyRowsFromActiveTurns(activeTurns, { sessionId, now = Date.now() } = {}) {
+  if (!isCodexThroughlineSessionId(sessionId)) {
+    throw new Error('Codex capture requires a codex:<thread_id> session id');
+  }
+
+  const rows = [];
+  let turnNumber = 0;
+  for (const turn of activeTurns ?? []) {
+    const grouped = groupMessagesByRole(turn.messages ?? []);
+    const details = turn.details ?? [];
+    if (grouped.length === 0 && details.length === 0) continue;
+
+    turnNumber++;
+    const createdAt = pickTurnCreatedAt(turn.messages ?? [], now);
+    for (const [role, text] of grouped) {
+      rows.push({
+        sessionId,
+        originSessionId: sessionId,
+        turnNumber,
+        role,
+        text,
+        tokenCount: Math.round(text.length / 4),
+        createdAt,
+      });
+    }
+  }
+  return rows;
+}
+
+export function buildDetailRowsFromActiveTurns(activeTurns, { sessionId, now = Date.now() } = {}) {
+  if (!isCodexThroughlineSessionId(sessionId)) {
+    throw new Error('Codex capture requires a codex:<thread_id> session id');
+  }
+
+  const rows = [];
+  let turnNumber = 0;
+  for (const turn of activeTurns ?? []) {
+    const grouped = groupMessagesByRole(turn.messages ?? []);
+    const details = turn.details ?? [];
+    if (grouped.length === 0 && details.length === 0) continue;
+
+    turnNumber++;
+    for (const detail of details) {
+      if (!detail?.kind || !detail?.tool_name) continue;
+      const inputText = detail.input_text ?? null;
+      const outputText = detail.output_text ?? null;
+      rows.push({
+        sessionId,
+        originSessionId: sessionId,
+        turnNumber,
+        toolName: String(detail.tool_name),
+        inputText,
+        outputText,
+        tokenCount: Math.round(((inputText?.length ?? 0) + (outputText?.length ?? 0)) / 4),
+        createdAt: pickDetailCreatedAt(detail, now),
+        kind: String(detail.kind),
+        sourceId: detail.source_id ?? null,
+      });
+    }
+  }
+  return rows;
+}
+
+function groupMessagesByRole(messages) {
+  const grouped = new Map();
+  for (const message of messages) {
+    if (!message?.role || !message?.text) continue;
+    const role = String(message.role);
+    const existing = grouped.get(role);
+    grouped.set(role, existing ? `${existing}\n\n${message.text}` : message.text);
+  }
+
+  const preferred = ['user', 'assistant', 'developer'];
+  return [...grouped.entries()].sort(([a], [b]) => {
+    const ai = preferred.indexOf(a);
+    const bi = preferred.indexOf(b);
+    if (ai !== -1 || bi !== -1) {
+      return (ai === -1 ? preferred.length : ai) - (bi === -1 ? preferred.length : bi);
+    }
+    return a.localeCompare(b);
+  });
+}
+
+function pickTurnCreatedAt(messages, fallback) {
+  const times = messages
+    .map((message) => Date.parse(message.time ?? ''))
+    .filter((time) => Number.isFinite(time));
+  if (times.length === 0) return fallback;
+  return Math.min(...times);
+}
+
+function pickDetailCreatedAt(detail, fallback) {
+  const time = Date.parse(detail?.time ?? '');
+  return Number.isFinite(time) ? time : fallback;
+}