@modusensus/dsh-mneme 0.9.3 → 0.9.4

package/lib/tools.js

@@ -677,6 +677,241 @@ export function createTools(ctx, service, config, embedder) {
       }
     }),
 
+    // #231 第二批：agent 主动整理接口的调用入口。引擎在 src/organize.js（PR #267），
+    // 当时刻意「不进工具列表、不加独立 opt-in 开关——#249 到位时只差注册工具一步」，
+    // 本条就是那一步。工具描述是 agent 侧唯一的协议说明，所以两步规则（apply 必须带
+    // 真实 run_id、筛除=discard 不删任何东西、archive 可恢复）都写在这里：本体已经
+    // 强制了这些，描述的作用是让第一次调用就成功，而不是靠被拒后试错。
+    defineTool({
+      name: "memory_organize",
+      description:
+        "Close out a stretch of work: compare candidate memories against the store first, then land only what you decide to keep. " +
+        "Two steps through one tool. mode=dryRun (default) takes `candidates` and answers one verdict per candidate — exact / near / new — with the " +
+        "matched row when there is one; it writes NO memories, only an audit receipt. mode=apply takes that report's `run_id` plus one decision per " +
+        "candidate (save | discard) and may archive a row the report flagged as superseded (action=archive with that matched id). " +
+        "apply is rejected without a real run_id, and a report can be applied only once: candidates that were never compared cannot be written, and " +
+        "a row the report never matched cannot be archived. Discard keeps a candidate out and deletes nothing; archive is recoverable and never " +
+        "physically removes a row. This tool exists only when organizeEnabled is on (off by default, and off in lightweight mode) — if it is missing " +
+        "from your tool list the user has not enabled it. For a single write use memory_save instead.",
+      parameters: {
+        mode: { type: "string", description: '"dryRun" (default: compare and report, writes nothing) or "apply" (land the decisions of a reported dryRun)' },
+        candidates: {
+          type: "array",
+          // 宿主强制的 JSON Schema 子集要求 object 显式声明 additionalProperties，
+          // 所以候选字段在这里逐键写死：scope **来源**两列（*_scope_source）故意不给
+          // ——那是可信调用层盖的章，不是模型可自选的内容。
+          items: {
+            type: "object",
+            additionalProperties: false,
+            properties: {
+              type: { type: "string", required: true, description: "Memory type (project / preference / constraint / ... ; 'document' is rejected here — it is minted by memory_register_document)" },
+              title: { type: "string", required: true, description: "Short stable title — part of the dedupe key (type + title + scope)" },
+              content: { type: "string", required: true, description: "The body that would be stored" },
+              importance: { type: "integer", description: "1-5 (default 3)" },
+              tags: { type: "array", items: { type: "string" }, description: "Optional tags" },
+              sensitivity: { type: "string", description: "Optional per-candidate sensitivity, overriding the payload-level default" },
+              agent_scope: { type: "string", description: "Optional per-candidate agent scope, overriding the payload-level default" },
+              workspace_scope: { type: "string", description: "Optional per-candidate workspace scope, overriding the payload-level default" }
+            }
+          },
+          description: "dryRun only: candidates to compare (hard cap 50 per call — this is for closing out a work stretch, not bulk import). Candidates missing type/title/content, or of type document, come back in `skipped`."
+        },
+        run_id: { type: "string", description: "apply only: the run_id returned by the dryRun report you are acting on" },
+        decisions: {
+          type: "array",
+          items: {
+            type: "object",
+            additionalProperties: false,
+            properties: {
+              action: { type: "string", required: true, enum: ["save", "discard", "archive"], description: 'save writes the candidate at `index` through the normal dedupe path (an existing row with the same key is merged, not duplicated); discard keeps it out and deletes nothing; archive hides the row at `id` (recoverable, and only legal for a row this report matched)' },
+              index: { type: "integer", description: "save | discard: the candidate index from the dryRun report" },
+              id: { type: "string", description: "archive: id of the matched row to archive" }
+            }
+          },
+          description: "apply only: one entry per candidate you judged. Entries whose index the dryRun never accepted are reported in `skipped`."
+        },
+        sensitivity: { type: "string", description: "dryRun only: payload-level default sensitivity label for candidates that do not set their own (also the scope dimension the comparison runs within)" },
+        agent_scope: { type: "string", description: "dryRun only: payload-level default agent scope for candidates that do not set their own. 'global' or '*' widens visibility to every agent; any other value narrows it. Defaults to this session's auto-stamped agent label when scope labeling is on (same rule as memory_save)." },
+        workspace_scope: { type: "string", description: "dryRun only: payload-level default workspace scope for candidates that do not set their own. 'global' or '*' widens visibility to every workspace; any other value narrows it. Defaults to this session's auto-stamped workspace label when scope labeling is on." }
+      },
+      output: {
+        schema: {
+          type: "object",
+          additionalProperties: false,
+          properties: {
+            // mode 是判别键：两种分支的返回键集不同，渲染与调用方都要靠它分流。
+            mode: { type: "string", required: true, enum: ["dryRun", "apply"] },
+            run_id: { type: "string", required: true },
+            status: { type: "string", required: true },
+            skipped: {
+              type: "array",
+              required: true,
+              items: {
+                type: "object",
+                additionalProperties: false,
+                properties: {
+                  index: { type: "integer", required: true },
+                  action: { type: "string" },
+                  error: { type: "string", required: true },
+                  ids: { type: "array", items: { type: "string" } }
+                }
+              }
+            },
+            // --- dryRun 分支 ---
+            created_at: { type: "string" },
+            counts: {
+              type: "object",
+              additionalProperties: false,
+              properties: {
+                total: { type: "integer", required: true },
+                exact: { type: "integer", required: true },
+                near: { type: "integer", required: true },
+                new: { type: "integer", required: true },
+                skipped: { type: "integer", required: true },
+                truncated: { type: "integer", required: true }
+              }
+            },
+            items: {
+              type: "array",
+              items: {
+                type: "object",
+                additionalProperties: false,
+                properties: {
+                  index: { type: "integer", required: true },
+                  type: { type: "string", required: true },
+                  title: { type: "string", required: true },
+                  verdict: { type: "string", required: true, enum: ["exact", "near", "new"] },
+                  // match.sim 只在向量档命中时出现（exact 档无相似度可报）；
+                  // 归档目标必须是报告里出现过的 id，所以这条链接就是 archive 的凭据。
+                  match: {
+                    type: "object",
+                    additionalProperties: false,
+                    properties: {
+                      id: { type: "string", required: true },
+                      title: { type: "string", required: true },
+                      sim: { type: "number" }
+                    }
+                  }
+                }
+              }
+            },
+            // --- apply 分支 ---
+            dry_run_id: { type: "string" },
+            saved: { type: "integer" },
+            merged: { type: "integer" },
+            discarded: { type: "integer" },
+            archived: { type: "integer" },
+            memory_ids: { type: "array", items: { type: "string" } },
+            degraded: { type: "boolean" }
+          }
+        },
+        render: (_args, value) => {
+          if (value.mode === "apply") {
+            return TEXT_OUTPUT(
+              `organize applied (${value.run_id}, report ${value.dry_run_id}): ${value.saved} saved, ${value.merged} merged, ` +
+              `${value.archived} archived, ${value.discarded} discarded${value.skipped.length ? ` | ${value.skipped.length} skipped` : ""}.`
+            );
+          }
+          const c = value.counts;
+          return TEXT_OUTPUT(
+            `organize dryRun ${value.run_id}: ${c.total} compared — ${c.new} new, ${c.exact} exact, ${c.near} near` +
+            `${c.skipped ? `, ${c.skipped} rejected` : ""}${c.truncated ? `, ${c.truncated} over the cap not compared` : ""}. ` +
+            `Nothing was written; pass this run_id with your decisions to memory_organize mode=apply.`
+          );
+        }
+      },
+      async execute(args, exec) {
+        const mode = String(args?.mode ?? "dryRun").trim();
+        const scope = resolveSessionScope(exec);
+        const autoStamping = config?.scopeEnabled === true;
+        // 载荷级缺省与 memory_save 同源：显式参数盖 explicit 章，否则吃会话自动标注
+        // 盖 auto 章。少了这一步，整理接口就成了第二条「写进库却不带 scope」的通道
+        // ——candidates 会全部落在未标注（全局可见）那一档。
+        const agentLabel = args.agent_scope !== undefined
+          ? { value: normalizeExplicitScope(args.agent_scope), source: "explicit" }
+          : autoStamping && scope ? { value: scope.agent_scope, source: "auto" } : null;
+        const workspaceLabel = args.workspace_scope !== undefined
+          ? { value: normalizeExplicitScope(args.workspace_scope), source: "explicit" }
+          : autoStamping && scope ? { value: scope.workspace_scope, source: "auto" } : null;
+        const hiddenIds = [];
+        if (mode === "apply" && config?.strictScope === true && scope && Array.isArray(args.decisions)) {
+          // #170 复核项 4 的口径延伸（register_document 的 hiddenEvidenceIds 同形）：
+          // 他 scope 的 explicit 行按「不存在」处理，由**可信调用层**算好传入，绝不
+          // 取 payload 里的字段——那是调用方可自选的内容，不是授权。少了这一段，
+          // archive 就成了第二条绕过 scope 治理的改库通道。
+          for (const decision of args.decisions) {
+            if (String(decision?.action ?? "").trim() !== "archive") continue;
+            const id = String(decision?.id ?? "").trim();
+            if (!id) continue;
+            const row = service.getById(id);
+            if (row && !service.isVisibleInScope(row, scope)) hiddenIds.push(id);
+          }
+        }
+        const result = await service.organize(
+          {
+            mode,
+            ...(args.candidates !== undefined ? { candidates: args.candidates } : {}),
+            ...(args.run_id !== undefined ? { run_id: args.run_id } : {}),
+            ...(args.decisions !== undefined ? { decisions: args.decisions } : {}),
+            ...(args.sensitivity !== undefined ? { sensitivity: args.sensitivity } : {}),
+            ...(agentLabel ? { agent_scope: agentLabel.value, agent_scope_source: agentLabel.source } : {}),
+            ...(workspaceLabel ? { workspace_scope: workspaceLabel.value, workspace_scope_source: workspaceLabel.source } : {})
+          },
+          { hiddenIds }
+        );
+        if (mode === "apply") {
+          return {
+            mode: "apply",
+            run_id: result.run_id,
+            dry_run_id: result.dry_run_id,
+            status: result.status,
+            saved: result.saved,
+            merged: result.merged,
+            discarded: result.discarded,
+            archived: result.archived,
+            memory_ids: result.memory_ids,
+            skipped: result.skipped,
+            degraded: result.degraded
+          };
+        }
+        // dryRun 的落点必须过一遍调用方的可见性。`agent_scope` / `workspace_scope`
+        // 是模型自己给的参数，而 `organize.dryRun` 的比对只看三列**值**（不看
+        // `*_scope_source`、不调 `isVisibleInScope`）——不过这一关，dryRun 就成了
+        // 「那一档有没有这个标题」的探测口：#170 复核项 4 给 memory_get / memory_delete
+        // 的口径是「不存在」，这里也按不存在说，落点一个键都不带。
+        // counts 跟着重算：留着引擎那份计数，`exact: 1` 配一个不带 match 的条目本身就是
+        // 存在性oracle，等于把泄露从 id 挪到计数器。审计行仍存原始落点（那是给操作者看的
+        // 证据面），apply 侧另有 hiddenIds 挡归档。
+        const visibleItems = result.items.map((item) => {
+          const match = item.match && visibleUnderStrictScope(service.getById(item.match.id), exec) ? item.match : null;
+          return {
+            index: item.index,
+            type: item.type,
+            title: item.title,
+            verdict: match ? item.verdict : "new",
+            ...(match ? { match: { id: match.id, title: match.title, ...(match.sim != null ? { sim: match.sim } : {}) } } : {})
+          };
+        });
+        const verdictCount = (verdict) => visibleItems.filter((i) => i.verdict === verdict).length;
+        return {
+          mode: "dryRun",
+          run_id: result.run_id,
+          created_at: result.created_at,
+          status: result.status,
+          counts: {
+            total: visibleItems.length,
+            exact: verdictCount("exact"),
+            near: verdictCount("near"),
+            new: verdictCount("new"),
+            skipped: result.counts.skipped,
+            truncated: result.counts.truncated
+          },
+          items: visibleItems,
+          skipped: result.skipped
+        };
+      }
+    }),
+
     // 运行时口子（issue #131 / PR-C）。
     //
     // 为什么要有这个工具：mneme 的取向是「本体保持完善但轻量；重的功能存在、默认不开、不被依赖」。
@@ -805,10 +1040,14 @@ export function createTools(ctx, service, config, embedder) {
   const hiddenTools = new Set();
   if (config?.disableMemorySearch === true) hiddenTools.add("memory_search");
   if (config?.disableMemoryArchive === true) hiddenTools.add("memory_archive");
+  // #231 第二批是**反向**语义：memory_organize 默认不在场，organizeEnabled 打开才
+  // 注册。仍走同一个闸门而不是在数组里条件展开——模型看不到就不会调，这比在描述里
+  // 劝它别用可靠（上面那段 v0.8.5 的定性对两个方向都成立）。
+  if (config?.organizeEnabled !== true) hiddenTools.add("memory_organize");
 
   for (const tool of tools) {
     if (hiddenTools.has(tool.name)) {
-      ctx.logger?.info?.(`[dsh-mneme] tool "${tool.name}" hidden by config (disableMemorySearch/disableMemoryArchive)`);
+      ctx.logger?.info?.(`[dsh-mneme] tool "${tool.name}" hidden by config (disableMemorySearch/disableMemoryArchive/organizeEnabled)`);
       continue;
     }
     if (registeredTools.has(tool.name)) {

package/lib/user-settings.js

@@ -0,0 +1,78 @@
+// dsh-mneme/src/user-settings.js
+// 「用户设置」注入块（人格 / 画像 / 规则）的唯一渲染处。
+//
+// 为什么要单独成模块：面板「Agent 眼中的画像」那张卡原本自己在前端拼了一份 profile +
+// rules 的列表，注释写着「注入生效文本」——但它没有表头、没有「- 用户画像：」前缀，
+// 也完全没有人格三行。两处渲染代码各写各的，就一定会漂；而漂了没人报错，因为两边都
+// 「看着像」。现在注入器与预览路由调同一个函数，前端只显示后端给的文本。
+//
+// 顺序是设计口径（人格设计稿⑥）：特化指令（人格）先出，画像与规则后出、后写覆盖占
+// 上风，rules 恒最硬。改这个顺序等于改提示词权重，别顺手调。
+
+import { STR, langOf } from "./lang.js";
+
+/**
+ * 提示词变量转义：宿主模板插值对 `{{`/`}}` 会按变量名解析并在缺失时抛错，整轮崩掉。
+ * 所以把 2 个以上连续花括号逐字符插 `\`，让任何 `{{`/`}}` 子串都不残留；转换幂等，
+ * 单花括号原样通过。`config.escapePromptVariables === false` 时退回原文。
+ *
+ * 住在这里是刻意的：预览必须与注入共用同一个转义，否则「同源」又是假的。
+ * `src/inject.js` 的同名闭包函数只是薄薄一层委托，其余调用点不动。
+ */
+export function escapePromptVars(config, text) {
+  if (config?.escapePromptVariables === false) return String(text);
+  return String(text).replace(/[{}]{2,}/g, (run) => run.split("").join("\\"));
+}
+
+/**
+ * 按会话身份取人格卡。返回 `{ card, source }`，`source` 是给面板解释「用的哪张卡」的
+ * 读数，不参与判定。
+ *
+ * `strict`（config.personaStrictAddressing，默认关）决定「有身份、没这张身份的卡」
+ * 与「这张卡被显式关掉」这两种情况：
+ * - 关（现状）：落 default 卡。default 于是变成「所有没建卡的 agent 都能拿到它」，
+ *   包括宿主里跑的外部 bot——它自带身份与设定，两处「你是谁」撞在同一帧里。
+ * - 开：不注入人格（`source: "none"`）。default 退回它的本意：只兜「这一帧解析不到
+ *   身份」的会话（无名会话本来就是 default 卡的受众）。
+ * 默认关是有意的：这是一次口径变更，不能让老用户的注入文本在升级后静默变化。
+ */
+export function resolvePersonaCard(settings, agentId, { strict = false } = {}) {
+  const store = settings.getPersona();
+  const id = typeof agentId === "string" && agentId.trim() ? agentId.trim() : "";
+  const card = id ? store.byAgent[id] : null;
+  if (card && card.enabled === true) return { card, source: "byAgent" };
+  if (id && strict) return { card: {}, source: "none" };
+  return { card: store.default, source: "default" };
+}
+
+/**
+ * 渲染整块「用户设置」。`agentId` 是会话身份（解析不到传 null → 走 default 兜底）。
+ * 返回 `{ text, source, agent, configGate }`：`text` 为最终注入文本（全空时 ""），
+ * `configGate` 是 personaEnabled 的现值——面板要靠它解释「卡开着为什么没生效」。
+ */
+export function renderUserSettingsBlock({ settings, config, agentId = null }) {
+  const language = langOf(config);
+  const profile = settings.getProfile().trim();
+  const rules = settings.getRules();
+  const enabled = config?.personaEnabled === true;
+  const resolved = enabled
+    ? resolvePersonaCard(settings, agentId, { strict: config?.personaStrictAddressing === true })
+    : { card: {}, source: "default" };
+  const persona = resolved.card;
+  const personaLines = persona?.enabled === true
+    ? [
+        ...(typeof persona.name === "string" && persona.name.trim() ? [STR.personaNameLine[language](persona.name.trim())] : []),
+        ...(typeof persona.personality === "string" && persona.personality.trim() ? [STR.personaPersonalityLine[language](persona.personality.trim())] : []),
+        ...(typeof persona.replyStyle === "string" && persona.replyStyle.trim() ? [STR.personaReplyStyleLine[language](persona.replyStyle.trim())] : [])
+      ]
+    : [];
+  const id = typeof agentId === "string" && agentId.trim() ? agentId.trim() : null;
+  if (!profile && !rules.length && !personaLines.length) {
+    return { text: "", source: resolved.source, agent: id, configGate: enabled };
+  }
+  const lines = [STR.userSettingsHeader[language]];
+  lines.push(...personaLines);
+  if (profile) lines.push(STR.profileLine[language](profile));
+  for (const rule of rules) lines.push(STR.ruleLine[language](rule));
+  return { text: escapePromptVars(config, lines.join("\n")), source: resolved.source, agent: id, configGate: enabled };
+}

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@modusensus/dsh-mneme",
   "description": "Cross-session memory plugin for DeepSeek Harness with autoDream consolidation: SQLite store, Markdown mirrors, 10 model tools, automatic injection, session summarization, user profile/rules, custom slash commands, vector (semantic) search, and a Web GUI panel",
-  "version": "0.9.3",
+  "version": "0.9.4",
   "license": "MIT",
   "repository": {
     "type": "git",

package/src/api.js

@@ -9,6 +9,7 @@ import { langOf } from "./lang.js";
 import { computeHeat } from "./heat.js";
 import { EFFORT_REJECT_RE, describeStreamFailure, resolveRoute, withEffortFallback } from "./dream.js";
 import { getInjectionSnapshot } from "./inject.js";
+import { renderUserSettingsBlock } from "./user-settings.js";
 import { describeLocalRuntime, publicRuntimeStatus } from "./runtime/loader.js";
 import { hostModulesDir, provisionRuntime } from "./runtime/provision.js";
 import { classify, fetchLatestVersion, PACKAGE_VERSION } from "./version-check.js";
@@ -182,7 +183,7 @@ function parseBody(text) {
 // maintenance 是第 9 个位置参数，默认 null：既有调用点（测试里的 14 处）全是位置传参、
 // 不传它，必须继续工作——不传时 /maintenance/reclaim 回 503 maintenance-unavailable，
 // 而不是把「没接线」伪装成崩溃（#386 第 4 条）。
-export function createApi(ctx, service, settings, commands, embedder, semantic = null, apiToken = "", config = null, maintenance = null) {
+export function createApi(ctx, service, settings, commands, embedder, semantic = null, apiToken = "", config = null, maintenance = null, profileExtract = null) {
   const disposers = [];
 
   // #182 注入状态探测：面板状态页的「极简模式下注入按宿主设计关闭」提示需要
@@ -488,6 +489,49 @@ export function createApi(ctx, service, settings, commands, embedder, semantic =
     }
   });
 
+  // --- 画像提取（issue #497）：一次性从活跃记忆出「助手眼中的用户」**草稿** ------
+  // 语义上它是「读 + 一次模型调用」，不是写端点：草稿回给面板，采用与否是用户在那里
+  // 另一次显式 PUT /profile。所以这个路由永远不碰 user_settings——画像正文是用户
+  // 手写的原文，让模型合并等于给它改写权，而改写后的文本每帧都注入。
+  register({
+    kind: "exact",
+    path: "/api/dsh-mneme/profile/extract",
+    // policy 是 `token` 而不是 `token-write`：这条路由**没有读分支**（非 POST 一律 405），
+    // 声明成 token-write 会让 SECURITY.md 的开放读清单按「GET 开放」把它算进去——
+    // 那张表是代码的投影，不是愿望清单（test/security-doc.test.js 就是钉这件事的）。
+    policy: "token",
+    handler(req, res) {
+      // 方法白名单在碰任何副作用之前：#489 的教训是「只拦 POST/PUT，其余直落
+      // run(null)」——那等于给带 token 的 PATCH/DELETE 开了一条静默花一次 LLM 的口子。
+      // 顺序也要紧：405 若挪到 readBody 之后，一个不带 body 的方法会把请求永远挂在
+      // 读体上（把这道判断改成只拦 GET 时实测卡住整条用例），等于一个免费的挂起面。
+      if (req.method !== "POST") {
+        res.writeHead(405, { Allow: "POST" });
+        res.end("");
+        return undefined;
+      }
+      if (config?.profileExtractEnabled !== true) return sendJson(res, 409, { error: "disabled" });
+      if (typeof profileExtract !== "function") return sendJson(res, 503, { error: "unavailable" });
+      return readBody(req, res).then((text) => {
+        if (text === null) return undefined; // 超限已在 readBody 里回过 413
+        return profileExtract().then(
+          (out) => sendJson(res, 200, out),
+          (error) => {
+            // 「没东西可提」与「模型没配合」必须能被调用方区分：把它们都压成 200 +
+            // 空草稿，面板就会把故障显示成「这次没提炼出东西」（#493 同一条教训）。
+            const code = typeof error?.code === "string" ? error.code : "";
+            if (code === "no-input") return sendJson(res, 409, { error: code });
+            // 没配模型是「环境缺东西」，与「模型不配合」两码：前者重跑也一样，后者可重试。
+            if (code === "no-route") return sendJson(res, 503, { error: code });
+            if (code === "unparseable" || code === "stream-failed") return sendJson(res, 502, { error: code });
+            ctx.logger?.warn?.(`dsh-mneme: profile extract failed: ${String(error?.message ?? error)}`);
+            return sendJson(res, 500, { error: "internal" });
+          }
+        );
+      });
+    }
+  });
+
   // --- agent persona（人格定义页，beta） -------------------------------------
   // 形状照抄 /profile 路由（设计稿②）：写方法走 requireAuth + readBody + parseBody。
   // v1.2 多卡：GET 回全量 { default, byAgent }；PUT 双形——单对象形（旧面板）只更新
@@ -519,7 +563,20 @@ export function createApi(ctx, service, settings, commands, embedder, semantic =
             sendJson(res, 200, { persona: settings.getPersona() });
           });
         }
-        sendJson(res, 200, { persona: settings.getPersona() });
+        const url = new URL(req.url, "http://localhost");
+        // 预览（面板「Agent 眼中的画像」用）：由注入器同一个渲染函数产出，前端只显示
+        // 返回的文本——以前端自己拼列表冒充「生效文本」是这个面板最容易漂的地方。
+        // ?agent=<身份> 让面板能逐张卡预览：传了就按那个身份寻址，没传按「解析不到身份」
+        // 走（也就是 default 卡的受众）。
+        // 这里不加鉴权是有意的：画像、规则、人格三处在同一条开放读面上本来就能各读一次
+        // （GET /profile 与 GET /persona 都无 token 可读），本字段只是把同样的内容拼成
+        // 模型实际看到的形状，没有新增可达面；真要锁，配 apiToken（写面与它同源）。
+        const preview = renderUserSettingsBlock({
+          settings,
+          config,
+          agentId: url.searchParams.get("agent")
+        });
+        sendJson(res, 200, { persona: settings.getPersona(), preview });
       } catch {
         sendJson(res, 500, { error: "internal" });
       }

package/src/config.js

@@ -35,6 +35,14 @@ export const Config = z.object({
   // 额度浪费在零成本窗口上。计数是进程内 per-session（与最小间隔闸门同生命
   // 周期），宿主重启即清零，与 #229 的游标持久化是两件事。
   summarizeMaxRunsPerSession: z.natural().min(0).max(1000).default(0),
+  // Issue #493：连续解析失败几次后放弃当前窗口（0 = 关闭，行为与历史版本逐字节
+  // 一致）。失败默认不推进游标——语义是「这段还没提炼完，下次接着来」，这对
+  // 偶发失败（429/5xx/超时）是对的。但确定性失败（模型把转录当成该自己回话，
+  // finish_reason=stop，同文同温）重试收益为 0，而窗口只会随新事件继续变大，
+  // 于是一条会话能被同一窗口卡死几十轮、每轮都白烧一次完整调用。设成 2-3 即
+  // 可止血：达到阈值后强制消费游标跳过该窗口，并留一行带 streak/raw_head 的
+  // error 审计。默认关是因为放弃内容本身有代价——短窗口偶尔失败仍值得重试。
+  summarizeParseFailureMaxRetries: z.natural().min(0).max(10).default(0),
   // Issue #239（第 4 项，错峰队列）：高峰期蒸馏顺延。空串 = 关闭，行为与现状逐
   // 字节一致。取值是本地时间的时段列表（逗号分隔，支持跨零点），可带**星期前缀**
   // （可省；ISO 1=周一…7=周日，也认 mon..sun；省略 = 每天）：
@@ -841,6 +849,19 @@ export const Config = z.object({
   disableMemorySearch: z.boolean().default(false),
   disableMemoryArchive: z.boolean().default(false),
 
+  // Issue #231 第二批：agent 主动整理接口（src/organize.js）的**暴露**闸。引擎在
+  // PR #267 就造好了，当时刻意不进工具列表、不加开关（模块头注释：「与 #249 同批
+  // 暴露时只差『注册工具 + 注入指引』一步」），配置面留到这一批再定——就是这里。
+  // 与上面两个 disable* 是**反向**语义：那两个把默认在场的工具藏起来，本键把默认
+  // 不在场的能力开出来。因为 dryRun→apply 是一套两步协议（apply 必须引用真实报告
+  // 的 run_id），让 agent 未经用户同意就能整理记忆，不是「少一次往返」的成本问题，
+  // 而是「谁在改库」的授权问题。
+  // 进 LIGHT_MODE_OFF：两步协议在弱模型上最容易走歪（漏 run_id、或跳过报告直接
+  // apply——那一拒绝就是一次失败的工具调用），而一次 dryRun 的代价是一回嵌入调用
+  // 加按 type 有界扫库。这是预设给的默认值、不是强制：用户显式勾选仍然赢（合并顺序
+  // 「用户开关 > 轻量预设 > bundle」，同 continuityRescueEnabled / distillRecords.enabled）。
+  organizeEnabled: z.boolean().default(false),
+
   // --- scope: v0.8.0 A1 存储层（issue #17）--------------------------------
   // 总开关默认关：关闭时写入不标注 scope、去重维持 (type, title) 现状，行为
   // 逐字节不变。开启后**两条写入路径都自动盖章**（*_scope_source='auto'）：
@@ -925,7 +946,27 @@ export const Config = z.object({
   // 人格段是用户自写的一小段轻量常驻文本，不引入任何重型后台路径，轻量档用户
   // 显式勾选仍然赢（同 actionPipelineEnabled 的定性）。
   // 也走 feature_flags（FEATURE_FLAG_BOOLEANS 白名单），面板可启停=线上回滚开关。
-  personaEnabled: z.boolean().default(false)
+  personaEnabled: z.boolean().default(false),
+
+  // 人格寻址的兜底口径（只在上一个键打开时才有意义）。关（默认，= 历史行为）：
+  // 会话身份没有卡、或有卡但卡被关掉时，一律落 default 卡——于是 default 成了
+  // 「所有没建卡的 agent 都能拿到某个人格」，宿主里跑的外部 bot（自带身份与设定）
+  // 会在同一帧里收到两句「你是谁」。开：这两种情况都不注入人格，default 退回它的
+  // 本意——只兜「这一帧解析不到会话身份」的无名会话（无身份时行为不变）。
+  // 默认关是因为这是一次口径变更：老用户升级后注入文本不许静默变化。
+  // 不进 LIGHT_MODE_OFF：它只是取卡时的一个分支，不引入常驻文本、也不引入后台路径，
+  // 且它本身只在 personaEnabled 打开时才起作用（同 scopeState 的定性）。
+  personaStrictAddressing: z.boolean().default(false),
+
+  // Issue #497：从活跃记忆反向提取「助手眼中的用户」画像**草稿**（POST
+  // /api/dsh-mneme/profile/extract）。默认关有三层理由：① 它每次点一次就是一次 LLM
+  // 调用并读上百行记忆，成本与 dream/summarize 同级，不该在没人要求时挂在面上；
+  // ② 产物会被用户当成「关于我的第一版画像」读，编造的代价不对称——所以空库直接报错、
+  // 解析失败也报错，绝不回空草稿；③ 它**不写** user_settings，采用草稿是面板里另一次
+  // 显式保存，画像正文必须是用户手写的原文，不给模型改写权。
+  // 进 LIGHT_MODE_OFF：一次调用要读上百行记忆 + 一轮模型生成，与低资源档互斥（同
+  // preInjectGate.enabled 的定性）；是预设不是强制，用户显式勾选仍然赢。
+  profileExtractEnabled: z.boolean().default(false)
 });
 
 // Fields forced to false by the light-mode preset. Everything not listed here
@@ -958,6 +999,10 @@ const LIGHT_MODE_OFF = [
   "dreamNarrativeEnabled",
   // 轻量模式不开 document 指针行（#230，opt-in：注册/注入/检索增强全随闸）。
   "documentMemoryEnabled",
+  // #231 第二批：轻量档不开 agent 主动整理。理由不是成本而是协议——dryRun→apply
+  // 要求 agent 拿住上一轮的 run_id 再回来，弱模型漏这一环就是一次被拒的调用；
+  // 预设关、不剥夺显式开启的权利（合并顺序同 continuityRescueEnabled）。
+  "organizeEnabled",
   // 轻量模式不开热计算（heat 属于重型增强；关掉后 sleep 降级也退回纯时间分层）。
   "heatEnabled",
   // 轻量模式不开注入前判定（#380：LLM-per-turn 附加路径，每帧注入多一次池级
@@ -977,6 +1022,10 @@ const LIGHT_MODE_OFF = [
   // 是「小模型 / 小上下文 / 少常驻路径」，这与一个每事件都过一遍的监听器相冲突。
   // 默认关，这里只是轻量预设再确认一次；用户显式勾选仍然赢（合并顺序同上面两条）。
   "actionRunEnabled",
+  // #497：轻量档不开画像提取——一次调用要读上百行记忆再生成一段画像，与低资源档
+  // 互斥（同 preInjectGate.enabled 的定性）。默认关，这里只是预设再确认一次；
+  // 用户显式勾选仍然赢（合并顺序同 continuityRescueEnabled）。
+  "profileExtractEnabled",
   // M.O. 自动沉淀：同样挂在 session/event 热路径上，而且解压会话日志是同步 I/O。
   // 轻量档的取向（小模型 / 小上下文 / 少常驻路径）与它直接冲突，预设里关掉；
   // 用户显式勾选仍然赢（合并顺序同上面几条）。

package/src/dream.js

@@ -10,7 +10,7 @@ import { scopeKeyOf } from "./scope.js";
 import { isInPeakWindow, nextOffPeakAt } from "./peak-hours.js";
 import { createHash, randomUUID } from "node:crypto";
 import { STR, langOf } from "./lang.js";
-export { validateDecisions, applyDecisions, withEffortFallback, withMaxTokensFallback, parseMaxTokensCap, describeStreamFailure, resolveDreamEffort, resolveRoute };
+export { validateDecisions, applyDecisions, withEffortFallback, withMaxTokensFallback, parseMaxTokensCap, describeStreamFailure, resolveDreamEffort, resolveRoute, streamText, runAuditedLlm };
 
 // Extract the first JSON array from LLM output, tolerating markdown fences,
 // leading/trailing prose, and common wrapper noise. Returns an array or null.

package/src/index.js

@@ -34,6 +34,7 @@ import { createSemantic } from "./semantic.js";
 import { Config, applyLightModePreset, injectChildEnabled } from "./config.js";
 import { langOf } from "./lang.js";
 import { extractEntities } from "./entities/extractor.js";
+import { createProfileExtractor } from "./profile-extract.js";
 import { mkdirSync } from "node:fs";
 import { join } from "node:path";
 import { homedir } from "node:os";
@@ -585,11 +586,15 @@ export const apply = (ctx, config) => {
   // 功能（工具/注入/dream）照常。
   const webServer = typeof ctx.reflect?.get === "function" ? ctx.reflect.get("webServer") : ctx.webServer;
   if (webServer) {
+    // 画像提取草稿（#497）：装配与开关无关——闸在路由那一侧（关着回 409 disabled，
+    // 本模块一次都不会被调用）。这样「没启用」与「没装配」在 HTTP 面上是两个可区分的
+    // 答案（503 unavailable 只该出现在旧宿主/装配缺失上，不该被读成「用户没开」）。
+    const extractProfileDraft = createProfileExtractor({ ctx, service, config: cfg, logger: ctx.logger });
     const api = createApi(ctx, service, settings, commands ?? {
       add: () => { throw new Error("commands unavailable"); },
       remove: () => false,
       list: () => []
-    }, embedder, { vectorIndex, reranker }, cfg.apiToken, cfg, maintenance);
+    }, embedder, { vectorIndex, reranker }, cfg.apiToken, cfg, maintenance, extractProfileDraft);
     disposers.push(api.dispose);
   }
 

package/src/inject.js

@@ -1,6 +1,7 @@
 import { createScopeResolver } from "./scope.js";
 import { createHotMemory, roundsFromEvents } from "./hot-memory.js";
 import { STR, langOf } from "./lang.js";
+import { escapePromptVars as escapePromptVarsWithConfig, renderUserSettingsBlock } from "./user-settings.js";
 import { MEMORY_GUIDE_SECTION } from "./guide.js";
 import { adaptiveInjectBudget } from "./search/adaptive.js";
 import { injectChildEnabled } from "./config.js";
@@ -176,8 +177,9 @@ export function createInjector(ctx, service, settings, config, gate = null) {
   // adjacent), and single braces pass through untouched — interpolate only
   // scans `{{`. Off via config.escapePromptVariables=false (default true).
   function escapePromptVars(text) {
-    if (config.escapePromptVariables === false) return String(text);
-    return String(text).replace(/[{}]{2,}/g, (run) => run.split("").join("\\"));
+    // 实现搬到 src/user-settings.js：预览路由要用同一份转义，否则「注入生效文本」的
+    // 预览又是第二份实现、又会漂。这里保留同名闭包，其余调用点一字不动。
+    return escapePromptVarsWithConfig(config, text);
   }
 
   // Time-prefix injection (issue #34，恢复于 #333): opt-in, off by default.
@@ -323,30 +325,13 @@ export function createInjector(ctx, service, settings, config, gate = null) {
 
   // User profile + rules: injected ahead of the memory block because they are
   // always-relevant instructions the agent should follow every turn.
-  // 人格段（beta）：双闸门（config.personaEnabled && 卡.enabled）开时渲染在最前
-  // ——设计稿⑥：特化指令（人格）先出，画像与规则后出、后写覆盖占上风，rules 恒
-  // 最硬。v1.2 多卡：按会话身份取 byAgent 卡，身份缺失/无卡/卡关落 default。
-  // 任一闸关着时本函数输出与历史版本逐字节一致（老用户零变化）。人格段非空即
-  // 触发整块渲染（与 profile 同权）。
+  // 渲染整体搬到 src/user-settings.js（与面板预览共用一份，见那里的模块头注释）。
+  // 口径不变：双闸门（config.personaEnabled && 卡.enabled）都开时人格行在最前，
+  // 画像与规则后出、后写覆盖占上风，rules 恒最硬；任一闸关着时输出与历史版本逐字节
+  // 一致（老用户零变化）。personaStrictAddressing 打开时，「有身份但没建卡」与
+  // 「卡被显式关掉」都不注入人格——default 只兜「这一帧解析不到身份」的会话。
   function renderUserSettings(ctx) {
-    const profile = settings.getProfile().trim();
-    const rules = settings.getRules();
-    const persona = config?.personaEnabled === true
-      ? settings.getPersonaFor(sessionAgentId(ctx))
-      : {};
-    const personaLines = persona?.enabled === true
-      ? [
-          ...(typeof persona.name === "string" && persona.name.trim() ? [STR.personaNameLine[language](persona.name.trim())] : []),
-          ...(typeof persona.personality === "string" && persona.personality.trim() ? [STR.personaPersonalityLine[language](persona.personality.trim())] : []),
-          ...(typeof persona.replyStyle === "string" && persona.replyStyle.trim() ? [STR.personaReplyStyleLine[language](persona.replyStyle.trim())] : [])
-        ]
-      : [];
-    if (!profile && !rules.length && !personaLines.length) return "";
-    const lines = [STR.userSettingsHeader[language]];
-    lines.push(...personaLines);
-    if (profile) lines.push(STR.profileLine[language](profile));
-    for (const rule of rules) lines.push(STR.ruleLine[language](rule));
-    return escapePromptVars(lines.join("\n"));
+    return renderUserSettingsBlock({ settings, config, agentId: sessionAgentId(ctx) }).text;
   }
 
   // #249 能力说明的系统提示段。order 150 = 插件指引段的既有惯例