throughline 0.4.10 → 0.4.12

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/resume-context.mjs

@@ -5,8 +5,11 @@
  *   - session-start.mjs (auto path / baton path どちらでも同じ注入)
  *
  * 設計 (docs/THROUGHLINE_CLEAR_AUTO_HANDOFF_PLAN.md):
- *   - 注入順: ヘッダ + 読み方 → L1 要約 → L2 本文（一番下）
- *   - 直前の発話に Claude の attention が向くよう、L2 を末尾に置く
+ *   - 注入順: ヘッダ + 読み方 → 現在地アンカー → L1 要約 → L2 本文（一番下）
+ *   - 「現在地」アンカーは直前の user / assistant turn をヘッダ直下に再掲して
+ *     最初の注意を最新ターンに固定する。L2 末尾アンカーは補強として残す。
+ *     （L2 が長くなると末尾アンカーだけでは前半の古いターンに注意が固着し、
+ *      話の流れを取り違える事例があった）
  *   - L3 は別セクションを設けず、対応する L1 / L2 行にインラインで
  *     `[→ throughline detail HH:MM:SS (kind …)]` ヒントを付ける
  *   - L2 全文があれば最後の assistant turn 自体に「次に何をしようとしていたか」が
@@ -25,12 +28,43 @@ const RESUME_HEADER_TEMPLATE = (turnCount) =>
   `## Throughline: 中断した作業の再開（${turnCount} ターン分の文脈を保持）\n` +
   `\n` +
   `**読み方:**\n` +
+  `- **下の「現在地」が直前のやりとりです。まずここで最新の状態と次の一手を把握してから L1/L2 を読んでください。**\n` +
   `- 直前の対話の自然な続きとして応答してください。\n` +
   '- **各ターンの詳細の取得方法**: **`Bash` ツールで `throughline detail HH:MM:SS` を実行** ' +
   `(該当ターンの本文＋詳細を stdout に返します)`;
 
 const NORMAL_HEADER = '## Throughline: セッション記憶';
 
+// 現在地アンカーは最新 user / assistant 本文を再掲する。長すぎると注入全体が膨らむので
+// この文字数で打ち切り、全文は L2 セクション側を参照させる。
+const ANCHOR_MAX_CHARS = 600;
+
+function truncateForAnchor(text) {
+  const normalized = text.replace(/\n+/g, ' ').trim();
+  if (normalized.length <= ANCHOR_MAX_CHARS) return normalized;
+  return normalized.slice(0, ANCHOR_MAX_CHARS) + ' …';
+}
+
+/**
+ * recentBodies (古い順) から「直前のやりとり」アンカー用に
+ * 最新の user / assistant 行をそれぞれ 1 件ずつ拾う。
+ */
+function pickLatestExchange(recentBodies) {
+  let latestUser = null;
+  let latestAssistant = null;
+  for (let i = recentBodies.length - 1; i >= 0; i -= 1) {
+    const r = recentBodies[i];
+    if (!r.text) continue;
+    if (r.role === 'assistant' && !latestAssistant) {
+      latestAssistant = r;
+    } else if (r.role === 'user' && !latestUser) {
+      latestUser = r;
+    }
+    if (latestUser && latestAssistant) break;
+  }
+  return { latestUser, latestAssistant };
+}
+
 /**
  * L1 + L2 注入テキストを組み立てる。L3 は本文ではなく
  * 各 L1 / L2 行末尾の inline hint として付与する。
@@ -61,6 +95,28 @@ export function buildResumeContext(
 
   const l3ByTurn = groupL3ByTurn(record.references.l3);
 
+  // 現在地アンカー: 引き継ぎ時のみ、最新 user / assistant turn をヘッダ直下に再掲する。
+  // L2 末尾アンカーだけだと、長い L2 で注意が前半に固着して話の流れを取り違える事例があった。
+  if (isInheritance && record.memory.recentBodies.length > 0) {
+    const { latestUser, latestAssistant } = pickLatestExchange(record.memory.recentBodies);
+    const anchorLines = [];
+    if (latestUser) {
+      anchorLines.push(
+        `**最新ユーザー指示** [${latestUser.time}]: ${truncateForAnchor(latestUser.text)}`,
+      );
+    }
+    if (latestAssistant) {
+      anchorLines.push(
+        `**直前のアシスタント** [${latestAssistant.time}]: ${truncateForAnchor(latestAssistant.text)}`,
+      );
+    }
+    if (anchorLines.length > 0) {
+      lines.push('');
+      lines.push('### 現在地 (直前のやりとり)');
+      lines.push(...anchorLines);
+    }
+  }
+
   if (record.memory.l1Summaries.length > 0) {
     const l1Lines = [];
     for (const r of record.memory.l1Summaries) {