throughline 0.4.11 → 0.4.12

package/CHANGELOG.md

@@ -10,6 +10,23 @@ shipped to npm but were not individually tagged on GitHub.
 
 ## [Unreleased]
 
+## [0.4.12] — 2026-05-17
+
+### Changed
+
+- Added a 「現在地 (直前のやりとり)」 anchor at the top of the Claude
+  `/clear` resume context injection. The anchor re-surfaces the latest user
+  directive and the latest assistant turn body (each truncated to 600
+  characters) directly under the header, before the L1 / L2 sections.
+  Observed failure mode: with a long L2 window the model's attention could
+  fixate on the *first* L2 entry (oldest in the window) and mistake an older
+  plan discussion for the current state of the conversation. The anchor pins
+  the latest exchange at the position the model reads first, with the existing
+  L2-tail anchor preserved as reinforcement. The header reading instructions
+  now point to the new anchor as the first bullet.
+
+## [0.4.11] — 2026-05-10
+
 ### Changed
 
 - Disabled Codex automatic current-thread refresh from `UserPromptSubmit`,
@@ -23,6 +40,17 @@ shipped to npm but were not individually tagged on GitHub.
   and opens the selected host. Explicit `throughline trim --execute --host codex`
   remains available as a diagnostic current-thread rollback / inject command.
 
+### Fixed
+
+- Codex hooks registered by `throughline install` now resolve the Node
+  executable through `PATH` (matching `process.execPath` by `realpath`) instead
+  of always hard-coding `process.execPath`. On Homebrew-installed Node on macOS,
+  `process.execPath` points at a Cellar-versioned binary that disappears on the
+  next `brew upgrade`, leaving stale absolute paths in `~/.codex/hooks.json`.
+  The new resolver prefers a stable `PATH` entry (e.g. `/opt/homebrew/bin/node`)
+  and falls back to `process.execPath` only when no PATH entry resolves to the
+  same binary.
+
 ## [0.4.10] — 2026-05-09
 
 ### Fixed

package/README.md

@@ -216,14 +216,21 @@ this fallback. **The env var only affects the fallback**; typed `/clear` and
 
 Both paths inject the **same** curated memory:
 
+- A **"現在地 (latest exchange)"** anchor (added in v0.4.12) re-surfaces the
+  most recent user directive and the most recent assistant turn directly under
+  the header, each truncated to 600 characters
 - L1 summaries (older turns, one-line)
 - L2 verbatim (most recent 20 turns, full text)
-- L3 references (`throughline detail <time>` retrieval commands; bodies stay in SQLite)
+- L3 references (`throughline detail <time>` retrieval commands, attached
+  inline to each L1/L2 row; bodies stay in SQLite)
 
 The injection is reframed as **"resuming an interrupted task"** rather than
 "reading past logs". The L2 verbatim already contains the last assistant
 turn — what Claude was about to do next — so no separate memo or extended
-thinking section is injected.
+thinking section is injected. The current-state anchor exists because, on
+long L2 windows, attention can fixate on the *first* L2 entry (the oldest
+turn in the window) and misread an old plan discussion as the current task;
+pinning the latest exchange at the top of the injection prevents that drift.
 
 Each merged row keeps its `origin_session_id`, so repeated handoffs
 accumulate memory through chains:

package/docs/THROUGHLINE_CLEAR_AUTO_HANDOFF_PLAN.md

@@ -95,13 +95,14 @@ on SessionStart(source, session_id, project_path):
 
 `consumeBaton` が先発なので「両方同時成立」は構造上発生しない (= baton ありなら baton 経路、無ければ source 判定)。typed `/clear` も UserPromptSubmit hook で baton を書くため、通常はほぼ常に baton path が走る。auto path は VSCode 拡張のメニュー由来 `/clear` のように UserPromptSubmit に届かない経路のためのフォールバック。
 
-### 2.2 注入内容: L1 + L2 + L3 refs のみ (baton/auto どちらの経路でも同一)
+### 2.2 注入内容: 現在地アンカー + L1 + L2 + L3 refs (baton/auto どちらの経路でも同一)
 
-含める:
+含める (順序):
 - ヘッダ + Reading Contract framing (= Codex 側 `renderCodexRolloutMemoryPreview` の写像)
+- **現在地アンカー** (v0.4.12+): 最新 user turn と最新 assistant turn の本文をヘッダ直下に再掲 (各 600 字で truncate)
 - **L1 summaries** (古い turn の一行要約)
 - **L2 bodies** (直近 20 turn の verbatim)
-- **L3 references** (= `throughline detail <時刻>` の取り出しコマンド一覧、Codex 風の `- ${kind}: ${detailCommand}` フォーマット)
+- **L3 references** (= `throughline detail <時刻>` の取り出しコマンド一覧、各 L1/L2 行末尾の inline suffix として集約)
 - Continuation Instruction (= 「これは過去ログではなく現在進行中の作業」と明示)
 
 含めない (= 削除):
@@ -109,7 +110,9 @@ on SessionStart(source, session_id, project_path):
 - 中断直前の thinking (extended thinking セクション)
 - 既存の Claude 向け footer の冗長な使い方説明
 
-理由: L2 全文があれば最後の assistant turn 自体に「次に何をしようとしていたか」が含まれている。memo / thinking は redundant。
+理由:
+- L2 末尾アンカーだけだと、L2 が長いセッションで注意が前半 (= L2 内の最古ターン) に固着し、古い計画ターンを「現在の作業」と誤認するケースがあった (実観測あり)。最新ターンをヘッダ直下にも再掲して、最初に目に入る位置で文脈を固定する。
+- L2 全文があれば最後の assistant turn 自体に「次に何をしようとしていたか」が含まれている。memo / thinking は redundant。
 
 ### 2.3 `/tl` の役割: **残すが簡素化**
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "throughline",
-  "version": "0.4.11",
+  "version": "0.4.12",
   "type": "module",
   "description": "Claude Code hooks plugin for structured context compression (/clear-safe persistent memory)",
   "keywords": [

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) {

package/src/resume-context.test.mjs

@@ -101,7 +101,8 @@ test('buildResumeContext: header is terse and announces the Bash invocation cont
   assert.ok(!text.includes('内訳の読み方'), 'glossary block must be gone');
   assert.ok(!text.includes('現在進行中の作業の active work context'), 'verbose framing must be gone');
 
-  // 残るのは 2 行: 自然な続き + Bash 呼び出し方法
+  // 残るのは 3 行: 現在地参照案内 + 自然な続き + Bash 呼び出し方法
+  assert.match(text, /下の「現在地」が直前のやりとりです/);
   assert.match(text, /直前の対話の自然な続きとして応答してください/);
   assert.match(
     text,
@@ -109,6 +110,132 @@ test('buildResumeContext: header is terse and announces the Bash invocation cont
   );
 });
 
+test('buildResumeContext: 現在地 anchor surfaces the latest user/assistant exchange above L1/L2', () => {
+  const db = makeDb();
+  // 25 turns to exercise an L2 window edge and ensure the anchor picks the newest.
+  for (let t = 1; t <= 25; t += 1) {
+    insertBody(db, {
+      session: 'new',
+      origin: 'old',
+      turn: t,
+      role: 'user',
+      text: `user turn ${t}`,
+      createdAt: 1000 + t * 10,
+    });
+    insertBody(db, {
+      session: 'new',
+      origin: 'old',
+      turn: t,
+      role: 'assistant',
+      text: `assistant turn ${t}`,
+      createdAt: 1000 + t * 10 + 1,
+    });
+  }
+
+  const text = buildResumeContext(db, {
+    sessionId: 'new',
+    isInheritance: true,
+  });
+
+  assert.ok(text);
+
+  const anchorIdx = text.indexOf('### 現在地 (直前のやりとり)');
+  const l2Idx = text.indexOf('### 直前の対話 (L2 / active work thread, 古い順)');
+  assert.ok(anchorIdx > 0, '現在地 anchor section should be present');
+  assert.ok(l2Idx > anchorIdx, '現在地 anchor must appear before the L2 section');
+
+  // The anchor must point to turn 25 (the latest), not any earlier turn.
+  assert.match(text, /\*\*最新ユーザー指示\*\* \[\d\d:\d\d:\d\d\]: user turn 25$/m);
+  assert.match(text, /\*\*直前のアシスタント\*\* \[\d\d:\d\d:\d\d\]: assistant turn 25$/m);
+});
+
+test('buildResumeContext: 現在地 anchor truncates long bodies but full body still appears in L2', () => {
+  const db = makeDb();
+  const longText = 'a'.repeat(1200);
+  insertBody(db, {
+    session: 'new',
+    origin: 'old',
+    turn: 1,
+    role: 'assistant',
+    text: longText,
+    createdAt: 1000,
+  });
+
+  const text = buildResumeContext(db, {
+    sessionId: 'new',
+    isInheritance: true,
+  });
+
+  assert.ok(text);
+
+  const anchorLine = text
+    .split('\n')
+    .find((l) => l.startsWith('**直前のアシスタント**'));
+  assert.ok(anchorLine, '直前のアシスタント anchor line should be present');
+  // Anchor must be truncated with ellipsis (originally 1200 chars > 600 cap).
+  assert.ok(anchorLine.endsWith(' …'), 'long anchor body must end with the ellipsis marker');
+  assert.ok(
+    anchorLine.length < longText.length,
+    'anchor line should be shorter than the original body',
+  );
+
+  // Full body must still appear in the L2 section below.
+  assert.match(text, new RegExp(`\\[assistant\\]: ${longText}`));
+});
+
+test('buildResumeContext: 現在地 anchor is omitted for non-inheritance sessions', () => {
+  const db = makeDb();
+  insertBody(db, {
+    session: 'new',
+    origin: 'old',
+    turn: 1,
+    role: 'assistant',
+    text: 'a body',
+    createdAt: 1000,
+  });
+
+  const text = buildResumeContext(db, {
+    sessionId: 'new',
+    isInheritance: false,
+  });
+
+  assert.ok(text);
+  assert.ok(
+    !text.includes('現在地'),
+    'normal sessions (isInheritance=false) must not include the 現在地 anchor',
+  );
+  assert.ok(
+    !text.includes('最新ユーザー指示'),
+    'normal sessions must not surface a latest-user pointer',
+  );
+});
+
+test('buildResumeContext: 現在地 anchor handles a single-role recent window', () => {
+  const db = makeDb();
+  // Only user rows (no assistant) — anchor should still render with just the user line.
+  insertBody(db, {
+    session: 'new',
+    origin: 'old',
+    turn: 1,
+    role: 'user',
+    text: 'lone user message',
+    createdAt: 1000,
+  });
+
+  const text = buildResumeContext(db, {
+    sessionId: 'new',
+    isInheritance: true,
+  });
+
+  assert.ok(text);
+  assert.ok(text.includes('### 現在地 (直前のやりとり)'));
+  assert.match(text, /\*\*最新ユーザー指示\*\* \[\d\d:\d\d:\d\d\]: lone user message/);
+  assert.ok(
+    !text.includes('**直前のアシスタント**'),
+    'no assistant body present → no 直前のアシスタント line',
+  );
+});
+
 test('buildResumeContext: L2 is the very last section (anchored at bottom for attention)', () => {
   const db = makeDb();
   insertSkeleton(db, {
@@ -239,9 +366,11 @@ test('buildResumeContext: L2 entries get inline (詳細：…) suffixes with too
 
   assert.ok(text);
 
+  // Look for the L2 body line specifically (not the 現在地 anchor line which also
+  // contains the latest assistant body).
   const turnWithToolsLine = text
     .split('\n')
-    .find((l) => l.includes('turn with tools'));
+    .find((l) => /^\[\d\d:\d\d:\d\d\] \[assistant\]: turn with tools/.test(l));
   assert.ok(turnWithToolsLine, 'L2 line for turn 5 should exist');
   // - tool_input + tool_output は tool 名で集約 (Bash ×2)
   // - hook 出力 (system) は suffix から除外
@@ -265,7 +394,9 @@ test('buildResumeContext: L2 entries get inline (詳細：…) suffixes with too
     'per-line should not repeat the throughline detail command (the header announces it)',
   );
 
-  const plainLine = text.split('\n').find((l) => l.includes('plain user message'));
+  const plainLine = text
+    .split('\n')
+    .find((l) => /^\[\d\d:\d\d:\d\d\] \[user\]: plain user message/.test(l));
   assert.ok(plainLine, 'L2 line for turn 6 should exist');
   assert.ok(
     !plainLine.includes('詳細：'),
@@ -341,9 +472,14 @@ test('buildResumeContext: (詳細：…) suffix appears only on the last role ro
 
   assert.ok(text);
 
-  const userTurn5 = text.split('\n').find((l) => l.includes('user side of turn 5'));
-  const assistantTurn5 = text.split('\n').find((l) => l.includes('assistant side of turn 5'));
-  const userTurn6 = text.split('\n').find((l) => l.includes('lone user turn'));
+  // Match L2 body lines specifically (`[HH:MM:SS] [role]: ...`) to avoid colliding
+  // with the 現在地 anchor lines (`**最新ユーザー指示** [HH:MM:SS]: ...`).
+  const lines = text.split('\n');
+  const userTurn5 = lines.find((l) => /^\[\d\d:\d\d:\d\d\] \[user\]: user side of turn 5/.test(l));
+  const assistantTurn5 = lines.find(
+    (l) => /^\[\d\d:\d\d:\d\d\] \[assistant\]: assistant side of turn 5/.test(l),
+  );
+  const userTurn6 = lines.find((l) => /^\[\d\d:\d\d:\d\d\] \[user\]: lone user turn/.test(l));
 
   assert.ok(userTurn5 && assistantTurn5 && userTurn6);
   // Turn 5: only assistant (last role of the turn) gets the suffix