@modusensus/dsh-mneme 0.12.0 → 0.14.0-beta.1

package/lib/index.js

@@ -17,6 +17,9 @@ import { createSummarizer } from "./summarize.js";
 import { createSessionGate } from "./session-gate.js";
 import { createDreamScheduler, describeStreamFailure } from "./dream.js";
 import { createSleepScheduler, runSleep } from "./dream/sleep.js";
+// #622 可观测性：错峰时段串解析失败是「静默未配置」（parsePeakSpec 契约不救错），
+// 启动装配后对非空且解析失败的键出一条 warn——只补可见性，不改语义。
+import { invalidPeakSpecs } from "./peak-hours.js";
 import { createApi } from "./api.js";
 import { createStandaloneApi } from "./api-standalone.js";
 // #275 存储生命周期第一批：无损回收（手动入口，不挂启动路径）。
@@ -27,15 +30,23 @@ import { createChoroInject } from "./wiki/inject.js";
 import { registerChoroCommand } from "./choro-command.js";
 // 收尾档：面板重建按钮走 runChoroT0（P34；T1 不上 HTTP）。
 import { runChoroT0 } from "./wiki/t0.js";
+// T1 后台任务账（契约 §3.2）：面板点「补语义正文」走 HTTP 起一个 spawn 子进程，
+// 进程账不能住在 api.js（HTTP 面刻意不摸 child_process），装配点在这里。
+import { createT1Jobs } from "./wiki/t1-jobs.js";
 import { createSettings } from "./settings.js";
 // 「Agent 眼中的你」自动事实（2026-11-06）：逐卡事实清单 + dream 后自动维护轮。
 import { createProfileFacts } from "./profile-facts.js";
+// 知识库第二层（契约 §3.4）：装配与开关无关（createKb 只建对象，读侧零 IO），
+// 闸在路由与工具两层——这样「没开」与「没装配」在 HTTP 面上是两个可区分答案。
+import { createKb } from "./kb/index.js";
 import { createCommandManager } from "./commands.js";
 import { createExecutionRecorder } from "./pipeline-runner.js";
 import { registerMoRunCommand } from "./pipeline-command.js";
 // M.O. 自动沉淀的触发侧（冷却 / 排队 / 兜底）。挖掘与落盘在 pipeline-nudge.js，
 // 这里只管「什么时候跑」。两者分开的理由见 src/pipeline-nudge-auto.js 文件头。
 import { createNudgeAutoRun } from "./pipeline-nudge-auto.js";
+// QQ 日记本：合成管线（compose）与触发侧（auto）分开，理由见 src/diary/index.js 文件头。
+import { createDiaryComposer, createDiaryAutoRun } from "./diary/index.js";
 import { createVectorIndex } from "./vector-index.js";
 // semantic(embedder/reranker/boot 回填)纯搬移至 src/semantic.js(PR2):宿主与
 // daemon(dsh-mneme-serve,#363)共用同一套装配,原文件保留 barrel 出口。
@@ -243,6 +254,19 @@ export const apply = (ctx, config) => {
   for (const [objKey, sub] of Object.entries(nestedFlags)) {
     cfg[objKey] = { ...(cfg[objKey] ?? {}), ...sub };
   }
+  // #622：错峰时段串（summarizePeakHours / dreamPeakHours）解析失败 = 静默未配置
+  // （parsePeakSpec 的契约：排程是省钱手段，绝不该因写错格式停掉蒸馏/巩固）。但
+  // 「不救错」不等于「不吭声」——配置写错的唯一症状是功能悄悄没生效（#424 的排查
+  // 只能靠「高峰期还在巩固」倒推）。这里对**非空**且解析为 null 的键各出一条 warn：
+  // 空串是合法的未配置，不告警（否则每个没配错峰的用户开机都被警告一遍）。helper
+  // 只转述 parsePeakSpec：等价类归一（PR #621，评审中）落地后，救得了的写法自然
+  // 不再走到这。行为零变化：只 log，不改 cfg。
+  for (const [key, spec] of Object.entries(invalidPeakSpecs(cfg))) {
+    ctx.logger?.warn?.(
+      `[dsh-mneme] ${key} "${spec}" 不是合法的高峰时段串，将按未配置处理（错峰不生效、全天候运行）。` +
+      `写法：09:00-18:00，多段用逗号分隔，可带星期前缀（mon-fri 08:00-12:00），支持跨零点；24:00 越界请写 00:00`
+    );
+  }
   const sessionGate = createSessionGate(cfg);
 
   // 失败表的启动期清理也放在装配之后（此前它在 createStore 之后、装配之前，写死
@@ -497,6 +521,34 @@ export const apply = (ctx, config) => {
           metadata: JSON.stringify({ count, chars })
         });
       },
+      // Issue #634：归档/删除/合并把活跃量压到上次成功轮的峰值（= 阈值基线）之下
+      // 时，调度器在判定口把基线夹回当前活跃量。这里把「夹回发生过」落进审计——
+      // 修复前这类收缩会变成永久静默停摆（overBase 恒为假且无任何账面），这条行
+      // 就是「为什么 X 天没巩固」的答案。status 与 peak-hours 同用
+      // "skipped"：按状态聚合（store.auditSummary）只做分组计数，不会把这行算进
+      // 成功率的分母口径之外的新桶；成败口径仍以 dream_runs 为准。门禁与写失败的
+      // fail-safe 同 auditPeakSkip（调度器侧还有一层 try/catch 兜底）。
+      auditBaselineClamp: ({ previous, count, chars }) => {
+        if (cfg?.llmAudit?.enabled === false || typeof service?.saveLlmAudit !== "function") return;
+        const modelId = cfg.dreamProvider && cfg.dreamModel ? `${cfg.dreamProvider}:${cfg.dreamModel}` : "";
+        service.saveLlmAudit({
+          timestamp: new Date().toISOString(),
+          trigger_source: "autoDream",
+          operation_type: "dream_consolidate",
+          model_id: modelId,
+          input_tokens: 0,
+          output_tokens: 0,
+          total_tokens: 0,
+          cost_usd: 0,
+          duration_ms: 0,
+          status: "skipped",
+          error_message: "baseline-clamp",
+          related_memory_ids: [],
+          // 观测用：previous = 夹回前的基线（旧峰值），count/chars = 夹回后的
+          // 活跃量（即新基线）——两份放一起，收缩幅度一眼可读。
+          metadata: JSON.stringify({ previous, count, chars })
+        });
+      },
       onRun: () => {
         const run = dream
           ? dream.runDream(ctx, service, cfg)
@@ -626,10 +678,17 @@ export const apply = (ctx, config) => {
     disposers.push(createContinuityRescue(ctx, store, sessionGate));
   }
 
+  // 知识库第二层（契约 §3.4）：装配与开关无关（createKb 只建对象，读侧零 IO），闸在
+  // 路由与工具两层——这样「没开」（409）与「没装配」（503）在对外两面都是可区分的。
+  // 位置必须在 tools/api 两处消费点之前：cordis 的 inject 回调可能在任一之后才触发，
+  // 在消费点里现建就会造出第二份实例（两份缓存、两套 dispose）。
+  const kb = createKb({ store, embedder, cfg });
+  disposers.push(() => kb.dispose?.());
+
   ctx.inject(["tools"], (toolsCtx) => {
     // choro（M1）：只读查询对象，chorographyEnabled 关着时工具压根不注册（闸在
     // createTools 的 hiddenTools，与 organizeEnabled 同款反向语义）。
-    disposers.push(createTools(toolsCtx, service, cfg, embedder, sessionGate, createChoroQueries({ store })));
+    disposers.push(createTools(toolsCtx, service, cfg, embedder, sessionGate, createChoroQueries({ store }), kb));
   });
 
   // chorography M3：/choro 只读回执。与 /mo-run 同形（ctx.commands.register），
@@ -651,6 +710,15 @@ export const apply = (ctx, config) => {
   const summarizer = createSummarizer(ctx, service, cfg, {}, sessionGate);
   disposers.push(summarizer.dispose);
 
+  // QQ 日记本（v0.13，diaryEnabled）：构造期零副作用（只闭包住依赖，不建目录、不读盘、
+  // 不调模型），所以位置可以放在这里——它必须早于下面的 createApi，面板的
+  // 「写一篇」按钮要转调同一个 composer；而自动触发侧在 webServer 块之后挂（同
+  // actionNudge 的 TDZ 理由）。关闸时 composer 是 null：路由回 409、座位不注册，
+  // 与「装配缺失」的 503 严格区分（#497 先例）。
+  const diary = cfg.diaryEnabled === true
+    ? createDiaryComposer({ ctx, config: cfg, logger: ctx.logger, service, settings, memoryDir })
+    : null;
+
   // #275 存储生命周期第一批：无损回收的手动入口。刻意不挂启动路径、不接定时器——
   // 这一步是不可逆的内容丢弃，只由人显式触发（面板的维护卡、`dsh-mneme reclaim`）。
   // 实例建在插件进程内，是为了让 CLI 也能走这条路：VACUUM 要排他锁，跟宿主抢锁的
@@ -676,17 +744,41 @@ export const apply = (ctx, config) => {
     // 闸在路由/工具两层（关着 409 / 不注册），queries 本体装配与开关无关。
     // 收尾档：choro 对象加两件 host 侧能力——embedder（向量惰性物化，P37）与
     // runT0Apply（面板重建按钮的写路径，P34；T1 不上 HTTP，CLI 仍是它的入口）。
+    // T1 任务账随 choro 装配建立（与开关无关：开关在路由那侧判，没开时这些方法一次
+    // 都不会被调到，符合「503=装配缺件 / 409=用户没开」的分叉）。
+    const t1Jobs = createT1Jobs({ store, dbPath: join(memoryDir, "memory.db") });
+    disposers.push(() => t1Jobs.dispose());
     const choro = {
       ...createChoroQueries({ store }),
       embedder,
-      runT0Apply: ({ repoRoot }) => runChoroT0({ repoRoot, store, apply: true }),
+      // guardT1Loss 只给「读侧顺手刷新」用：那条路不是用户的明确指令，不能替他
+      // 丢掉花模型调用换来的语义段。手动重建（面板按钮 / CLI）不传，行为不变。
+      runT0Apply: ({ repoRoot, guardT1Loss = false }) => runChoroT0({ repoRoot, store, apply: true, guardT1Loss }),
+      startT1Job: (args) => t1Jobs.start(args),
+      t1JobStatus: (jobId) => t1Jobs.status(jobId),
     };
+    // The semantic surface handed to the API is createSemantic()'s own return
+    // value, plus the vectorIndex it does not carry. Passing the bare literal
+    // `{ vectorIndex, reranker }` used to drop embeddingDiagnostics, so the
+    // panel's `data.embeddings` was permanently null on a real install — the
+    // typeof guard in api.js fell through every time, and no test noticed
+    // because none asserted on `data.embeddings`.
     const api = createApi(ctx, service, settings, commands ?? {
       add: () => { throw new Error("commands unavailable"); },
       remove: () => false,
       list: () => []
-    }, embedder, { vectorIndex, reranker }, cfg.apiToken, cfg, maintenance, extractProfileDraft, choro, profileFacts);
+    }, embedder, { ...semantic, vectorIndex, reranker }, cfg.apiToken, cfg, maintenance, extractProfileDraft, choro, profileFacts, kb, diary);
     disposers.push(api.dispose);
+
+    // dsh-go 原生面板：只有宿主提供 dshGo 服务（dsh-go 手机 App）时才挂载。
+    // 动态 import 是刻意的——静态导入会让「没有桥就整块不加载」这句承诺落空。
+    // cfg.apiToken 一并交给面板：createApi 给 token / token-write 路由包了鉴权，
+    // 进程内调用不带令牌会被自家路由拦成 401，不为此在服务端开白名单。
+    ctx.inject(["dshGo"], (dshCtx) => {
+      import("./dsh-go/panel.js")
+        .then((panel) => panel.mountDshGoPanel(dshCtx, { apiToken: cfg.apiToken }))
+        .catch((error) => ctx.logger?.warn?.(`[dsh-mneme] dsh-go 面板未加载：${error?.message ?? error}`));
+    });
   }
 
   // M.O. 自动沉淀（v0.9.3）：项目里重复走的那套动作，自动变成 memoryDir 里的一条
@@ -701,6 +793,34 @@ export const apply = (ctx, config) => {
     disposers.push(createNudgeAutoRun({ ctx, memoryDir, logger: ctx.logger, sessionGate }));
   }
 
+  // 日记的触发侧（v0.13）：turn/end 跨天判定 + 启动补写。
+  //
+  // 启动补写为什么在这里而不是 webServer 块里：它不依赖面板，headless 宿主也该补。
+  // 补哪个项目只能靠状态文件里记过的项目根——宿主刚起来时没有任何会话，
+  // 而「上次是哪个项目、哪天写的」就在那儿。补写不 await：启动路径上吊住一次
+  // 模型调用，等于让整个插件加载等模型回来（本机 p90 五十秒级）。
+  if (diary) {
+    // diaryWriteEveryMinutes > 0 时额外起一根定时器（见 auto.js 的 tick）：日记不该
+    // 取决于「谁先开口」，整天不说话也要有一篇。listProjects 用 knownProjects ——
+    // 定时器唤醒时没有会话，只能靠状态文件里记过的项目根。
+    const everyMinutes = Number(cfg.diaryWriteEveryMinutes) || 0;
+    const diaryAuto = createDiaryAutoRun({
+      ctx,
+      composer: diary,
+      logger: ctx.logger,
+      sessionGate,
+      everyMs: everyMinutes > 0 ? everyMinutes * 60 * 1000 : 0,
+      listProjects: () => diary.knownProjects()
+    });
+    disposers.push(diaryAuto);
+    const projects = diary.knownProjects();
+    if (projects.length) {
+      Promise.resolve(diaryAuto.catchUp(projects)).catch((error) => {
+        ctx.logger?.warn?.("[dsh-mneme] diary startup catch-up failed: " + String(error));
+      });
+    }
+  }
+
   // Standalone external API (v0.7.12): plain node:http server for ecosystem
   // integrations outside the DSH host. Persisted external_api settings win
   // over the bundle config (enabled/port); the Bearer token lives in the same

package/lib/inject.js

@@ -44,13 +44,17 @@ function visibleSeqsOf(session) {
 // 候选问的是同一件事——「当时到底想干什么」；这条取原话的路只该有一份实现。
 // 复制一份的代价本仓库付过几次（src/lib 平价、snapshotEvents 兼容层），所以
 // 这里只加 export，不改行为。
-export function lastUserQuery(ctx) {
+//
+// #617：多带一个 seq——注入器要拿它判断「待认领票据是否比事件流更新」（见
+// createInjector 的 pendingQueries）。seq 是宿主事件序号，取不到时为 null
+// （老版本宿主 / 测试夹具），调用方按 null 参与相等比较，不做真假推断。
+export function lastUserMessageInfo(ctx) {
   try {
     const session = ctx?.agent?.session;
     // DSH ≥0.1.2-rc only exposes events via snapshotEvents(); older builds
     // still have the .events property, so fall back to it.
     const events = session?.snapshotEvents?.() ?? session?.events;
-    if (!Array.isArray(events) || events.length === 0) return "";
+    if (!Array.isArray(events) || events.length === 0) return { text: "", seq: null };
     const visibleSeqs = visibleSeqsOf(session);
     for (let i = events.length - 1; i >= 0; i--) {
       const event = events[i];
@@ -61,16 +65,44 @@ export function lastUserQuery(ctx) {
       if (kind !== undefined && kind !== "user") continue;
       const parts = event.data?.content;
       if (!Array.isArray(parts) || parts.length === 0) continue;
-      return safeSlice(
-        parts
-          .map((p) => (typeof p === "string" ? p : p?.text ?? ""))
-          .filter(Boolean)
-          .join("\n"),
-        500
-      );
+      return {
+        text: safeSlice(
+          parts
+            .map((p) => (typeof p === "string" ? p : p?.text ?? ""))
+            .filter(Boolean)
+            .join("\n"),
+          500
+        ),
+        seq: event?.seq ?? null
+      };
     }
   } catch { /* session internals unavailable: degrade to no query */ }
-  return "";
+  return { text: "", seq: null };
+}
+
+export function lastUserQuery(ctx) {
+  return lastUserMessageInfo(ctx).text;
+}
+
+// 认领消息 → 查询文本。#617 的补位票据就是这里算出来的字符串：判定口径与
+// user/message 事件同源（content parts + source.kind），于是「插件注入的上下文」
+// 这类非人类消息照样被跳过，票据不会拿插件自己的话当用户问题。
+function inboxMessageQuery(message) {
+  try {
+    const parts = message?.content ?? message?.data?.content;
+    if (!Array.isArray(parts) || parts.length === 0) return "";
+    const kind = message?.source?.kind ?? message?.data?.source?.kind;
+    if (kind !== undefined && kind !== "user") return "";
+    return safeSlice(
+      parts
+        .map((p) => (typeof p === "string" ? p : p?.text ?? ""))
+        .filter(Boolean)
+        .join("\n"),
+      500
+    );
+  } catch {
+    return "";
+  }
 }
 
 // Hot-memory round extraction (v0.5.0 1.3): pairs each user/message with the
@@ -80,6 +112,14 @@ export function lastUserQuery(ctx) {
 // visibleSeqsOf). Rewind-shadowed / compacted events are thereby excluded:
 // hot memory and the model see the same conversation. Best-effort: returns []
 // on any failure, and the hot block simply does not render.
+//
+// omitPendingRound: true（Issue #637）：prompt 组装发生的时刻，尾部 pending 轮
+// 就是「正在组装的这一轮」——它的提问已经作为真实 user message 在本条 prompt
+// 里，热记忆里再渲染一份空 `A:` 行是纯重复，且回答落地后该行会从空 `A:` 抖成
+// 正文：宿主「文本变了就追加快照」的契机会让同一轮的注入块被追加多份 runtime-
+// context，旧份永久留在会话历史（#637 报告：4 轮 → 10 份、75% 重复）。省略之后
+// 一轮内热块文本恒定、回答落地时恰好变一次——快照数降到每轮一份。直调方
+// （tests / 其他消费者）不传这个参数，保持完整配对。
 function extractRounds(ctx, maxRounds) {
   try {
     const session = ctx?.agent?.session;
@@ -87,7 +127,7 @@ function extractRounds(ctx, maxRounds) {
     // still have the .events property, so fall back to it.
     const events = session?.snapshotEvents?.() ?? session?.events;
     if (!Array.isArray(events) || events.length === 0) return [];
-    return roundsFromEvents(events, maxRounds, visibleSeqsOf(session));
+    return roundsFromEvents(events, maxRounds, visibleSeqsOf(session), { omitPendingRound: true });
   } catch {
     return [];
   }
@@ -259,7 +299,11 @@ export function createInjector(ctx, service, settings, config, gate = null, sess
         ? STR.verified[language]
         : "";
       const title = STR.entryTitle[language](m.title, m.importance);
-      const content = injectMemory(m, pinned ? PINNED_CONTENT_MAX : maxContent);
+      // Issue #641（T4 注入标注）：conflictNote 由 injectCandidates 在 enforce
+      // 档下挂上（矛盾对同批时的机械排位说明）。#537 的教训：标注必须进注入
+      // 文本本体，不能只留在账本里——消费方看不见的标注等于没标。
+      const content = injectMemory(m, pinned ? PINNED_CONTENT_MAX : maxContent)
+        + (m.conflictNote ? "\n" + m.conflictNote : "");
       const full = m.graphHint === true
         ? STR.graphHintLine[language](m.type, title, content)
         : STR.entryLine[language](m.type, verified, title, content);
@@ -291,21 +335,117 @@ export function createInjector(ctx, service, settings, config, gate = null, sess
   // first render after a new user message may still fall back to the rule-based
   // pick; later assemblies in the same session reuse the cached vector. Bounded
   // cache (cap 8, drop oldest) so a long session never grows it unbounded.
+  //
+  // #617 根因 B：旧实现用一个 lastPrefetched 字符串做去重，且它在 await 之前
+  // 就置位——同一条查询第一次失败（模型没下好、超时）之后**永不重试**，而那
+  // 恰好是最需要重试的一次。这里换成三件套：inflight Map 去重（渲染同一步会
+  // 被求值两次：assemble 一次、refreshContext 一次，同一条查询只该嵌一次）、
+  // 失败冷却 15s（失败可重试，但不许每次渲染都拿一次失败去撞模型）、返回
+  // Promise（调用方/测试能等到它，而不是靠魔法延时）。
   const QUERY_VECTOR_CACHE_MAX = 8;
+  const PREFETCH_FAIL_COOLDOWN_MS = 15000;
   const queryVectorCache = new Map();
-  let lastPrefetched = "";
+  const inflightPrefetches = new Map(); // query -> Promise<vector|null>
+  const prefetchFailedAt = new Map(); // query -> ms
 
   function prefetchQueryVector(query) {
-    if (!query || query === lastPrefetched || queryVectorCache.has(query)) return;
-    lastPrefetched = query;
-    service.embedQuery(query).then((vec) => {
+    if (!query) return null;
+    const cached = queryVectorCache.get(query);
+    if (cached) return Promise.resolve(cached);
+    const inflight = inflightPrefetches.get(query);
+    if (inflight) return inflight;
+    const failedAt = prefetchFailedAt.get(query);
+    if (failedAt !== undefined && Date.now() - failedAt < PREFETCH_FAIL_COOLDOWN_MS) return null;
+    const pending = service.embedQuery(query).then((vec) => {
       if (Array.isArray(vec) && vec.length) {
         queryVectorCache.set(query, vec);
         if (queryVectorCache.size > QUERY_VECTOR_CACHE_MAX) {
           queryVectorCache.delete(queryVectorCache.keys().next().value);
         }
+        prefetchFailedAt.delete(query);
+        return vec;
       }
-    }).catch(() => { /* prefetch is best-effort */ });
+      prefetchFailedAt.set(query, Date.now());
+      return null;
+    }).catch(() => {
+      prefetchFailedAt.set(query, Date.now());
+      return null; /* prefetch is best-effort */
+    }).finally(() => {
+      inflightPrefetches.delete(query);
+    });
+    inflightPrefetches.set(query, pending);
+    return pending;
+  }
+
+  // #617 根因 A 的补位票据：宿主（agent-loop 0.2.x）在每个 step 的 pre-step 里
+  // 先 inbox.claim()（同步 emit agent/inbox/claimed），再 assemble()，而
+  // user/message 要到 step() 末尾（:865）才 append——注入的 text 回调在
+  // assemble / refreshContext 里求值，**永远比当轮用户输入早一拍**：Step 1 拿到
+  // ""，第 N 轮的 Step 1 只能拿到第 N-1 轮的旧文本（实测 46 个渲染点错 3 次）。
+  // 票据在 claim 那一刻记下原文；渲染时若事件流里最后一条用户消息还不是它，
+  // 说明本轮 user/message 尚未落盘，用票据；一旦落盘，事件流才是权威（它对
+  // rewind / compact 的可见面判定更准，票据不看 surface）。
+  //
+  // 为什么只在 claimed 上记、不从 agent/inbox/spliced 推：claim 自己的两次
+  // mutate 都落 outcome:"canceled" 的 spliced（inserted 为空），拿 removedCount
+  // 当撤回信号会把每次正常认领误判成取消；claimed 只在真有消息被认领时触发，
+  // 是唯一无歧义的信号源。Cancel/Rewind 穿透因此也不存在——它们不产生 claimed。
+  const PENDING_QUERY_MAX = 32;
+  // 票据超过这个岁数就不再采信：一个 step 的 assemble 不可能跑这么久，更久说明
+  // 那条消息压根没落盘（认领后整轮被取消），票据已是过期证据。
+  const PENDING_QUERY_TTL_MS = 60000;
+  const pendingQueries = new Map(); // sessionId -> { text, at }
+  const offClaimed = typeof ctx?.on === "function"
+    ? ctx.on("agent/inbox/claimed", (payload) => {
+      try {
+        const message = payload?.message;
+        const text = inboxMessageQuery(message);
+        if (!text) return;
+        const session = payload?.agent?.session;
+        const sessionId = session?.id;
+        if (typeof sessionId !== "string" || !sessionId) return;
+        // #539 无痕闸门必须挡在这里，不能只挡渲染侧：claim 在 pre-step 里同步触发，
+        // 早于 assemble；这条路径既写票据（票据会变成注入查询文本）又预取向量
+        // （embedQuery 直接 POST 外部 /embeddings），闸门命中时两者都是该会话数据的
+        // 外流。嵌入层自身没有任何会话维度判断，这里是唯一的拦截点。
+        if (sessionGate?.isOff(session)) return;
+        pendingQueries.delete(sessionId); // 重新插入 = 移到队尾
+        pendingQueries.set(sessionId, { text, at: Date.now() });
+        if (pendingQueries.size > PENDING_QUERY_MAX) {
+          pendingQueries.delete(pendingQueries.keys().next().value);
+        }
+        // 认领即预取：embed 在 assemble→step 之间就已经在跑，Step 1 的第二次
+        // 求值（refreshContext）有机会拿到向量。拿不到也无妨——查询文本已经在
+        // 手上，BM25 词法路（#198）能顶上。
+        prefetchQueryVector(text);
+      } catch { /* the ticket is best-effort; injection must never break */ }
+    })
+    : null;
+
+  // 当轮查询：票据优先于事件流（见上）。判据是**文本比对**而不是事件条数——
+  // 从 claim 到 assemble 之间还夹着 await tools.resolve(...)，这期间任何插件
+  // 追加一个事件都会让条数增长，按条数判会把「消息还没落盘」误判成「已落盘」，
+  // 票据提前退休、Step 1 又退回空串（正是本 issue 要修的那一拍）。文本相等才是
+  // 「这条消息真的进事件流了」的直接证据；连续两轮同一句话时两者相等，取哪个都对。
+  function liveStepQuery(ctx) {
+    const info = lastUserMessageInfo(ctx);
+    let sessionId = null;
+    try {
+      const id = ctx?.agent?.session?.id;
+      if (typeof id === "string" && id) sessionId = id;
+    } catch { /* session internals unavailable */ }
+    if (!sessionId) return info.text;
+    const ticket = pendingQueries.get(sessionId);
+    if (!ticket) return info.text;
+    if (info.text === ticket.text) {
+      pendingQueries.delete(sessionId); // 已落盘，票据退休（顺带保证 Map 不被历史会话撑大）
+      return info.text;
+    }
+    if (Date.now() - ticket.at > PENDING_QUERY_TTL_MS) {
+      pendingQueries.delete(sessionId); // 过期证据，不采信
+      return info.text;
+    }
+    return ticket.text;
   }
 
   // 会话身份解析（v1.2 人格寻址用）：读 session.header.agentPreset——冻结的
@@ -323,6 +463,39 @@ export function createInjector(ctx, service, settings, config, gate = null, sess
     }
   }
 
+  // 会话 id 解析（#606 绑会话卡用）：session.id 在宿主里稳定可用（scope.js:97-103
+  // 就是靠它反查 workspace 的）。与 agentPreset 一样各自护住——两者来自同一个
+  // session 对象，但 accessor 抛错时不该互相拖累（一个取不到不影响另一个）。
+  // 为什么需要第二个键：DS Bot 里 agentPreset 恒为 "standard"，按 bot 建卡分不开，
+  // 只有会话 id 能分开（实测见 issue #606）。
+  function sessionIdOf(ctx) {
+    try {
+      const id = ctx?.agent?.session?.id;
+      return typeof id === "string" && id.trim() ? id.trim() : null;
+    } catch {
+      return null;
+    }
+  }
+
+  // 父会话 id 解析（子 agent 继承人格卡用）：子代理会话的 header 里有 `parentSession`
+  // （实测 518 个子代理头恒带此字段，主会话没有）。⚠️ 与 `session-gate.js` 的口径不同：
+  // 那里刻意不用它判「是不是子代理」（宿主 fork 出的主会话分支同样带 parentSession），
+  // 这里只把它当「自己没建卡时该继承谁」的线索，fork 出的分支继承父卡同样是正确语义。
+  function parentSessionIdOf(ctx) {
+    try {
+      const session = ctx?.agent?.session;
+      const parent = session?.header?.parentSession;
+      return typeof parent === "string" && parent.trim() ? parent.trim() : null;
+    } catch {
+      return null;
+    }
+  }
+
+  // 一次取全三个寻址键。分开取值、各自兜错：一个失败不该让另一个也丢。
+  function sessionIdentity(ctx) {
+    return { agentId: sessionAgentId(ctx), sessionId: sessionIdOf(ctx), parentSessionId: parentSessionIdOf(ctx) };
+  }
+
   // User profile + rules: injected ahead of the memory block because they are
   // always-relevant instructions the agent should follow every turn.
   // 渲染整体搬到 src/user-settings.js（与面板预览共用一份，见那里的模块头注释）。
@@ -333,7 +506,9 @@ export function createInjector(ctx, service, settings, config, gate = null, sess
   function renderUserSettings(ctx) {
     // factsInject 是 profile-facts 域的读口（index.js 接线，面板预览路由传同一份）：
     // 开关与事实有无的判定都在 renderUserSettingsBlock 内部，「关」等于零读数。
-    return renderUserSettingsBlock({ settings, config, agentId: sessionAgentId(ctx), factsProvider: factsInject }).text;
+    const { agentId, sessionId, parentSessionId } = sessionIdentity(ctx);
+    return renderUserSettingsBlock({ settings, config, agentId, sessionId, parentSessionId, factsProvider: factsInject })
+      .text;
   }
 
   // #249 能力说明的系统提示段。order 150 = 插件指引段的既有惯例
@@ -360,10 +535,12 @@ export function createInjector(ctx, service, settings, config, gate = null, sess
       text: (ctx) => {
         if (sessionGate?.isOff(sessionOf(ctx))) return "";
         // Bug4: pass the latest user query so injection prefers semantically
-        // relevant memories; lastUserQuery is best-effort (empty → legacy).
+        // relevant memories; liveStepQuery is best-effort (empty → legacy).
         // The query vector is prefetched asynchronously (cached) because the
         // render itself must stay synchronous.
-        const query = lastUserQuery(ctx);
+        // #617：liveStepQuery 而不是 lastUserQuery——宿主在 step 末尾才 append
+        // user/message，而注入在这之前求值，只看事件流会拿到上一轮的输入。
+        const query = liveStepQuery(ctx);
         if (query) prefetchQueryVector(query);
         const queryVector = queryVectorCache.get(query);
         // v0.8.0 A3：scope 随请求解析（解析器恒返回对象，身份取不到时两维为
@@ -458,6 +635,12 @@ export function createInjector(ctx, service, settings, config, gate = null, sess
   ];
 
   return () => {
+    // #617：认领票据是监听宿主事件的活句柄，卸载时必须成对摘掉，否则注入器重装
+    // （面板开关、宿主热重载）会留下一个继续写 Map 的孤儿监听。
+    offClaimed?.();
+    pendingQueries.clear();
+    inflightPrefetches.clear();
+    prefetchFailedAt.clear();
     queryVectorCache.clear();
     rotationHistory.clear();
     injectionSnapshot = null; // 注入器卸载即失效：快照不得跨生命周期存留