@max-null/dsh-memory 0.7.3 → 0.9.0

package/README.md

@@ -74,15 +74,20 @@ md 文件是唯一事实源（`~/.dsh/prompt-library/*.md` 为 global；`<worksp
 
 ```
 模型 memory_save     →  status: approved，立即生效；命中密钥/凭据规则则隔离（不进检索也不进注入）
+                        给 injected 则同时钉住常驻（0.8.0），不吃下面两条自动规则
 memory_search        →  关键词/语义召回（只搜记忆；模板走 prompt_search 通道，不会混进候选池）
 命中累计 2 次         →  injected: true（自动打开常驻：global + 当前会话工作区，摘要化 + 预算截断）
-30 天未再命中         →  自动撤下常驻（只撤自动开的；人工动过的开关双向豁免）
+30 天未再命中         →  自动撤下常驻（只撤自动开的；人工或模型显式动过的开关双向豁免）
 人（面板 / 开关）     →  钉住 / 删除 / 放行隔离记录 / 回滚
 memory_forget        →  随时删除（删除始终是人的动作）
 ```
 
 两条自动规则撑起淘汰机制：**反复被检索命中**是它值得每轮付费的证据，**长期不再被命中**则自动退出常驻。两者都不删除任何内容——记忆不会无限累积，也不会被系统自行清空。
 
+自动规则对**低频但关键**的记忆（长期约定、判据、委托）够不着：它们不会被反复检索，够不到阈值；勉强够到也会被 30 天撤下。这类走显式路径——在 `memory_save` / `memory_update` 里给 `injected` 即钉住，写的是与面板开关同一套语义（`injectedAuto: false`），此后不受两条自动规则影响。未审核与已隔离的记录不接受注入。
+
+注入有**字符预算**（默认 1500，config `injectionBudget`）：装不下的条目**整条丢弃**（不截内容），按「最近更新优先」取舍——所以 `injected: true` 不等于「每轮真的在场」，它只保证有资格排队。0.9.0 起这种出局不再无声：注入末尾会追加一行 `（另有 N 条常驻因预算未注入：id1, id2, …）`，**清理干净即自行消失**；面板的注入预览里也能展开看明细。诊断行本身不占预算。
+
 记忆还可声明**有效性锚点**（环境变量 / 工具清单 / 插件版本）：所绑的值变化后，这条记忆被标记 `stale` 并撤下常驻，检索结果里也带出失效提示——环境变了，旧结论就不再被当成仍然正确。
 
 模型写入不需要人点头，但**人始终能看见并推翻**：面板按「隔离区 / 常驻 / 冷数据」分组，被隔离的记录必须由人放行才会重新进入检索。

package/client.js

@@ -196,6 +196,9 @@ var STRINGS = {
     confirmAll: "\u5168\u90E8\u653E\u884C",
     injectPreview: "\u6CE8\u5165\u9884\u89C8",
     contextUsage: "\u4E0A\u4E0B\u6587\u5360\u7528",
+    injectionOmitted: "{count} \u6761\u5E38\u9A7B\u8BB0\u5FC6\u672A\u6CE8\u5165\uFF08\u5C55\u5F00\u67E5\u770B\uFF09",
+    budgetLabel: "\u9884\u7B97",
+    contextUsageDetail: "{self}+{injected} \u5B57\u7B26{budget} \u2248 {tokens} token",
     keywordsLabel: "\u5173\u952E\u8BCD",
     suggested: "\u9694\u79BB",
     approved: "\u5DF2\u751F\u6548",
@@ -249,6 +252,9 @@ var STRINGS = {
     confirmAll: "Release all",
     injectPreview: "Injection preview",
     contextUsage: "Context usage",
+    injectionOmitted: "{count} resident memories not injected (expand)",
+    budgetLabel: "budget",
+    contextUsageDetail: "{self}+{injected} chars{budget} \u2248 {tokens} token",
     keywordsLabel: "Keywords",
     suggested: "Quarantined",
     approved: "Active",
@@ -985,13 +991,23 @@ function MemoryView(props) {
             const selfChars = preview.self.length;
             const total = selfChars + preview.chars;
             const tokens = Math.ceil(total / 2);
-            const budgetText = preview.budget === null ? "" : ` / \u9884\u7B97 ${preview.budget}`;
-            const omittedText = preview.omitted > 0 ? `\uFF08\u7701\u7565 ${preview.omitted} \u6761\uFF09` : "";
-            return `${selfChars}+${preview.chars} \u5B57\u7B26${budgetText}${omittedText} \u2248 ${tokens} token`;
+            const budgetText = preview.budget === null ? "" : ` / ${t("budgetLabel")} ${preview.budget}`;
+            return t("contextUsageDetail", { self: selfChars, injected: preview.chars, budget: budgetText, tokens });
           })())
         ),
         (0, import_react.createElement)("div", { style: { ...ssid.text, fontSize: 11, whiteSpace: "pre-wrap", wordBreak: "break-all" } }, preview.self),
-        preview.lines.length === 0 ? (0, import_react.createElement)("div", { style: ssid.muted }, t("empty")) : preview.lines.map((line, index) => (0, import_react.createElement)("div", { key: index, style: { ...ssid.muted, fontSize: 11 } }, line))
+        preview.lines.length === 0 ? (0, import_react.createElement)("div", { style: ssid.muted }, t("empty")) : preview.lines.map((line, index) => (0, import_react.createElement)("div", { key: index, style: { ...ssid.muted, fontSize: 11 } }, line)),
+        // 预算诊断（2026-09-18）：被预算挡在外面的常驻记忆——展开可见 id 与摘要
+        preview.omittedRecords.length > 0 ? (0, import_react.createElement)(
+          "details",
+          { style: { ...ssid.muted, fontSize: 11 } },
+          (0, import_react.createElement)(
+            "summary",
+            { style: { cursor: "pointer" } },
+            t("injectionOmitted", { count: preview.omitted })
+          ),
+          preview.omittedRecords.map((record, index) => (0, import_react.createElement)("div", { key: index, style: { ...ssid.muted, fontSize: 11, marginTop: 4 } }, record.line))
+        ) : null
       ) : null,
       // 未选择工作区：工作区视图显示占位（0.3.4 工作区路由语义）
       namespace === "workspace" && (props.cwd === void 0 || props.cwd === "") ? (0, import_react.createElement)("div", { style: ssid.empty }, t("noWorkspace")) : listSection

package/dist/engine.d.ts

@@ -94,6 +94,12 @@ export interface MemoryWrite {
      * 失效。只用于「随环境变化的事实」（某工具版本下的行为、某环境变量决定的配置）。
      */
     anchor?: MemoryAnchor;
+    /**
+     * 常驻注入（可选，2026-09-18）：显式指定这条记忆是否每轮进上下文。**给值即接管**——
+     * 与 {@link MemoryEngine.setInjected} 同一套语义（写 `injectedAuto: false`，此后不受自动
+     * 升降影响）。省略则维持缺省行为：不注入，且**保留**「被反复命中即自动升常驻」的资格。
+     */
+    injected?: boolean;
 }
 export interface MemoryFilter {
     namespace?: MemoryNamespace;
@@ -104,6 +110,16 @@ export interface MemoryFilter {
     /** 记录类别过滤（0.6.0）；缺省不过滤（工具层显式传 kind='fact' 保持旧行为）。 */
     kind?: MemoryKind;
 }
+/** {@link MemoryEngine.update} 的补丁：省略的字段保持原值（`injected` 省略时连 `injectedAuto` 一起保持）。 */
+export interface MemoryPatch {
+    content?: string;
+    keywords?: string[];
+    /**
+     * 常驻注入（2026-09-18）：给值即接管，与 {@link MemoryEngine.setInjected} 同义（写
+     * `injectedAuto: false`，此后不受自动升降影响）；省略则保持原值。
+     */
+    injected?: boolean;
+}
 export interface MemoryHit {
     record: MemoryRecord;
     score: number;
@@ -426,21 +442,22 @@ export declare class MemoryEngine extends Service {
     /** {@link setStatus} 的实现体；必须经 `writeScope` 进入。 */
     private setStatusInner;
     /**
-     * 注入维度开关（0.3.0）：只改 injected，不动审核状态。供 UI 面板
-     * 「常驻注入」开关调用（remote.setInjected）。
+     * 注入维度开关（0.3.0）：只改 injected，不动审核状态。供 UI 面板「常驻注入」开关调用
+     * （remote.setInjected）。2026-09-18 起模型侧有等价路径——`memory_save` / `memory_update`
+     * 的 `injected` 参数，经 {@link remember} / {@link update} 写同一套 `injectedAuto: false`
+     * 语义。差异只在越界处理：本方法对隔离记录**抛错**（用户明确要开，该被告知），
+     * 而写入/更新路径**静默降级为不注入**（那是顺带设置，不该中断整次写入）。
      */
     setInjected(id: MemoryId, injected: boolean, projectCwd?: string): Promise<MemoryRecord>;
     /** {@link setInjected} 的实现体；必须经 `writeScope` 进入。 */
     private setInjectedInner;
     /**
-     * 修改一条记忆的内容/关键词（0.3.1 整理记忆用）。2026-09-15 起：改动**不再**
-     * 退回待审核——静默机制下记忆由系统与模型自行维护，更新即保持原有审核状态；
-     * `injected` 保留原值。若新内容命中危险规则则转为隔离（与写入路径同一判定）。
+     * 修改一条记忆的内容/关键词/注入位（0.3.1 整理记忆用）。2026-09-15 起：改动**不再**
+     * 退回待审核——静默机制下记忆由系统与模型自行维护，更新即保持原有审核状态。2026-09-18
+     * 起可改 `injected`：**省略则保留原值**（连 `injectedAuto` 一起不动），给值即接管。若新
+     * 内容命中危险规则则转为隔离（与写入路径同一判定），并连带撤下注入。
      */
-    update(id: MemoryId, patch: {
-        content?: string;
-        keywords?: string[];
-    }, projectCwd?: string): Promise<MemoryRecord>;
+    update(id: MemoryId, patch: MemoryPatch, projectCwd?: string): Promise<MemoryRecord>;
     /** {@link update} 的实现体；必须经 `writeScope` 进入。 */
     private updateInner;
     /**

package/dist/engine.js

@@ -417,13 +417,16 @@ export class MemoryEngine extends Service {
         const block = {
             namespace,
             status: verdict.quarantined ? 'suggested' : 'approved',
-            injected: false,
+            // 常驻注入（2026-09-18）：显式给值即接管；隔离内容一律不注入
+            injected: verdict.quarantined ? false : input.injected ?? false,
             content: input.content,
             keywords: (input.keywords ?? []).map(keyword => keyword.toLowerCase()),
             createdAt: now,
             updatedAt: now,
             // ⑧ 来源（2026-09-15）：缺省 'agent'——写入这条记忆的就是主模型
             source: input.source ?? 'agent',
+            // 显式指定注入即接管：此后既不被自动降级，也不被自动升级（同 setInjected，2026-09-18）
+            ...input.injected === undefined ? {} : { injectedAuto: false },
             // 有效性锚点（可选）：值变了这条记忆会被标 stale，不再被当成仍然正确
             ...input.anchor === undefined ? {} : { anchor: input.anchor },
             ...verdict.quarantined
@@ -980,8 +983,11 @@ export class MemoryEngine extends Service {
         throw new Error(`cannot set status of unknown memory '${id}'`);
     }
     /**
-     * 注入维度开关（0.3.0）：只改 injected，不动审核状态。供 UI 面板
-     * 「常驻注入」开关调用（remote.setInjected）。
+     * 注入维度开关（0.3.0）：只改 injected，不动审核状态。供 UI 面板「常驻注入」开关调用
+     * （remote.setInjected）。2026-09-18 起模型侧有等价路径——`memory_save` / `memory_update`
+     * 的 `injected` 参数，经 {@link remember} / {@link update} 写同一套 `injectedAuto: false`
+     * 语义。差异只在越界处理：本方法对隔离记录**抛错**（用户明确要开，该被告知），
+     * 而写入/更新路径**静默降级为不注入**（那是顺带设置，不该中断整次写入）。
      */
     async setInjected(id, injected, projectCwd) {
         return this.writeScope(projectCwd, () => this.setInjectedInner(id, injected, projectCwd));
@@ -1025,9 +1031,10 @@ export class MemoryEngine extends Service {
         return record;
     }
     /**
-     * 修改一条记忆的内容/关键词（0.3.1 整理记忆用）。2026-09-15 起：改动**不再**
-     * 退回待审核——静默机制下记忆由系统与模型自行维护，更新即保持原有审核状态；
-     * `injected` 保留原值。若新内容命中危险规则则转为隔离（与写入路径同一判定）。
+     * 修改一条记忆的内容/关键词/注入位（0.3.1 整理记忆用）。2026-09-15 起：改动**不再**
+     * 退回待审核——静默机制下记忆由系统与模型自行维护，更新即保持原有审核状态。2026-09-18
+     * 起可改 `injected`：**省略则保留原值**（连 `injectedAuto` 一起不动），给值即接管。若新
+     * 内容命中危险规则则转为隔离（与写入路径同一判定），并连带撤下注入。
      */
     async update(id, patch, projectCwd) {
         return this.writeScope(projectCwd, () => this.updateInner(id, patch, projectCwd));
@@ -1041,11 +1048,16 @@ export class MemoryEngine extends Service {
                 ? block.keywords
                 : patch.keywords.map(keyword => keyword.toLowerCase());
             const verdict = detectSensitive(content, ...keywords);
+            // 命中危险规则：退回 suggested（不注入）+ 隔离（不检索）双保险；否则保持原状态
+            const status = verdict.quarantined ? 'suggested' : normalized.status;
+            // 常驻注入（2026-09-18）：显式给值即接管；未审核或已隔离一律不注入（与自动升级同一门槛）
+            const injected = status === 'approved' ? patch.injected ?? normalized.injected : false;
             return {
                 ...block,
-                // 命中危险规则：退回 suggested（不注入）+ 隔离（不检索）双保险；否则保持原状态
-                status: verdict.quarantined ? 'suggested' : normalized.status,
-                injected: normalized.injected,
+                status,
+                injected,
+                // 显式改注入即视为有意决定：此后不受自动升降影响（省略时连 injectedAuto 一起保持）
+                ...patch.injected === undefined ? {} : { injectedAuto: false },
                 ...verdict.quarantined
                     ? { quarantined: true, ...verdict.reason === undefined ? {} : { quarantineReason: verdict.reason } }
                     : { quarantined: false, quarantineReason: undefined },
@@ -1054,13 +1066,22 @@ export class MemoryEngine extends Service {
                 updatedAt: Date.now(),
             };
         };
+        // 注入位变化单独发一条事件：客户端与面板据此刷新「常驻」列，只发 status 会漏掉它
+        const publish = (previous, updated) => {
+            const record = toRecord(id, updated);
+            this.ctx.emit('memory/changed', { operation: 'status', id, status: normalizeBlock(updated).status });
+            const wasInjected = normalizeBlock(previous).injected;
+            const isInjected = normalizeBlock(updated).injected;
+            if (isInjected !== wasInjected) {
+                this.ctx.emit('memory/changed', { operation: 'injected', id, injected: isInjected });
+            }
+            return record;
+        };
         const global = this.requireTable('global').get(id);
         if (global !== undefined) {
             const updated = applyPatch(global);
             await this.requireTable('global').put(id, updated);
-            const record = toRecord(id, updated);
-            this.ctx.emit('memory/changed', { operation: 'status', id, status: normalizeBlock(updated).status });
-            return record;
+            return publish(global, updated);
         }
         const project = await this.projectTableFor(projectCwd);
         if (project !== undefined) {
@@ -1068,9 +1089,7 @@ export class MemoryEngine extends Service {
             if (block !== undefined) {
                 const updated = applyPatch(block);
                 await project.put(id, updated);
-                const record = toRecord(id, updated);
-                this.ctx.emit('memory/changed', { operation: 'status', id, status: normalizeBlock(updated).status });
-                return record;
+                return publish(block, updated);
             }
         }
         throw new Error(`cannot update unknown memory '${id}'`);

package/dist/index.js

@@ -9,7 +9,7 @@ import { MemoryEngine } from "./engine.js";
 import { MemoryGateway } from "./remote.js";
 import { mountMemoryApi } from "./routes.js";
 import { SELF_DESCRIPTION } from "./self.js";
-import { DEFAULT_INJECTION_BUDGET, DEFAULT_SUMMARY_CHARS, renderInjection } from "./injection.js";
+import { DEFAULT_INJECTION_BUDGET, DEFAULT_SUMMARY_CHARS, omittedNotice, renderInjection } from "./injection.js";
 export { MemoryEngine } from "./engine.js";
 export { MemoryId } from "./engine.js";
 export { bm25FieldScores, bm25Scores, cosineSimilarity, rrfFuse, tokenize } from "./bm25.js";
@@ -112,11 +112,19 @@ const GUIDANCE = 'Use memory tools for cross-session preferences, habits, and pr
 // （0.3.4 起工作区记忆就按会话 cwd 路由；provider 是同步回调，只读已
 // 打开/缓存的表，未打开时本轮工作区部分为空，由 ensureProjectOpen 预热）。
 // 0.5.2：注入经摘要化 + 预算截断（renderInjection，纯函数）防上下文膨胀。
+// 0.9.0：装不下的条目不再是无声丢弃——末尾追加一行预算诊断（omittedNotice），
+// 报出被挡在外面的 id；它只在有出局时出现，清理干净即消失。
 function recallText(memory, projectCwd, budget, summaryChars) {
     const rendered = renderInjection(memory.recallRecords(projectCwd), budget, summaryChars);
-    if (rendered.lines.length === 0)
-        return '';
-    return `Remembered preferences and conventions — apply these:\n${rendered.lines.join('\n')}`;
+    const parts = [];
+    if (rendered.lines.length > 0) {
+        parts.push(`Remembered preferences and conventions — apply these:\n${rendered.lines.join('\n')}`);
+    }
+    // 全部出局（lines 为空）时诊断照出——那正是最该报的情形
+    const notice = omittedNotice(rendered);
+    if (notice !== '')
+        parts.push(notice);
+    return parts.join('\n');
 }
 /** 从组装上下文取当前 agent 会话的工作区 cwd（AssembleContext.agent 由 dsh-agent 声明合并提供）。 */
 function assemblyProjectCwd(assembly) {
@@ -213,6 +221,7 @@ export async function apply(ctx, config) {
             content: { type: 'string', required: true, description: 'Plaintext memory content.' },
             namespace: { type: 'string', enum: ['global', 'project'], description: 'Where it applies; defaults to global.' },
             keywords: { type: 'array', items: { type: 'string' }, description: 'Explicit searchable anchors for memory_search. Give several angles (synonyms, abbreviations, zh/en) or it will not be found later. 多角度关键词（同义词、缩写、中英），否则将来检索不到它。' },
+            injected: { type: 'boolean', description: 'Set true to make this memory resident in every turn\'s context, as a deliberate decision that no longer auto-expires. Reserve it for rules, standing agreements and judgement criteria — the kind that must apply even when nobody thinks to search for them. Facts, references and case notes stay search-only (omit it). 设为 true 让这条记忆每轮常驻上下文，且视为有意决定、不再被自动淘汰。只用于规则、长期约定与判据——那些「没人想起来搜也必须生效」的记忆；事实、参考与案例留作按需检索（省略即可）。' },
             anchor: {
                 type: 'object',
                 additionalProperties: false,
@@ -233,6 +242,7 @@ export async function apply(ctx, config) {
                 content: args.content,
                 ...args.namespace === undefined ? {} : { namespace: args.namespace },
                 ...args.keywords === undefined ? {} : { keywords: args.keywords },
+                ...args.injected === undefined ? {} : { injected: args.injected },
                 // 参数已由 tool schema 校验，这里的窄化只为过类型
                 ...args.anchor === undefined
                     ? {}
@@ -431,11 +441,12 @@ export async function apply(ctx, config) {
     }));
     ctx.tools.register(defineTool({
         name: 'memory_update',
-        description: 'Update the content or keywords of one stored memory (e.g. correcting stale facts). The record keeps its review status and injection switch; content that looks like a credential quarantines it instead. 修改一条记忆的内容或关键词（如修正过时信息）。改动后记忆保持原有审核状态与注入开关；若新内容命中危险规则则转为隔离。',
+        description: 'Update the content, keywords or persistent-injection switch of one stored memory (e.g. correcting stale facts). The record keeps its review status; content that looks like a credential quarantines it instead. 修改一条记忆的内容、关键词或常驻注入开关（如修正过时信息）。改动后记忆保持原有审核状态；若新内容命中危险规则则转为隔离。',
         parameters: {
             id: { type: 'string', required: true, description: 'Exact memory id from memory_list. 记忆 id（来自 memory_list）.' },
             content: { type: 'string', description: 'New content; omit to keep current. 新内容；省略则保留现有内容.' },
             keywords: { type: 'array', items: { type: 'string' }, description: 'New keywords; omit to keep current. 新关键词；省略则保留现有.' },
+            injected: { type: 'boolean', description: 'Set or clear the persistent-injection switch; omit to keep the current value. Setting it records a deliberate decision — the memory stops being auto-promoted or auto-demoted. See memory_save for what deserves residency. 设置或清除常驻注入开关；省略则保持原值。给值即视为有意决定——此后不受自动升降影响。何时该常驻见 memory_save。' },
         },
         output: {
             schema: RECORD_SCHEMA,
@@ -445,6 +456,7 @@ export async function apply(ctx, config) {
             return memory.update(args.id, {
                 ...args.content === undefined ? {} : { content: args.content },
                 ...args.keywords === undefined ? {} : { keywords: args.keywords },
+                ...args.injected === undefined ? {} : { injected: args.injected },
             }, execProjectCwd(exec)).then(recordValue);
         },
         presentCall: args => present('Update memory', 'other', args.id),

package/dist/injection.d.ts

@@ -2,13 +2,15 @@
  * 注入渲染（0.5.2）：`memory:recall` 与面板「注入预览」共用的确定性
  * 渲染——摘要化 + 预算截断。纯函数、无模型调用：注入行 = 每条记忆的
  * 单行摘要（内容过长取首行截断），超出预算（字符数）时按「最近更新
- * 优先」贪心保留，省略计数返回给 UI 提示。
+ * 优先」贪心保留；省略明细返回给面板与预算诊断（2026-09-18）。
  */
 import type { MemoryRecord } from './engine.ts';
 /** 摘要截断上限（字符）：中英混合场景下 ~40-60 token。 */
 export declare const DEFAULT_SUMMARY_CHARS = 80;
 /** 注入预算（字符）：0.5.2 起默认开启，防常驻注入随记忆增长膨胀上下文。 */
 export declare const DEFAULT_INJECTION_BUDGET = 1500;
+/** 诊断行列出的 id 上限（2026-09-18）：超出只列前 N 个，防这行本身失控。 */
+export declare const OMITTED_ID_LIMIT = 12;
 /**
  * 确定性摘要：取首行，超过 maxChars 截断加省略号。
  * 空内容/空首行回退为去掉换行后的前 maxChars（保证 any 内容有摘要）。
@@ -23,7 +25,16 @@ export interface InjectionRender {
     budget: number | null;
     /** 因预算被省略的候选条数（0 = 全部注入）。 */
     omitted: number;
-    /** 实际注入的字符数（摘要 + 标记开销之和）。 */
+    /**
+     * 被省略条目的明细：`id` 供预算诊断行与后续清理定位，`line` 与 {@link lines}
+     * 同格式，供面板明细直接渲染。诊断行**不占预算**——它由 `recallText` 追加在
+     * 注入行之后，不参与这里的截断。
+     */
+    omittedRecords: Array<{
+        id: string;
+        line: string;
+    }>;
+    /** 实际注入的字符数（摘要 + 标记开销之和；不含 {@link omittedRecords}）。 */
     chars: number;
 }
 /**
@@ -32,3 +43,9 @@ export interface InjectionRender {
  * 预算为 null 或非正数时全量注入（不过滤）。
  */
 export declare function renderInjection(records: readonly MemoryRecord[], budget: number | null, summaryChars: number): InjectionRender;
+/**
+ * 预算诊断行（2026-09-18）：列 id 而非摘要——列全文要约 4000 字符，id 列表约
+ * 100 字符。**不占注入预算**（调用方把它追加在注入行之后），清理干净后自行消失
+ * （`omitted === 0` 返回空串）；超出 {@link OMITTED_ID_LIMIT} 只列前 N 个。
+ */
+export declare function omittedNotice(rendered: InjectionRender): string;

package/dist/injection.js

@@ -2,12 +2,14 @@
  * 注入渲染（0.5.2）：`memory:recall` 与面板「注入预览」共用的确定性
  * 渲染——摘要化 + 预算截断。纯函数、无模型调用：注入行 = 每条记忆的
  * 单行摘要（内容过长取首行截断），超出预算（字符数）时按「最近更新
- * 优先」贪心保留，省略计数返回给 UI 提示。
+ * 优先」贪心保留；省略明细返回给面板与预算诊断（2026-09-18）。
  */
 /** 摘要截断上限（字符）：中英混合场景下 ~40-60 token。 */
 export const DEFAULT_SUMMARY_CHARS = 80;
 /** 注入预算（字符）：0.5.2 起默认开启，防常驻注入随记忆增长膨胀上下文。 */
 export const DEFAULT_INJECTION_BUDGET = 1500;
+/** 诊断行列出的 id 上限（2026-09-18）：超出只列前 N 个，防这行本身失控。 */
+export const OMITTED_ID_LIMIT = 12;
 /** 单条注入行的固定标记开销（不含摘要本体）。 */
 const LINE_OVERHEAD = 27;
 /**
@@ -36,6 +38,7 @@ export function injectionLine(record, summaryChars) {
 export function renderInjection(records, budget, summaryChars) {
     const ordered = [...records].sort((left, right) => (right.lastUsedAt ?? right.updatedAt) - (left.lastUsedAt ?? left.updatedAt));
     const lines = [];
+    const omittedRecords = [];
     let chars = 0;
     let omitted = 0;
     for (const record of ordered) {
@@ -43,10 +46,24 @@ export function renderInjection(records, budget, summaryChars) {
         const cost = text.length + LINE_OVERHEAD;
         if (budget !== null && budget > 0 && chars + cost > budget) {
             omitted++;
+            omittedRecords.push({ id: String(record.id), line: text });
             continue;
         }
         lines.push(text);
         chars += cost;
     }
-    return { lines, budget: budget ?? null, omitted, chars };
+    return { lines, budget: budget ?? null, omitted, omittedRecords, chars };
+}
+/**
+ * 预算诊断行（2026-09-18）：列 id 而非摘要——列全文要约 4000 字符，id 列表约
+ * 100 字符。**不占注入预算**（调用方把它追加在注入行之后），清理干净后自行消失
+ * （`omitted === 0` 返回空串）；超出 {@link OMITTED_ID_LIMIT} 只列前 N 个。
+ */
+export function omittedNotice(rendered) {
+    if (rendered.omitted === 0)
+        return '';
+    const ids = rendered.omittedRecords.map(record => String(record.id).slice(0, 8));
+    const shown = ids.slice(0, OMITTED_ID_LIMIT);
+    const truncated = ids.length > shown.length ? '…' : '';
+    return `（另有 ${rendered.omitted} 条常驻因预算未注入：${shown.join(', ')}${truncated}）`;
 }

package/dist/remote.d.ts

@@ -31,13 +31,18 @@ export declare class MemoryGateway extends TypertRemoteService {
     /**
      * 注入预览（0.3.5 + 0.5.2）：开发者查看当前注入到 system prompt 的记忆
      * 内容——self 自述 + 当前会话工作区（cwd）的 approved+injected 记忆，
-     * 经摘要化 + 预算截断（与 memory:recall 同源渲染）。
+     * 经摘要化 + 预算截断（与 memory:recall 同源渲染）。`omittedRecords`
+     * （2026-09-18）供面板展开「哪些常驻没进上下文」。
      */
     injectionPreview(cwd?: string, budget?: number | null, summaryChars?: number): Promise<{
         self: string;
         lines: string[];
         budget: number | null;
         omitted: number;
+        omittedRecords: Array<{
+            id: string;
+            line: string;
+        }>;
         chars: number;
     }>;
 }

package/dist/remote.js

@@ -112,7 +112,8 @@ let MemoryGateway = (() => {
         /**
          * 注入预览（0.3.5 + 0.5.2）：开发者查看当前注入到 system prompt 的记忆
          * 内容——self 自述 + 当前会话工作区（cwd）的 approved+injected 记忆，
-         * 经摘要化 + 预算截断（与 memory:recall 同源渲染）。
+         * 经摘要化 + 预算截断（与 memory:recall 同源渲染）。`omittedRecords`
+         * （2026-09-18）供面板展开「哪些常驻没进上下文」。
          */
         async injectionPreview(cwd, budget, summaryChars) {
             if (cwd !== undefined)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@max-null/dsh-memory",
-  "version": "0.7.3",
+  "version": "0.9.0",
   "description": "Cross-session plaintext memory plugin for the DeepSeek Harness — deterministic BM25 recall, writes take effect immediately, signal-driven injection, no embeddings",
   "license": "MIT",
   "publishConfig": {