@cocorograph/hub-agent 0.7.102 → 0.7.104

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cocorograph/hub-agent",
-  "version": "0.7.102",
+  "version": "0.7.104",
   "description": "Hub Hosted Cockpit のローカル常駐 agent。Hub と outbound WSS で接続し、ローカルの tmux/pty を中継する。",
   "type": "module",
   "license": "UNLICENSED",

package/src/claude-history.mjs

@@ -23,6 +23,46 @@ import {
   maskMessageObject,
   redactSecrets,
 } from "./tool-result-mask.mjs"
+import { lookupInjectSource } from "./inject-source-store.mjs"
+
+/** user 履歴イベントの本文を取り出す (string content / text ブロック配列の両対応)。
+ *  連携カード source の永続タグ付けで、注入本文との一致判定に使う。 */
+function historyUserText(event) {
+  const content = event?.message?.content
+  if (typeof content === "string") return content
+  if (Array.isArray(content)) {
+    return content
+      .filter((b) => b && b.type === "text" && typeof b.text === "string")
+      .map((b) => b.text)
+      .join("\n")
+  }
+  return ""
+}
+
+/**
+ * 連携カード種別 (Phase 2 永続化): hydrate した履歴イベントのうち、この cwd で注入と本文一致する
+ * user メッセージへ source を付け直す (reattach / cold resume / 別端末でもカードを維持する)。
+ * hydrateCache の共有オブジェクトを壊さないよう、タグを付けるイベントだけ **shallow-clone** して
+ * 差し替える (source が無いイベントは元のまま = 参照維持でコスト無し)。
+ * @param {object[]} events
+ * @param {string} cwd
+ * @returns {Promise<object[]>}
+ */
+export async function tagHistoryInjectSources(events, cwd) {
+  if (!cwd || !Array.isArray(events) || events.length === 0) return events
+  let out = null // 変更が発生したときだけ配列を複製する (通常セッションはコスト 0)
+  for (let i = 0; i < events.length; i++) {
+    const ev = events[i]
+    if (!ev || ev.type !== "user" || ev.source) continue
+    const text = historyUserText(ev)
+    if (!text) continue
+    const source = await lookupInjectSource(cwd, text)
+    if (!source) continue
+    if (!out) out = events.slice()
+    out[i] = { ...ev, source }
+  }
+  return out || events
+}
 
 export const MAX_HISTORY_LINES = 500
 
@@ -282,7 +322,10 @@ export async function fetchSessionHistory({ cwd, session_id, maxLines, projectsR
   const filePath = jsonlPath({ cwd, session_id, projectsRoot })
   try {
     const result = await readSessionHistory(filePath, { maxLines, logger })
-    return { ...result, file_path: filePath }
+    // 連携カード種別 (Phase 2 永続化): 注入 user メッセージへ source を付け直す (hydrateCache は
+    // filePath キーで cwd を持たないため、cwd を持つここでタグ付けする。クローンで cache 非破壊)。
+    const events = await tagHistoryInjectSources(result.events, cwd)
+    return { ...result, events, file_path: filePath }
   } catch (err) {
     return {
       events: [],

package/src/claude-stream-bridge.mjs

@@ -32,6 +32,7 @@ import {
   maskJsonlFileAtRest,
 } from "./tool-result-mask.mjs"
 import { getOrCreateSiblingToken } from "./sibling-token.mjs"
+import { recordInjectSourcePersistent } from "./inject-source-store.mjs"
 
 /**
  * sibling-inject (2026-07-04) 用: spawn する claude プロセス自身の環境変数に、
@@ -530,15 +531,16 @@ export class ClaudeStreamSession {
   /** マスク済みイベントを onEvent へ流す共通経路。秘匿情報 / 非公開スキルプロンプト本文を
    *  表示・WS 配信前に伏せる。マスク失敗時は素のイベントを流す (表示が止まるより素通し優先)。 */
   /** 連携カード種別 (Phase 2): 注入本文と source を FIFO に控える。sendToCwd/sendToStream が
-   *  session.sendMessage() を呼ぶ直前に記録し、直後の user echo を _tagInjectSource が拾う。
+   *  session.sendMessage() を呼ぶ直前に記録し、**drain 昇格時に _emitQueueState が started 本文
+   *  一致で消費**して startedSources として frontend へ載せる。
    *
-   *  ⚠️ 相関は「注入本文の完全一致」で行う (cross-review round1 major#1)。ID をメタデータで
-   *  伝播する方が堅牢だが、**Claude Agent SDK の user echo には隠しメタを載せる経路が無い**
-   *  (echo は本文そのもの)。cockpit_orch.py が注入本文末尾に付ける返信 footer で本文の一意性が
-   *  高く、人間が同一本文を打つ衝突は実質起きない。残る衝突リスクは①送信失敗時の stale entry
-   *  → _removeInjectSource で掃除、②未 echo の無限成長 → 32 件上限、で最小化する。衝突時も
-   *  誤タグ (青バブルが稀にカード化) に留まりクラッシュしない。
-   *  @param {string} text 注入本文 (SDK が echo する user メッセージ本文と一致する)
+   *  ⚠️ claude は SDK が user メッセージを live echo しない (reducer set_queue コメント参照)。
+   *  user バブルは queue_state の started 昇格で作られるため、当初の _emit(user echo) タグ方式は
+   *  claude で発火せず注入が青バブルのままだった (2026-07-23 実機で判明)。消費点を _emitQueueState
+   *  に移した。相関は「注入本文の完全一致」(footer 込みで一意性が高い)。ID メタ伝播が堅牢だが
+   *  started は本文しか持たないため本文相関を採る。衝突リスクは①送信失敗時の stale → _removeInjectSource
+   *  で handle 同定除去、②未 drain の無限成長 → 32 件上限、で最小化。衝突時も誤タグ止まりで安全。
+   *  @param {string} text 注入本文 (drain 時の started 本文と一致する)
    *  @param {'peer'|'orchestrator'|undefined} source
    *  @returns {object|null} この entry の固有 handle (identity)。配送失敗時に _removeInjectSource へ
    *    渡して**その entry だけ**を除去する。無効な source/text では null。 */
@@ -563,30 +565,6 @@ export class ClaudeStreamSession {
     if (idx !== -1) this._pendingInjectSources.splice(idx, 1)
   }
 
-  /** user echo イベントの本文が控えた注入本文と一致すれば source タグを付けて返す (それ以外は
-   *  無変更)。frontend はこの source があれば専用の連携依頼カードへ分岐する。共有/at-rest の
-   *  イベントを壊さないよう shallow-clone に付ける (top-level に source を足すだけ)。 */
-  _tagInjectSource(event) {
-    if (!this._pendingInjectSources.length) return event
-    if (!event || event.type !== "user" || !event.message) return event
-    const content = event.message.content
-    const text =
-      typeof content === "string"
-        ? content
-        : Array.isArray(content)
-          ? content
-              .filter((b) => b && b.type === "text" && typeof b.text === "string")
-              .map((b) => b.text)
-              .join("\n")
-          : ""
-    if (!text) return event
-    const idx = this._pendingInjectSources.findIndex((p) => p.text === text)
-    if (idx === -1) return event
-    const { source } = this._pendingInjectSources[idx]
-    this._pendingInjectSources.splice(idx, 1)
-    return { ...event, source }
-  }
-
   _emit(event) {
     if (!this.onEvent) return
     let out = event
@@ -601,7 +579,6 @@ export class ClaudeStreamSession {
         out = event
       }
     }
-    out = this._tagInjectSource(out)
     this.onEvent(out)
   }
 
@@ -1026,6 +1003,9 @@ export class ClaudeStreamSession {
       // 初回ターンの ultracode は起動時 options.settings に焼き込むため、起動前 reconcile
       // (applyFlagSettings) のための空窓も不要。
       if (!this._residentQuery || this._residentQueryReturned) {
+        // Phase 2 (major#1): resident fresh start は started を出さないため、注入なら source 付きで
+        // 昇格バブルを作るよう started を先出しする (通常メッセージは no-op)。
+        this._maybeEmitInjectStarted(prompt)
         this._startResidentTurnWithInput(toSDKUserMessage(prompt), ultracode)
         return { accepted: true }
       }
@@ -1038,6 +1018,11 @@ export class ClaudeStreamSession {
         ultracode,
       )
       if (outcome === "closed") return { accepted: false, reason: "queue_dead" }
+      // Phase 2 (round2 major): 起動済み・idle な resident query への delivery は
+      // _reconcileThenDeliver 内で pushed (inputQueue.push) / restarted
+      // (_startResidentTurnWithInput) のどちらも started を出さない。注入なら source 付き
+      // started をここで先出しして昇格バブルをカード化する (通常メッセージは no-op)。
+      this._maybeEmitInjectStarted(prompt)
       return { accepted: true }
     }
 
@@ -1058,6 +1043,9 @@ export class ClaudeStreamSession {
       this._emitQueueState()
       return { accepted: true }
     }
+    // Phase 2 (major#1): per-message idle 直接実行も started を出さないため、注入なら source 付きで
+    // 昇格バブルを作るよう started を先出しする (通常メッセージは no-op)。
+    this._maybeEmitInjectStarted(prompt)
     // ack はターン完走を待たず「起動できたか」で返すため、フル実行の Promise を
     // 呼び出し元へ伝播させない (fire-and-forget)。例外は _runPerMessage 内部で
     // 握っているため通常は reject しないが、念のため warn だけ残す。
@@ -1304,6 +1292,20 @@ export class ClaudeStreamSession {
     // force のときは再アタッチ snapshot なので重複チェックを完全にバイパスする。
     if (!force && started.length === 0 && sig === this._lastEmittedQueueSig) return
     this._lastEmittedQueueSig = sig
+    // 連携カード種別 (Phase 2, 2026-07-23 修正): **claude は SDK が user メッセージを live echo
+    // しない** (reducer set_queue のコメント参照)。ゆえに user バブルは queue_state の started
+    // (drain 昇格) から作られる。当初 _emit の user echo にタグする実装は claude では発火せず
+    // (dead code)、注入が青バブルのままだった (実機確認)。正しくは started 各テキストの source を
+    // ここで _pendingInjectSources から引いて startedSources として載せ、frontend が昇格バブルへ
+    // source を付ける。started は全 drain 経路 (_drainPending / resident / per-message finally) が
+    // 通る funnel なのでここ 1 箇所で全経路をカバーする。注入本文 (footer 込み) の完全一致で消費。
+    const startedSources = started.map((text) => {
+      const idx = this._pendingInjectSources.findIndex((p) => p.text === text)
+      if (idx === -1) return null
+      const { source } = this._pendingInjectSources[idx]
+      this._pendingInjectSources.splice(idx, 1)
+      return source
+    })
     try {
       // messages は全文を載せる。frontend は実行開始 (drain) 時にこれを user バブルへ
       // 昇格させるため、ここで切り詰めると本文が欠ける。チップの省略表示は CSS 側で行う。
@@ -1314,12 +1316,25 @@ export class ClaudeStreamSession {
         messages: this._pendingMessages.map((m) => m.text),
         items: this._pendingMessages.map((m) => ({ id: m.id, text: m.text })),
         started,
+        // started と parallel。連携注入なら 'peer'|'orchestrator'、通常は null。
+        startedSources,
       })
     } catch {
       /* ignore */
     }
   }
 
+  /** 連携カード種別 (Phase 2, cross-review major#1): **idle 直接送信経路**用。busy→queue→drain は
+   *  _emitQueueState([text]) を通るが、idle 直接実行 (resident fresh start / per-message 即時) は
+   *  started を出さないため、注入の source が startedSources に載らずカード化されない。ここで
+   *  「その本文が注入 (source 記録済み) のときだけ」started を 1 件 emit して昇格バブルを source 付き
+   *  で作る。通常メッセージ (source 無し) は emit せず従来経路 (optimistic 等) に任せる = 挙動不変。 */
+  _maybeEmitInjectStarted(prompt) {
+    if (this._pendingInjectSources.some((p) => p.text === prompt)) {
+      this._emitQueueState([prompt])
+    }
+  }
+
   /** 空 InputQueue 窓封鎖 (T06118): fresh start する resume 常駐 query を「入力を先に積んで
    *  から起動」する (push 先行)。fresh な InputQueue を作り、実ユーザーメッセージを push して
    *  から query を起動するため、「resume + 空入力」の窓で SDK が自動継続ターン (Continue from
@@ -2697,14 +2712,28 @@ export class ClaudeStreamBridge extends EventEmitter {
     // 連携カード種別 (Phase 2): 配送先が確定した後に記録する (ambiguous/not_found では記録しない)。
     // handle を控え、失敗時にその entry だけを除去する (round2: text 除去は並行同一本文で誤消費)。
     const injectHandle = session._recordInjectSource?.(text, source)
-    session.sendMessage({ role: "user", content: text }).catch((err) => {
-      // Phase 2: 配送失敗なら echo は来ないので stale な source entry を掃除する (誤タグ防止)。
-      session._removeInjectSource?.(injectHandle)
-      this.logger?.error(
-        { cwd, err: err?.message },
-        "sendToCwd: sendMessage threw unexpectedly",
-      )
-    })
+    session
+      .sendMessage({ role: "user", content: text })
+      .then((r) => {
+        // Phase 2 (major#3): sendMessage は throw せず {accepted:false} で失敗を返す経路がある
+        // (queue_dead / empty_message / pre-canceled)。この場合は echo/started は来ないので
+        // stale な live source entry を掃除し、**永続化もしない** (persist round1 major#1: 失敗を
+        // 永続化すると 30 日 stale が残り後続の同文 human を誤カード化する)。
+        if (r && r.accepted === false) {
+          session._removeInjectSource?.(injectHandle)
+          return
+        }
+        // 受理された (queued/started) ときだけ hydrate 用に永続化する (best-effort、live と独立)。
+        recordInjectSourcePersistent(cwd, text, source).catch(() => {})
+      })
+      .catch((err) => {
+        // 配送失敗 (throw) でも echo は来ないので stale な live entry を掃除する (永続化はしない)。
+        session._removeInjectSource?.(injectHandle)
+        this.logger?.error(
+          { cwd, err: err?.message },
+          "sendToCwd: sendMessage threw unexpectedly",
+        )
+      })
     return { status: "delivered", session: this._describeCandidate(session, att) }
   }
 
@@ -2750,14 +2779,25 @@ export class ClaudeStreamBridge extends EventEmitter {
     const { session, attached } = matches[0]
     // 連携カード種別 (Phase 2): 宛先確定後に記録 (not_found/ambiguous では記録しない)。
     const injectHandle = session._recordInjectSource?.(text, source)
-    session.sendMessage({ role: "user", content: text }).catch((err) => {
-      // Phase 2: 配送失敗なら echo は来ないので stale な source entry を掃除する (誤タグ防止)。
-      session._removeInjectSource?.(injectHandle)
-      this.logger?.error(
-        { session_id: sessionId, err: err?.message },
-        "sendToStream: sendMessage threw unexpectedly",
-      )
-    })
+    session
+      .sendMessage({ role: "user", content: text })
+      .then((r) => {
+        // Phase 2 (major#3 / persist major#1): {accepted:false} は echo/started 来ないので live を
+        // 掃除し永続化もしない (失敗を永続化すると 30 日 stale で後続同文 human を誤カード化)。
+        if (r && r.accepted === false) {
+          session._removeInjectSource?.(injectHandle)
+          return
+        }
+        // 受理時のみ hydrate 用に永続化 (best-effort)。
+        recordInjectSourcePersistent(cwd, text, source).catch(() => {})
+      })
+      .catch((err) => {
+        session._removeInjectSource?.(injectHandle)
+        this.logger?.error(
+          { session_id: sessionId, err: err?.message },
+          "sendToStream: sendMessage threw unexpectedly",
+        )
+      })
     return { status: "delivered", session: this._describeCandidate(session, attached) }
   }
 

package/src/inject-source-store.mjs

@@ -0,0 +1,206 @@
+/**
+ * 連携カード種別 (Phase 2) の **永続ストア** (2026-07-24)。
+ *
+ * 背景 (WHY): claude の連携カードは注入時の live イベント (queue_state.startedSources) にだけ
+ * source が乗り、会話履歴 (jsonl) には書かれない。そのため reattach / cold resume / 別端末
+ * (スマホ) で開くと履歴 hydrate 由来の user バブルには source が無く、カードが青バブルへ戻る。
+ * 「履歴でも連携カードのまま残したい」(ユーザー要望 2026-07-24) を満たすため、注入本文と source を
+ * cwd 単位でサイドカー (`~/.hub/inject-sources.json`) に永続化し、hydrate 時に本文一致で付け直す。
+ *
+ * ⚠️ 設計 (cross-review 指摘への対応):
+ *  - **隔離**: cwd 単位でリストを分ける (別 workspace の注入と混ざらない)。
+ *  - **相関**: 注入本文の完全一致 (footer 込みで一意性が高い)。ID メタ経路が無い claude の制約下で
+ *    live 経路 (queue_state) と同じ相関方式に揃える。衝突時も誤タグ止まりでクラッシュしない。
+ *  - **失敗は永続化しない** (persist round1 major#1): 呼び出し側 (claude-stream-bridge) が
+ *    sendMessage 受理時 (accepted!==false) のみ record を呼ぶ。reject/accepted:false では呼ばない
+ *    ため、30 日 stale が残って後続同文 human を誤カード化する事故が起きない。
+ *  - **TTL / 上限** (persist round1 major#2): MAX_AGE_MS 経過 entry は **record 時だけでなく load 時と
+ *    lookup 時にも** prune する (cold resume / 非活性 cwd の期限切れを永久 lookup しない)。
+ *    per-cwd 上限 (MAX_PER_CWD) + cwd 総数上限 (MAX_CWDS、最終活性が古い cwd を退避) で無限成長を防ぐ。
+ *  - **並行/権限** (persist round1 minor): tmp 名は pid + 連番でユニーク化 (複数 process 競合回避)、
+ *    ファイル 0600 / ディレクトリ 0700 で本文 (平文) の権限を絞る (jsonl と同等の秘匿レベル)。
+ *  - **書き込み**: 1s デバウンス + atomic write (tmp+rename)。単一 hub-agent プロセス内は event loop で
+ *    直列化。デバウンス中のプロセス死で最後の数件がロストしても live 表示は無傷 (hydrate だけ劣化)。
+ */
+
+import { readFile, writeFile, rename, mkdir } from "node:fs/promises"
+import path from "node:path"
+import os from "node:os"
+
+const DEFAULT_PATH = path.join(os.homedir() || "/tmp", ".hub", "inject-sources.json")
+export const STORE_PATH = process.env.HUB_INJECT_SOURCE_STORE || DEFAULT_PATH
+const MAX_PER_CWD = 500
+const MAX_CWDS = 200
+const MAX_AGE_MS = 30 * 24 * 60 * 60 * 1000 // 30 日
+const WRITE_DEBOUNCE_MS = 1000
+
+/** @type {Map<string, Array<{text: string, source: 'peer'|'orchestrator', at: number}>> | null} */
+let _cache = null
+let _writeScheduled = false
+let _dirty = false
+let _writeChain = Promise.resolve()
+let _loadPromise = null
+let _tmpCounter = 0
+
+// round2 minor: at が数値でない entry は「期限切れ」扱いにして prune する (欠落を永久 fresh 扱い
+// にするとリークする)。正常な record は必ず at を付けるので、これは破損/外部書き込み対策。
+function isFresh(entry, nowMs) {
+  return typeof entry?.at === "number" && nowMs - entry.at < MAX_AGE_MS
+}
+
+/** cwd リストを TTL + 件数上限で prune する (新しい順を保つため末尾側を残す)。 */
+function pruneList(list, nowMs) {
+  let out = list.filter((e) => isFresh(e, nowMs))
+  if (out.length > MAX_PER_CWD) out = out.slice(out.length - MAX_PER_CWD)
+  return out
+}
+
+/** cwd 総数上限: 空リスト cwd を落とし、超過分は「最終 entry が最も古い cwd」から退避する。 */
+function enforceCwdCap(cache) {
+  for (const [cwd, list] of cache) if (!list.length) cache.delete(cwd)
+  if (cache.size <= MAX_CWDS) return
+  const byRecency = [...cache.entries()].sort((a, b) => {
+    const at = (l) => (l.length ? l[l.length - 1].at || 0 : 0)
+    return at(a[1]) - at(b[1])
+  })
+  const drop = cache.size - MAX_CWDS
+  for (let i = 0; i < drop; i++) cache.delete(byRecency[i][0])
+}
+
+/** 全 cwd を prune する (load / 定期整理用)。変化があれば true。 */
+function pruneAll(cache, nowMs) {
+  let changed = false
+  for (const [cwd, list] of cache) {
+    const pruned = pruneList(list, nowMs)
+    if (pruned.length !== list.length) changed = true
+    cache.set(cwd, pruned)
+  }
+  const before = cache.size
+  enforceCwdCap(cache)
+  if (cache.size !== before) changed = true
+  return changed
+}
+
+/** サイドカーを 1 度だけ読み込み in-memory 化する (load 時に prune する)。 */
+async function ensureLoaded() {
+  if (_cache) return
+  if (_loadPromise) return _loadPromise
+  _loadPromise = (async () => {
+    const cache = new Map()
+    try {
+      const raw = await readFile(STORE_PATH, "utf-8")
+      const obj = JSON.parse(raw)
+      if (obj && typeof obj === "object" && !Array.isArray(obj)) {
+        for (const [cwd, list] of Object.entries(obj)) {
+          if (!Array.isArray(list)) continue
+          const clean = list.filter(
+            (e) =>
+              e &&
+              typeof e.text === "string" &&
+              (e.source === "peer" || e.source === "orchestrator"),
+          )
+          if (clean.length) cache.set(cwd, clean)
+        }
+      }
+    } catch {
+      /* 初回はファイル無し = 空 */
+    }
+    // major#2: load 時に期限切れを prune する (cold resume / 非活性 cwd を永久 lookup しない)。
+    if (pruneAll(cache, Date.now())) {
+      _cache = cache
+      scheduleWrite()
+    } else {
+      _cache = cache
+    }
+  })()
+  await _loadPromise
+  _loadPromise = null
+}
+
+function scheduleWrite() {
+  _dirty = true
+  if (_writeScheduled) return
+  _writeScheduled = true
+  const t = setTimeout(() => {
+    _writeScheduled = false
+    // round2 minor (write race): 書き込みを **promise チェーンで直列化**する。デバウンス満了時に
+    // _dirty を見て 1 回だけ実行し、実行時点の _cache を snapshot する。これで「遅い I/O の最中に
+    // 後続 timer が発火し、古い snapshot の rename が新しい snapshot を後着上書きする」逆転を防ぐ
+    // (rename が重ならない = 直列)。実行中に更に record されたら _dirty が立ち、チェーン末尾で再実行。
+    _writeChain = _writeChain.then(async () => {
+      if (!_dirty) return
+      _dirty = false
+      try {
+        const obj = {}
+        if (_cache) for (const [cwd, list] of _cache) if (list.length) obj[cwd] = list
+        await mkdir(path.dirname(STORE_PATH), { recursive: true, mode: 0o700 })
+        // minor: tmp 名を pid + 連番でユニーク化 (複数 process 同時書き込みの取り違え防止)。
+        const tmp = `${STORE_PATH}.${process.pid}.${_tmpCounter++}.tmp`
+        // minor: 本文 (平文) を含むため 0600 で書く (jsonl と同等の秘匿レベル)。
+        await writeFile(tmp, JSON.stringify(obj), { mode: 0o600 })
+        await rename(tmp, STORE_PATH)
+      } catch {
+        /* best effort: 永続化失敗は live カードには影響しない */
+      }
+      // 実行中に record されて再度 dirty になっていたら、次の debounce を張って追従する。
+      if (_dirty && !_writeScheduled) scheduleWrite()
+    })
+  }, WRITE_DEBOUNCE_MS)
+  t.unref?.()
+}
+
+/** 注入が **受理された後** に呼ぶ: この cwd の注入本文と source を永続化する (hydrate で付け直す)。
+ *  ⚠️ 呼び出し側は sendMessage 受理時のみ呼ぶこと (失敗を永続化しないため。round1 major#1)。
+ *  @param {string} cwd
+ *  @param {string} text 注入本文 (jsonl の user メッセージ本文と一致する)
+ *  @param {'peer'|'orchestrator'|undefined} source
+ *  @param {number} [nowMs] */
+export async function recordInjectSourcePersistent(cwd, text, source, nowMs = Date.now()) {
+  if (!cwd || !text || (source !== "peer" && source !== "orchestrator")) return
+  await ensureLoaded()
+  const list = _cache.get(cwd) || []
+  list.push({ text, source, at: nowMs })
+  _cache.set(cwd, pruneList(list, nowMs))
+  enforceCwdCap(_cache)
+  scheduleWrite()
+}
+
+/** hydrate 時に呼ぶ: この cwd で本文が (期限内の) 注入と一致すれば source を返す (最新一致優先)。
+ *  期限切れ entry はここでも lazy prune する (major#2)。
+ *  @param {string} cwd
+ *  @param {string} text
+ *  @returns {Promise<'peer'|'orchestrator'|null>} */
+export async function lookupInjectSource(cwd, text) {
+  if (!cwd || !text) return null
+  await ensureLoaded()
+  const list = _cache.get(cwd)
+  if (!list || !list.length) return null
+  const nowMs = Date.now()
+  let hit = null
+  let hasStale = false
+  for (let i = list.length - 1; i >= 0; i--) {
+    const e = list[i]
+    if (!isFresh(e, nowMs)) {
+      hasStale = true
+      continue // 期限切れは一致とみなさない
+    }
+    if (hit === null && e.text === text) hit = e.source
+  }
+  if (hasStale) {
+    // 期限切れを取り除いて次回以降の lookup/成長を抑える。
+    const pruned = list.filter((e) => isFresh(e, nowMs))
+    if (pruned.length) _cache.set(cwd, pruned)
+    else _cache.delete(cwd)
+    scheduleWrite()
+  }
+  return hit
+}
+
+/** テスト用: in-memory キャッシュを破棄して次回 ensureLoaded を強制する。 */
+export function _resetForTest() {
+  _cache = null
+  _loadPromise = null
+  _writeScheduled = false
+  _dirty = false
+  _writeChain = Promise.resolve()
+}