throughline 0.4.9 → 0.4.11

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

@@ -2,6 +2,7 @@ import assert from 'node:assert/strict';
 import { test } from 'node:test';
 
 import {
+  buildCodexAutoRefreshFingerprint,
   CODEX_AUTO_REFRESH_THRESHOLD,
   evaluateCodexAutoRefreshUsage,
   runCodexAutoRefresh,
@@ -48,12 +49,38 @@ test('evaluateCodexAutoRefreshUsage: estimate does not trigger mutation', () =>
   assert.equal(estimatedWindow.reason, 'estimated_context_window_not_allowed');
 });
 
+test('runCodexAutoRefresh: disabled by default and does not inspect trim source', async () => {
+  let buildTrimSourceCalled = false;
+  const result = await runCodexAutoRefresh({
+    db: {},
+    threadId: '019dfaba-thread',
+    projectPath: '/repo',
+    usage: {
+      tokens: 240_000,
+      contextWindowSize: 258_400,
+      estimated: false,
+      contextWindowEstimated: false,
+    },
+    deps: {
+      buildTrimSource: () => {
+        buildTrimSourceCalled = true;
+        return null;
+      },
+    },
+  });
+
+  assert.equal(result.status, 'skipped');
+  assert.equal(result.reason, 'codex_auto_refresh_disabled');
+  assert.equal(buildTrimSourceCalled, false);
+});
+
 test('runCodexAutoRefresh: below threshold skips before building trim source', async () => {
   let buildTrimSourceCalled = false;
   const result = await runCodexAutoRefresh({
     db: {},
     threadId: '019dfaba-thread',
     projectPath: '/repo',
+    enabled: true,
     usage: {
       tokens: 100_000,
       contextWindowSize: 258_400,
@@ -82,6 +109,7 @@ test('runCodexAutoRefresh: threshold reached rolls back and injects Throughline
     codexThreadIdSource: 'payload:session_id',
     projectPath: '/repo',
     sessionId: 'codex:019dfaba-thread',
+    enabled: true,
     usage: {
       tokens: 240_000,
       contextWindowSize: 258_400,
@@ -137,12 +165,159 @@ test('runCodexAutoRefresh: threshold reached rolls back and injects Throughline
   assert.match(runTrimExecutionArgs.memoryText, /Throughline: Active Work Context/);
 });
 
+test('runCodexAutoRefresh: suppresses repeated execution for the same rollout and usage epoch', async () => {
+  let executionCalls = 0;
+  const stateStore = makeMemoryAutoRefreshStateStore();
+  const baseArgs = {
+    db: {},
+    threadId: '019dfaba-thread',
+    codexThreadIdSource: 'payload:session_id',
+    projectPath: '/repo',
+    sessionId: 'codex:019dfaba-thread',
+    enabled: true,
+    usage: {
+      tokens: 240_000,
+      contextWindowSize: 258_400,
+      estimated: false,
+      contextWindowEstimated: false,
+    },
+    autoRefreshStateStore: stateStore,
+    deps: {
+      buildTrimSource: () => ({
+        source: 'codex-rollout',
+        capturedTurns: 4,
+        memoryPreview: { text: 'rollout preview' },
+        stats: {
+          rollbackEvents: 0,
+          injectedDeveloperMessages: 0,
+          userMessagesAfterRollback: 0,
+        },
+      }),
+      buildTrimPlan: () => ({
+        status: 'ready',
+        trim: {
+          source: 'codex-rollout',
+          capturedTurns: 4,
+          rollbackTurns: 4,
+          rolloutPath: '/repo/rollout.jsonl',
+          rolloutStats: {
+            rollbackEvents: 0,
+            injectedDeveloperMessages: 0,
+            userMessagesAfterRollback: 0,
+          },
+        },
+        memoryPreview: {
+          text: '## Throughline: Active Work Context\n\nrecent work',
+          stats: { source: 'throughline-db' },
+        },
+      }),
+      runTrimExecution: async () => {
+        executionCalls++;
+        return {
+          rollbackSent: true,
+          injectSent: true,
+          postInjectVisibilityCheck: { status: 'match' },
+        };
+      },
+    },
+  };
+
+  const first = await runCodexAutoRefresh(baseArgs);
+  const second = await runCodexAutoRefresh(baseArgs);
+
+  assert.equal(first.status, 'refreshed-live');
+  assert.equal(second.status, 'skipped');
+  assert.equal(second.reason, 'auto_refresh_backoff');
+  assert.equal(executionCalls, 1);
+});
+
+test('runCodexAutoRefresh: durable success keeps the thread quiet after injection until a new user turn', async () => {
+  let executionCalls = 0;
+  const stateStore = makeMemoryAutoRefreshStateStore();
+  const makeArgs = ({ tokens, rollbackEvents, injectedDeveloperMessages, userMessagesAfterRollback }) => ({
+    db: {},
+    threadId: '019dfaba-thread',
+    projectPath: '/repo',
+    sessionId: 'codex:019dfaba-thread',
+    enabled: true,
+    usage: {
+      tokens,
+      contextWindowSize: 258_400,
+      estimated: false,
+      contextWindowEstimated: false,
+    },
+    autoRefreshStateStore: stateStore,
+    deps: {
+      buildTrimSource: () => ({
+        source: 'codex-rollout',
+        capturedTurns: 1,
+        memoryPreview: { text: 'rollout preview' },
+        stats: { rollbackEvents, injectedDeveloperMessages, userMessagesAfterRollback },
+      }),
+      buildTrimPlan: () => ({
+        status: 'ready',
+        trim: {
+          source: 'codex-rollout',
+          capturedTurns: 1,
+          rollbackTurns: 1,
+          rolloutPath: '/repo/rollout.jsonl',
+          rolloutStats: { rollbackEvents, injectedDeveloperMessages, userMessagesAfterRollback },
+        },
+        memoryPreview: {
+          text: '## Throughline: Active Work Context\n\nrecent work',
+          stats: { source: 'throughline-db' },
+        },
+      }),
+      runTrimExecution: async () => {
+        executionCalls++;
+        return {
+          rollbackSent: true,
+          injectSent: true,
+          postInjectVisibilityCheck: { status: 'match' },
+        };
+      },
+    },
+  });
+
+  const first = await runCodexAutoRefresh(
+    makeArgs({
+      tokens: 240_000,
+      rollbackEvents: 0,
+      injectedDeveloperMessages: 0,
+      userMessagesAfterRollback: 0,
+    }),
+  );
+  const afterInjection = await runCodexAutoRefresh(
+    makeArgs({
+      tokens: 252_000,
+      rollbackEvents: 1,
+      injectedDeveloperMessages: 1,
+      userMessagesAfterRollback: 0,
+    }),
+  );
+  const afterNewUserTurn = await runCodexAutoRefresh(
+    makeArgs({
+      tokens: 252_000,
+      rollbackEvents: 1,
+      injectedDeveloperMessages: 1,
+      userMessagesAfterRollback: 1,
+    }),
+  );
+
+  assert.equal(first.status, 'refreshed-live');
+  assert.equal(afterInjection.status, 'skipped');
+  assert.equal(afterInjection.reason, 'auto_refresh_backoff');
+  assert.equal(afterNewUserTurn.status, 'refreshed-live');
+  assert.equal(executionCalls, 2);
+});
+
 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',
+    enabled: true,
     usage: {
       tokens: 240_000,
       contextWindowSize: 258_400,
@@ -180,3 +355,185 @@ test('runCodexAutoRefresh: threshold reached skips when injectable DB memory is
   assert.equal(result.reason, 'injectable_memory_required');
   assert.equal(runTrimExecutionCalled, false);
 });
+
+test('runCodexAutoRefresh: noop and missing injectable memory are backed off for the same state', async () => {
+  const cases = [
+    {
+      name: 'nothing_to_trim',
+      plan: {
+        status: 'ready',
+        trim: {
+          source: 'codex-rollout',
+          capturedTurns: 2,
+          rollbackTurns: 0,
+          rolloutPath: '/repo/rollout.jsonl',
+          rolloutStats: { rollbackEvents: 0, injectedDeveloperMessages: 0, userMessagesAfterRollback: 0 },
+        },
+        memoryPreview: {
+          text: '## Throughline: Active Work Context\n\nrecent work',
+          stats: { source: 'throughline-db' },
+        },
+      },
+    },
+    {
+      name: 'injectable_memory_required',
+      plan: {
+        status: 'ready',
+        trim: {
+          source: 'codex-rollout',
+          capturedTurns: 2,
+          rollbackTurns: 2,
+          rolloutPath: '/repo/rollout.jsonl',
+          rolloutStats: { rollbackEvents: 0, injectedDeveloperMessages: 0, userMessagesAfterRollback: 0 },
+        },
+        memoryPreview: {
+          text: 'rollout preview only',
+          stats: { source: 'codex-rollout' },
+        },
+      },
+    },
+  ];
+
+  for (const fixture of cases) {
+    const stateStore = makeMemoryAutoRefreshStateStore();
+    const args = {
+      db: {},
+      threadId: `019dfaba-thread-${fixture.name}`,
+      projectPath: '/repo',
+      enabled: true,
+      usage: {
+        tokens: 240_000,
+        contextWindowSize: 258_400,
+        estimated: false,
+        contextWindowEstimated: false,
+      },
+      autoRefreshStateStore: stateStore,
+      deps: {
+        buildTrimSource: () => ({
+          source: 'codex-rollout',
+          capturedTurns: 2,
+          memoryPreview: { text: 'rollout preview' },
+          stats: { rollbackEvents: 0, injectedDeveloperMessages: 0, userMessagesAfterRollback: 0 },
+        }),
+        buildTrimPlan: () => fixture.plan,
+        runTrimExecution: async () => {
+          throw new Error('runTrimExecution should not be called');
+        },
+      },
+    };
+
+    const first = await runCodexAutoRefresh(args);
+    const second = await runCodexAutoRefresh(args);
+
+    assert.equal(first.status, 'skipped', fixture.name);
+    assert.equal(first.reason, fixture.name);
+    assert.equal(second.status, 'skipped', fixture.name);
+    assert.equal(second.reason, 'auto_refresh_backoff');
+  }
+});
+
+test('runCodexAutoRefresh: backoff still allows a new usage epoch or thread', async () => {
+  const stateStore = makeMemoryAutoRefreshStateStore();
+  const makeArgs = ({ threadId, tokens }) => ({
+    db: {},
+    threadId,
+    projectPath: '/repo',
+    enabled: true,
+    usage: {
+      tokens,
+      contextWindowSize: 258_400,
+      estimated: false,
+      contextWindowEstimated: false,
+    },
+    autoRefreshStateStore: stateStore,
+    deps: {
+      buildTrimSource: () => ({
+        source: 'codex-rollout',
+        capturedTurns: 2,
+        memoryPreview: { text: 'rollout preview' },
+        stats: { rollbackEvents: 0, injectedDeveloperMessages: 0, userMessagesAfterRollback: 0 },
+      }),
+      buildTrimPlan: () => ({
+        status: 'ready',
+        trim: {
+          source: 'codex-rollout',
+          capturedTurns: 2,
+          rollbackTurns: 2,
+          rolloutPath: '/repo/rollout.jsonl',
+          rolloutStats: { rollbackEvents: 0, injectedDeveloperMessages: 0, userMessagesAfterRollback: 0 },
+        },
+        memoryPreview: {
+          text: 'rollout preview only',
+          stats: { source: 'codex-rollout' },
+        },
+      }),
+      runTrimExecution: async () => {
+        throw new Error('runTrimExecution should not be called');
+      },
+    },
+  });
+
+  const first = await runCodexAutoRefresh(makeArgs({ threadId: 'thread-a', tokens: 240_000 }));
+  const repeated = await runCodexAutoRefresh(makeArgs({ threadId: 'thread-a', tokens: 240_000 }));
+  const usageAdvanced = await runCodexAutoRefresh(makeArgs({ threadId: 'thread-a', tokens: 252_000 }));
+  const newThread = await runCodexAutoRefresh(makeArgs({ threadId: 'thread-b', tokens: 240_000 }));
+
+  assert.equal(first.reason, 'injectable_memory_required');
+  assert.equal(repeated.reason, 'auto_refresh_backoff');
+  assert.equal(usageAdvanced.reason, 'injectable_memory_required');
+  assert.equal(newThread.reason, 'injectable_memory_required');
+});
+
+test('buildCodexAutoRefreshFingerprint: ignores live tool-loop row churn within a usage epoch', () => {
+  const base = {
+    threadId: 'thread-a',
+    projectPath: '/repo',
+    usage: {
+      tokens: 196_000,
+      contextWindowSize: 258_400,
+      estimated: false,
+      contextWindowEstimated: false,
+      source: 'codex-rollout-token-count-live-turn',
+    },
+    rolloutState: {
+      rolloutPath: '/repo/rollout.jsonl',
+      capturedTurns: 1,
+      rollbackTurns: null,
+      capturedRows: 2,
+      capturedDetails: 60,
+      rollbackEvents: 1,
+      rolledBackTurns: 2,
+      injectedDeveloperMessages: 1,
+      userMessagesAfterRollback: 0,
+    },
+  };
+
+  assert.equal(
+    buildCodexAutoRefreshFingerprint(base),
+    buildCodexAutoRefreshFingerprint({
+      ...base,
+      usage: {
+        ...base.usage,
+        tokens: 199_000,
+      },
+      rolloutState: {
+        ...base.rolloutState,
+        capturedRows: 3,
+        capturedDetails: 65,
+      },
+    }),
+  );
+});
+
+function makeMemoryAutoRefreshStateStore() {
+  const states = new Map();
+  return {
+    read(threadId) {
+      const state = states.get(threadId);
+      return state ? structuredClone(state) : null;
+    },
+    write(threadId, state) {
+      states.set(threadId, structuredClone(state));
+    },
+  };
+}

package/src/codex-thread-index.mjs

@@ -1,4 +1,4 @@
-import { closeSync, existsSync, openSync, readFileSync, readSync, readdirSync, statSync } from 'node:fs';
+import { closeSync, existsSync, openSync, readFileSync, readSync, readdirSync, realpathSync, statSync } from 'node:fs';
 import { homedir } from 'node:os';
 import { join, resolve, sep } from 'node:path';
 
@@ -169,5 +169,11 @@ function compareCandidates(a, b) {
 }
 
 function normalizePath(value) {
-  return resolve(value).split(sep).join('/').replace(/\/+$/, '').toLowerCase();
+  let resolved = resolve(value);
+  try {
+    if (existsSync(resolved)) resolved = realpathSync.native(resolved);
+  } catch {
+    // Keep the lexical path when it cannot be resolved.
+  }
+  return resolved.split(sep).join('/').replace(/\/+$/, '').toLowerCase();
 }

package/src/project-path.mjs

@@ -0,0 +1,20 @@
+import { existsSync, realpathSync } from 'node:fs';
+import { platform } from 'node:os';
+import { resolve, sep } from 'node:path';
+
+export function normalizeProjectPathForCompare(value) {
+  if (!value) return '';
+  let resolved = resolve(String(value));
+  try {
+    if (existsSync(resolved)) resolved = realpathSync.native(resolved);
+  } catch {
+    // Fall back to the lexical path when the filesystem cannot resolve it.
+  }
+  let normalized = resolved.split(sep).join('/').replace(/\/+$/, '');
+  if (platform() === 'win32') normalized = normalized.toLowerCase();
+  return normalized;
+}
+
+export function sameProjectPath(a, b) {
+  return normalizeProjectPathForCompare(a) === normalizeProjectPathForCompare(b);
+}

package/src/test-env.mjs

@@ -0,0 +1,4 @@
+// Keep tests hermetic when they are run from inside a live Codex session.
+// Individual tests that need these values set them explicitly in child env.
+delete process.env.THROUGHLINE_CODEX_THREAD_ID;
+delete process.env.CODEX_THREAD_ID;

package/src/trim-cli.test.mjs

@@ -137,6 +137,7 @@ rl.on('line', (line) => {
       send({ id: msg.id, error: { code: -32000, message: 'mutation must not be called' } });
       return;
     }
+    appendFileSync(log, 'ROLLBACK_TURNS:' + msg.params.numTurns + '\\n');
     turns = turns.slice(0, Math.max(0, turns.length - msg.params.numTurns));
     appendRollout({ type: 'event_msg', payload: { type: 'thread_rolled_back', num_turns: msg.params.numTurns } });
     send({ id: msg.id, result: { thread: { id: threadId, turns } } });
@@ -843,7 +844,7 @@ test('trim CLI preflight proceeds when compacted history already retains target
   }
 });
 
-test('trim CLI execute refuses before rollback when rollout and app-server turn counts differ', async () => {
+test('trim CLI execute adjusts rollback turns from app-server count when counts differ', async () => {
   const home = makeTempHome();
   const codexHome = makeTempHome();
   const project = makeTempProject();
@@ -853,12 +854,12 @@ test('trim CLI execute refuses before rollback when rollout and app-server turn
     writeCodexRollout(codexHome, {
       project,
       threadId,
-      turnCount: 22,
+      turnCount: 6,
     });
     const { script, log } = makeFakeCodexAppServer(project, {
       allowMutation: true,
       threadId,
-      turnCount: 21,
+      turnCount: 7,
     });
     const result = runTrim(
       home,
@@ -868,8 +869,7 @@ test('trim CLI execute refuses before rollback when rollout and app-server turn
         'codex',
         '--codex-thread-id',
         threadId,
-        '--keep-recent',
-        '20',
+        '--all',
         '--execute',
         '--codex-app-server-bin',
         script,
@@ -881,17 +881,25 @@ test('trim CLI execute refuses before rollback when rollout and app-server turn
 
     assert.equal(result.status, 1);
     const payload = JSON.parse(result.stdout);
-    assert.equal(payload.status, 'execute-refused');
-    assert.equal(payload.reason, 'codex_rollout_app_server_turn_mismatch');
-    assert.equal(payload.execution.rollbackSent, false);
-    assert.equal(payload.execution.injectSent, false);
+    assert.notEqual(payload.status, 'execute-refused');
+    assert.equal(payload.execution.rollbackSent, true);
+    assert.equal(payload.execution.injectSent, true);
+    assert.equal(payload.execution.rollbackRequestedTurns, 7);
     assert.equal(payload.execution.turnCountCheck.status, 'mismatch');
+    assert.deepEqual(payload.execution.rollbackResolution, {
+      plannedRollbackTurns: 6,
+      requestedRollbackTurns: 7,
+      adjustment: 1,
+      basis: 'app_server_turn_count',
+      reason: 'adjusted_by_app_server_turn_delta',
+    });
 
     const calledMethods = readFileSync(log, 'utf8');
     assert.match(calledMethods, /thread\/read/);
     assert.match(calledMethods, /thread\/resume/);
-    assert.doesNotMatch(calledMethods, /thread\/rollback/);
-    assert.doesNotMatch(calledMethods, /thread\/inject_items/);
+    assert.match(calledMethods, /thread\/rollback/);
+    assert.match(calledMethods, /ROLLBACK_TURNS:7/);
+    assert.match(calledMethods, /thread\/inject_items/);
   } finally {
     rmSync(project, { recursive: true, force: true });
     rmSync(home, { recursive: true, force: true });

package/src/trim-model.mjs

@@ -1,5 +1,6 @@
 import { inspectCodexPlannedRollbackRestoreSafety } from './codex-rollout-memory.mjs';
 import { buildHandoffRecord, N_RECENT_L2 } from './handoff-record.mjs';
+import { sameProjectPath } from './project-path.mjs';
 import { estimateTokens } from './token-estimator.mjs';
 
 export const DEFAULT_TRIM_KEEP_RECENT = N_RECENT_L2;
@@ -31,15 +32,14 @@ function loadSession(db, sessionId) {
 export function findLatestSessionIdForProject(db, projectPath) {
   if (!projectPath) return null;
   try {
-    const row = db
+    const rows = db
       .prepare(
-        `SELECT session_id
+        `SELECT session_id, project_path
          FROM sessions
-         WHERE lower(project_path) = lower(?)
-         ORDER BY updated_at DESC
-         LIMIT 1`,
+         ORDER BY updated_at DESC`,
       )
-      .get(projectPath);
+      .all();
+    const row = rows.find((candidate) => sameProjectPath(candidate.project_path, projectPath));
     return row?.session_id ?? null;
   } catch {
     return null;