@modusensus/dsh-mneme 0.9.0 → 0.9.1

package/lib/config.js

@@ -415,6 +415,13 @@ export const Config = z.object({
   // in the background after a short delay, rate-limited in batches. On by
   // default; set false to keep the backfill manual only.
   autoReindexOnBoot: z.boolean().default(true),
+  // Backfill pacing (previously hardcoded 500 / 10 / 200 in semantic.js). A
+  // fixed 500-per-boot cap meant a 4k-row backlog needed nine restarts to
+  // clear, and nothing reported that the run had been capped.
+  // reindexMaxPerBoot = 0 means "no cap, drain the whole backlog this run".
+  reindexMaxPerBoot: z.natural().default(500),
+  reindexBatchSize: z.natural().min(1).max(64).default(10),
+  reindexRateLimitMs: z.natural().default(200),
   // Semantic-first injection (Bug4): when enabled, injectCandidates with a
   // non-empty query recalls via the vector index first and falls back to the
   // rule-based pick to fill/dedupe. Empty query / no vector → legacy behavior.
@@ -867,7 +874,27 @@ export const Config = z.object({
   // 它只是只读视图、不引入任何重型后台路径，轻量档用户显式勾选仍然赢（预设
   // 该关的是重型能力，不该替用户关掉一个纯 UI 入口）。
   // 也走 feature_flags（FEATURE_FLAG_BOOLEANS 白名单），面板可启停=线上回滚开关。
-  actionPipelineEnabled: z.boolean().default(false)
+  actionPipelineEnabled: z.boolean().default(false),
+
+  // M.O. 执行记账（v0.9.0 第二批）：`/mo-run` 显式开一次执行窗口，窗口内的命令执行
+  // 才可能被记成一条 run。与上面那个键**分开**：上面管「看图的座位」，这个管
+  // 「往账本里写」——看图和写账是两件事，混成一个键会让「只想看图」的人不知不觉
+  // 获得写入能力。
+  //
+  // 默认关（beta 必须 opt-in）。它挂在热路径上（每个会话事件都过一次监听），
+  // 所以轻量档要关掉：`LIGHT_MODE_OFF` 里有它。
+  actionRunEnabled: z.boolean().default(false),
+
+  // --- 人格定义页（beta）---------------------------------------------------
+  // 注入器渲染人格段的顶层总闸（双闸门的 config 半边；user_settings "persona"
+  // 键内的 persona.enabled 是 per-agent 半边，两闸同真才渲染）。API 的 effective
+  // 必须含这个键——schema 里没有它 effective 就静默少键，面板开关形同虚设
+  // （#254 漏登记 NESTED_FLAG_PATHS 是同一个坑，计数锁 test/api.test.js 钉住）。
+  // 默认关：beta 功能必须 opt-in，老用户行为逐字节不变。不进 LIGHT_MODE_OFF——
+  // 人格段是用户自写的一小段轻量常驻文本，不引入任何重型后台路径，轻量档用户
+  // 显式勾选仍然赢（同 actionPipelineEnabled 的定性）。
+  // 也走 feature_flags（FEATURE_FLAG_BOOLEANS 白名单），面板可启停=线上回滚开关。
+  personaEnabled: z.boolean().default(false)
 });
 
 // Fields forced to false by the light-mode preset. Everything not listed here
@@ -914,7 +941,11 @@ const LIGHT_MODE_OFF = [
   // #399：轻量档不开蒸馏原文留存——它是一份对话原文副本（磁盘 + 暴露面），
   // 与轻量档「小模型 / 小上下文 / 少留痕」的取向相反。默认关，这里只是
   // 轻量预设再确认一次；用户显式勾选仍然赢（合并顺序同 continuityRescueEnabled）。
-  "distillRecords.enabled"
+  "distillRecords.enabled",
+  // M.O. 执行记账：它挂在**热路径**上（每个会话事件都过一次监听）。轻量档的取向
+  // 是「小模型 / 小上下文 / 少常驻路径」，这与一个每事件都过一遍的监听器相冲突。
+  // 默认关，这里只是轻量预设再确认一次；用户显式勾选仍然赢（合并顺序同上面两条）。
+  "actionRunEnabled"
 ];
 
 /**

package/lib/embedding.js

@@ -69,9 +69,51 @@ export async function embedText({ baseUrl, apiKey, model }, text) {
  * successful embed the model that produced the vectors is recorded, so the
  * index can detect drift and the auto-reindex backfill knows what to rebuild.
  */
+/**
+ * Bounded receipt ring for embedding attempts.
+ *
+ * Why a ring instead of llm_audit_logs: a full backfill is thousands of
+ * attempts, and one audit row each would bury the LLM calls that table exists
+ * to trace. What the user actually needs in order to answer "is the vector
+ * layer silently dead right now?" is the recent window plus running totals —
+ * which costs nothing and cannot flood.
+ */
+const RECEIPT_LIMIT = 200;
+
+function createReceiptLedger() {
+  const recent = [];
+  const totals = { ok: 0, failed: 0, skipped: 0 };
+  let lastOkAt = null;
+  let lastFailAt = null;
+  let lastFailReason = null;
+  return {
+    record(entry) {
+      recent.push(entry);
+      if (recent.length > RECEIPT_LIMIT) recent.shift();
+      if (entry.status in totals) totals[entry.status]++;
+      if (entry.status === "ok") lastOkAt = entry.at;
+      else if (entry.status === "failed") {
+        lastFailAt = entry.at;
+        lastFailReason = entry.reason ?? null;
+      }
+    },
+    snapshot() {
+      return {
+        totals: { ...totals },
+        lastOkAt,
+        lastFailAt,
+        lastFailReason,
+        recent: recent.slice(-RECEIPT_LIMIT)
+      };
+    }
+  };
+}
+
 export function createEmbedder({ store, settings, logger, vectorIndex }) {
   // Dimension of the most recent successful embed, exposed for fingerprinting.
   let _dimension = 0;
+  // Per-write embed receipts (see createReceiptLedger above).
+  const ledger = createReceiptLedger();
 
   /** Record the producing model fingerprint in vector_meta (best-effort). */
   function markModel(cfg, dimension) {
@@ -85,19 +127,52 @@ export function createEmbedder({ store, settings, logger, vectorIndex }) {
   // ready/configured 两个 getter 共用，避免以后改一处漏一处。
   const configComplete = (cfg) => !!(cfg?.enabled && cfg.baseUrl && cfg.apiKey && cfg.model);
 
+  /**
+   * Embed one memory and store the vector. Never throws — a flaky endpoint
+   * must not break memory writes — but it now REPORTS what happened instead
+   * of returning undefined on both success and failure. Callers that ignore
+   * the result are unaffected; callers that care get a receipt.
+   *
+   * @returns {Promise<{status:"ok"|"failed"|"skipped", id:string,
+   *   at:string, reason?:string, dim?:number, model?:string}>}
+   */
   async function embedFor(id, title, content) {
+    const at = new Date().toISOString();
     const cfg = settings.getVectorConfig();
-    if (!configComplete(cfg)) return;
+    if (!configComplete(cfg)) {
+      const entry = { status: "skipped", id, at, reason: "vector-config-incomplete" };
+      ledger.record(entry);
+      return entry;
+    }
     const text = [title, content].filter(Boolean).join("\n");
-    const vector = await embedText(cfg, text);
-    if (vector) {
-      store.setEmbedding(id, vector);
-      _dimension = vector.length;
-      // Bug3: record which model produced the current vectors so the index can
-      // detect drift and skip a redundant backfill when nothing changed.
-      markModel(cfg, vector.length);
-      logger?.info?.(`[dsh-mneme] embedded memory ${id} (dim=${vector.length})`);
+    let vector = null;
+    try {
+      vector = await embedText(cfg, text);
+    } catch (error) {
+      const entry = { status: "failed", id, at, reason: String(error) };
+      ledger.record(entry);
+      logger?.warn?.(`[dsh-mneme] embed memory ${id} failed: ${String(error)}`);
+      return entry;
+    }
+    if (!vector) {
+      // embedText swallows the HTTP detail (404 / timeout / malformed body all
+      // resolve to null). The receipt still has to say "no vector", which is
+      // exactly the fact the write path never used to report.
+      const entry = { status: "failed", id, at, reason: "embedding-request-returned-no-vector" };
+      ledger.record(entry);
+      logger?.warn?.(`[dsh-mneme] embed memory ${id} produced no vector`);
+      return entry;
     }
+    const model = modelHashOf(cfg.model);
+    store.setEmbedding(id, vector, model);
+    _dimension = vector.length;
+    // Bug3: record which model produced the current vectors so the index can
+    // detect drift and skip a redundant backfill when nothing changed.
+    markModel(cfg, vector.length);
+    const entry = { status: "ok", id, at, dim: vector.length, model };
+    ledger.record(entry);
+    logger?.info?.(`[dsh-mneme] embedded memory ${id} (dim=${vector.length})`);
+    return entry;
   }
 
   return {
@@ -120,10 +195,26 @@ export function createEmbedder({ store, settings, logger, vectorIndex }) {
     get configured() {
       return configComplete(settings.getVectorConfig());
     },
-    /** Fire-and-forget re-embed of a memory after any write. */
+    /**
+     * Re-embed a memory after any write. Still non-blocking — the caller does
+     * not have to await it — but it now RETURNS the receipt promise so a
+     * caller that wants to know can. Previously this returned undefined and
+     * swallowed the rejection, so "did this write get a vector?" had no answer
+     * anywhere in the process. Swallowing still applies to the rejection
+     * itself: a vector failure must never break the memory write.
+     */
     schedule(memory) {
-      if (!memory?.id) return;
-      embedFor(memory.id, memory.title, memory.content).catch(() => {});
+      if (!memory?.id) {
+        return Promise.resolve({ status: "skipped", id: null, at: new Date().toISOString(), reason: "no-id" });
+      }
+      return embedFor(memory.id, memory.title, memory.content).catch((error) => ({
+        status: "failed", id: memory.id, at: new Date().toISOString(), reason: String(error)
+      }));
+    },
+
+    /** Recent embed receipts + running totals (see createReceiptLedger). */
+    embedReceipts() {
+      return ledger.snapshot();
     },
 
     /** Embed one text and return its vector (null on failure/disabled). */
@@ -155,17 +246,27 @@ export function createEmbedder({ store, settings, logger, vectorIndex }) {
       return _dimension || undefined;
     },
 
-    /** Batch re-index rows still missing an embedding. */
+    /**
+     * Batch re-index rows whose vector is missing OR came from another model.
+     * Uses needsEmbeddingFor (not needsEmbedding) so a model switch actually
+     * re-embeds the old vectors instead of leaving them eligible for "has a
+     * vector" forever while they poison similarity ranking.
+     */
     async reindexMissing(limit = 50) {
       const cfg = settings.getVectorConfig();
       if (!cfg?.enabled) return { indexed: 0, skipped: 0 };
-      const rows = store.needsEmbedding(limit);
+      const model = modelHashOf(cfg.model);
+      // Fall back to the plain selector for stores that predate the
+      // provenance column (older hosts, test doubles).
+      const rows = typeof store.needsEmbeddingFor === "function"
+        ? store.needsEmbeddingFor(model, limit)
+        : store.needsEmbedding(limit);
       let indexed = 0;
       for (const row of rows) {
         const text = [row.title, row.content].filter(Boolean).join("\n");
         const vector = await embedText(cfg, text);
         if (vector) {
-          store.setEmbedding(row.id, vector);
+          store.setEmbedding(row.id, vector, model);
           _dimension = vector.length;
           indexed++;
         }

package/lib/index.js

@@ -22,6 +22,8 @@ import { createStandaloneApi } from "./api-standalone.js";
 import { createMaintenance } from "./maintenance.js";
 import { createSettings } from "./settings.js";
 import { createCommandManager } from "./commands.js";
+import { createExecutionRecorder } from "./pipeline-runner.js";
+import { registerMoRunCommand } from "./pipeline-command.js";
 import { createVectorIndex } from "./vector-index.js";
 // semantic(embedder/reranker/boot 回填)纯搬移至 src/semantic.js(PR2):宿主与
 // daemon(dsh-mneme-serve,#363)共用同一套装配,原文件保留 barrel 出口。
@@ -388,11 +390,40 @@ export const apply = (ctx, config) => {
   // Custom commands: register persisted commands into the DSH command registry
   // on boot; add/remove re-register live through the API.
   let commands = null;
+  // M.O. 执行记账器：默认 null（旗标关），开了才装配。
+  let recorder = null;
   if (ctx.commands) {
     commands = createCommandManager({ ctx, settings, logger: ctx.logger, language: langOf(cfg) });
     commands.sync();
   }
 
+  // M.O. 执行记账（v0.9.0 第二批）：`/mo-run` 显式开一次执行窗口，窗口内的命令执行
+  // 才可能被记成一条 run。挂的是 `session/event`——本仓已有三处消费者（continuity /
+  // summarize / api），不是新引入的宿主依赖。
+  //
+  // 为什么必须显式开窗：工作流的 trigger 是人话，拿它去猜「用户这句话是不是要开始走
+  // 某条流程」只能猜错，而猜错会把一条从没跑过的流程记成跑过。所以窗口边界由人的
+  // 显式动作划，**没开窗时一个字都不记**。
+  //
+  // 门控：默认关（actionRunEnabled），并且它挂热路径，轻量档也关。
+  if (cfg.actionRunEnabled === true) {
+    recorder = createExecutionRecorder({ ctx, logger: ctx.logger });
+    const disposeMoRun = registerMoRunCommand({
+      ctx,
+      recorder,
+      enabled: true,
+      language: () => langOf(cfg)
+    });
+    if (disposeMoRun) {
+      disposers.push(disposeMoRun);
+    } else {
+      // 注册不上（宿主没有命令注册表）时别留一个只开着窗口却没人能操作的记录器。
+      recorder.dispose();
+      recorder = null;
+      ctx.logger?.warn?.("[dsh-mneme] actionRunEnabled=true 但宿主没有命令注册表，M.O. 记账未启用");
+    }
+  }
+
   // Dream scheduler: automatic consolidation + summary runs, triggered by
   // store growth. Writes through the service fire the dream hook, which asks
   // the scheduler to (re)schedule a run once absolute and since-last-run
@@ -582,6 +613,7 @@ export const apply = (ctx, config) => {
       if (typeof dispose === "function") dispose();
     }
     commands?.dispose();
+    recorder?.dispose();
     if (dream) await dream.dispose();
     if (sleep) sleep.dispose();
     store.close();

package/lib/inject.js

@@ -306,13 +306,44 @@ export function createInjector(ctx, service, settings, config, gate = null) {
     }).catch(() => { /* prefetch is best-effort */ });
   }
 
+  // 会话身份解析（v1.2 人格寻址用）：读 session.header.agentPreset——冻结的
+  // SessionHeader（issue #17 身份契约）。⚠️ 不能先读 requestHeader()：那返回
+  // EpochHeader（请求级头，首请求后为真），会把 session.header 遮蔽掉，身份取空
+  // （scope.js 同坑，本地实测踩过）。任何失败静默 → null（落 default 卡）。
+  function sessionAgentId(ctx) {
+    try {
+      const session = ctx?.agent?.session;
+      const header = session?.header ?? null;
+      const preset = header?.agentPreset;
+      return typeof preset === "string" && preset.trim() ? preset.trim() : null;
+    } catch {
+      return null;
+    }
+  }
+
   // User profile + rules: injected ahead of the memory block because they are
   // always-relevant instructions the agent should follow every turn.
-  function renderUserSettings() {
+  // 人格段（beta）：双闸门（config.personaEnabled && 卡.enabled）开时渲染在最前
+  // ——设计稿⑥：特化指令（人格）先出，画像与规则后出、后写覆盖占上风，rules 恒
+  // 最硬。v1.2 多卡：按会话身份取 byAgent 卡，身份缺失/无卡/卡关落 default。
+  // 任一闸关着时本函数输出与历史版本逐字节一致（老用户零变化）。人格段非空即
+  // 触发整块渲染（与 profile 同权）。
+  function renderUserSettings(ctx) {
     const profile = settings.getProfile().trim();
     const rules = settings.getRules();
-    if (!profile && !rules.length) return "";
+    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"));
@@ -418,7 +449,7 @@ export function createInjector(ctx, service, settings, config, gate = null) {
     ctx.systemPrompt.context({
       name: "user-settings",
       order: 85,
-      text: renderUserSettings
+      text: (ctx) => renderUserSettings(ctx)
     })
   ];
 

package/lib/lang.js

@@ -122,6 +122,20 @@ export const STR = {
     zh: (rule) => `- 规则：${rule}`,
     en: (rule) => `- Rule: ${rule}`
   },
+  // 人格定义页（beta）：人格段行（renderUserSettings 拼装，双闸门开时渲染）。
+  // 设计稿⑥：人格段在 profile/rules 之前——特化指令后出、通用底座压轴，rules 恒最硬。
+  personaNameLine: {
+    zh: (name) => `- 你的人格名字：${name}`,
+    en: (name) => `- Your persona name: ${name}`
+  },
+  personaPersonalityLine: {
+    zh: (text) => `- 人格性格设定：${text}`,
+    en: (text) => `- Persona personality: ${text}`
+  },
+  personaReplyStyleLine: {
+    zh: (text) => `- 回复要求：${text}`,
+    en: (text) => `- Reply style: ${text}`
+  },
 
   // --- summarize.js：蒸馏转录标签（进入 LLM 上下文） --------------------------
   transcriptUser: { zh: (t) => `用户：${t}`, en: (t) => `User: ${t}` },
@@ -223,6 +237,116 @@ export const STR = {
     en: (name) => `Failed to submit command ${name}; see logs`
   },
 
+  // --- pipeline-command.js：/mo-run 的开窗命令 -----------------------------------
+  // 回执是这个功能唯一的对外窗口（面板侧还没做），所以每一条都要说清「发生了什么、
+  // 为什么」——尤其失败时不许含糊成「完成」。
+  moRunDescription: {
+    zh: "M.O. 记账：显式开一次执行窗口，之后跑过的命令才可能被记下来",
+    en: "M.O. ledger: explicitly open an execution window; only commands run inside it can be recorded"
+  },
+  moRunInputHint: {
+    zh: "start <工作流 id> | stop | confirm <做了的步骤> | status",
+    en: "start <pipeline id> | stop | confirm <steps that ran> | status"
+  },
+  moRunUsage: {
+    zh: "用法：/mo-run start <工作流 id> → 走一遍 → /mo-run stop → /mo-run confirm <做了的步骤 id>\n\n停止时会给出一份待确认清单（含本次观察到的业务动作）；**确认之后才写账**。\n确认写法：`/mo-run confirm P6 V2` 表示这两步做了；`V2:-` 表示没做（记 skipped），`V2:?` 表示不确定（不写）。\n未提到的步骤什么都不写——「没确认」不等于「没发生」。\n\n它不会自己判断「你是不是在走某条流程」，也不会自己判断「哪几步走了」：这两件事都会猜错。",
+    en: "Usage: /mo-run start <pipeline id> → walk through it → /mo-run stop → /mo-run confirm <step ids that ran>\n\nStop gives you a checklist (with the business actions observed); **the ledger is only written after you confirm**.\nConfirm syntax: `/mo-run confirm P6 V2` means both ran; `V2:-` means not done (recorded as skipped), `V2:?` means unsure (not written).\nSteps you do not mention are written as nothing — unconfirmed is not the same as not-happened.\n\nIt never guesses whether you are walking a workflow, nor which steps ran: both guesses would be wrong."
+  },
+  moRunStart: {
+    zh: {
+      ok: (id, steps) => `已开窗：${id}（${steps} 步）。走完用 /mo-run stop 结账——它会给你一份待确认清单，**确认之后才写账**。`,
+      alreadyOpen: (id) => `这个会话已经开着窗口了：${id}。先用 /mo-run stop 结账，再开新的。`,
+      notFound: (ids) => `找不到这条工作流。可用：${ids}`,
+      noneAvailable: "（当前项目里没有读到任何工作流）",
+      unreadable: (detail) => `工作流读不出来：${detail}`,
+      noProject: "拿不到这个会话的工作目录，无法定位工作流。",
+      noSession: "拿不到会话身份，无法记账。",
+      failed: (reason) => `开窗失败：${reason}`
+    },
+    en: {
+      ok: (id, steps) => `Window opened: ${id} (${steps} steps). When done, run /mo-run stop — it gives you a checklist, and **the ledger is only written after you confirm**.`,
+      alreadyOpen: (id) => `This session already has an open window: ${id}. Run /mo-run stop first.`,
+      notFound: (ids) => `No such workflow. Available: ${ids}`,
+      noneAvailable: "(no workflow found in this project)",
+      unreadable: (detail) => `Workflow unreadable: ${detail}`,
+      noProject: "Cannot determine this session's working directory, so the workflow cannot be located.",
+      noSession: "No session identity available; nothing can be recorded.",
+      failed: (reason) => `Failed to open window: ${reason}`
+    }
+  },
+  moRunStop: {
+    zh: {
+      ok: (id, steps) => `已结账并落盘：${id}，记下 ${steps} 步。`,
+      awaiting: (id, steps) => `已结账：${id}（${steps} 步）。**还没有写账**——请确认哪几步真的走了：`,
+      confirmHow: (sample) =>
+        `\n用 /mo-run confirm ${sample} 列出「做了」的步骤；要标「没做」就写 ${String(sample).split(" ")[0]}:-\n未提到的步骤什么都不写（「没确认」不等于「没发生」）。`,
+      notCommands: (n) => `${n} 次调用不是命令执行器（读文件、检索这类），与工作流步骤无关。`,
+      truncated: "⚠️ 事件缓冲到上限被截断，这次记账可能不完整。",
+      noWindow: "这个会话没有开着窗口，没什么可结账的。",
+      activities: (n) => `本次观察到 ${n} 种业务动作（只留动作与旗标，位置参数略去）：`,
+      shellNoise: (n) => `另有 ${n} 段是 shell 语法（赋值、管道、输出），不是工作流的一步。`,
+      writeFailed: (detail) => `写盘失败：${detail}`,
+      failed: (reason) => `结账失败：${reason}`
+    },
+    en: {
+      ok: (id, steps) => `Closed and persisted: ${id}, ${steps} step(s) recorded.`,
+      awaiting: (id, steps) => `Closed: ${id} (${steps} steps). **Nothing persisted yet** — confirm which steps really ran:`,
+      confirmHow: (sample) =>
+        `\nUse /mo-run confirm ${sample} to list the steps that ran; mark one as not-done with ${String(sample).split(" ")[0]}:-\nSteps you do not mention are written as nothing (unconfirmed is not the same as not-happened).`,
+      notCommands: (n) => `${n} call(s) were not command executors (file reads, searches) and are irrelevant to workflow steps.`,
+      truncated: "⚠️ Event buffer hit its cap and was truncated; this record may be incomplete.",
+      noWindow: "No window is open for this session, so there is nothing to close.",
+      activities: (n) => `${n} kind(s) of business action observed this pass (actions and flags only; positional arguments omitted):`,
+      shellNoise: (n) => `Another ${n} segment(s) were shell syntax (assignments, pipes, output), not steps of a workflow.`,
+      writeFailed: (detail) => `Failed to write: ${detail}`,
+      failed: (reason) => `Failed to close: ${reason}`
+    }
+  },
+  moRunConfirm: {
+    zh: {
+      ok: (id, steps) => `已记入账本：${id}，${steps} 步。`,
+      notDone: (list) => `记为「这次没做」（skipped）：${list}`,
+      unsure: (list) => `你说不确定，没有写进账：${list}`,
+      unanswered: (list) => `没提到的步骤没有写进账：${list}`,
+      nothingToConfirm: "没有待确认的清单。先 /mo-run start <工作流 id>，走一遍，再 /mo-run stop。",
+      mismatch: (n, rows) => `⚠️ 有 ${n} 步你说做了、但声明的命令这次一次都没出现（是声明该改、还是本来不必敲？由你判）：\n${rows}`,
+      obsSaved: (file) => `本次观察已旁挂：${file}`,      noAnswers: (notDone, unsure, unanswered) =>
+        `一条都没确认，**没有落盘**。你说「没做」的 ${notDone} 步、不确定的 ${unsure} 步、没提到的 ${unanswered} 步。\n确认「做了」的步骤才会写账：/mo-run confirm <步骤 id>`,
+      badValue: (stepId, value) => `${stepId} 的回答「${value}」不合法。只认「做了」（或不写标记）/「没做」写作 -/「不确定」写作 ?`,
+      unknownStep: (stepId) => `没有这一步：${stepId}`,
+      writeFailed: (detail) => `写盘失败：${detail}`,
+      failed: (reason) => `确认失败：${reason}`
+    },
+    en: {
+      ok: (id, steps) => `Recorded: ${id}, ${steps} step(s).`,
+      notDone: (list) => `Marked as not done this pass (skipped): ${list}`,
+      unsure: (list) => `You were unsure; not written to the ledger: ${list}`,
+      unanswered: (list) => `Steps you did not mention were not written to the ledger: ${list}`,
+      nothingToConfirm: "Nothing to confirm. Run /mo-run start <pipeline id>, walk through it, then /mo-run stop.",
+      mismatch: (n, rows) => `⚠️ ${n} step(s) you marked done never showed their declared command this pass (stale declaration, or simply not needed? your call):\n${rows}`,
+      obsSaved: (file) => `Observations side-written to: ${file}`,      noAnswers: (notDone, unsure, unanswered) =>
+        `Nothing was confirmed; **nothing was persisted**. Not-done: ${notDone}, unsure: ${unsure}, unmentioned: ${unanswered}.\nOnly steps confirmed as done are recorded: /mo-run confirm <step id>`,
+      badValue: (stepId, value) => `Answer "${value}" for ${stepId} is invalid. Use done (no marker) / - for not-done / ? for unsure.`,
+      unknownStep: (stepId) => `No such step: ${stepId}`,
+      writeFailed: (detail) => `Failed to write: ${detail}`,
+      failed: (reason) => `Failed to confirm: ${reason}`
+    }
+  },
+  moRunStatus: {
+    zh: {
+      closed: "当前没有开着的执行窗口。用 /mo-run start <工作流 id> 开一个。",
+      awaiting: (id, steps) => `等你在确认：${id}（${steps} 步）。用 /mo-run confirm <做了的步骤 id> 写账。`,
+      open: (s, recorded) => `窗口开着：${s.pipelineId}\n开始于 ${s.startedAt}\n已缓冲 ${s.bufferedEvents} 条事件，识别出 ${recorded} 步${s.truncated ? "（缓冲已截断）" : ""}\n认不出 ${s.unattributed}，待确认 ${s.ambiguous}`,
+      none: "（还没有）"
+    },
+    en: {
+      closed: "No execution window is open. Open one with /mo-run start <pipeline id>.",
+      awaiting: (id, steps) => `Waiting for your confirmation: ${id} (${steps} steps). Write the ledger with /mo-run confirm <step ids that ran>.`,
+      open: (s, recorded) => `Window open: ${s.pipelineId}\nStarted ${s.startedAt}\n${s.bufferedEvents} event(s) buffered, ${recorded} step(s) recognized${s.truncated ? " (buffer truncated)" : ""}\nUnattributed ${s.unattributed}, ambiguous ${s.ambiguous}`,
+      none: "(none yet)"
+    }
+  },
+
   // --- mirror.js：镜像文件标签（渲染随实例语言；解析两种语言都认） ----------------
   mirrorLabel: {
     zh: { type: "类型", importance: "重要性", tags: "标签", updated: "更新时间", source: "来源", scope: "作用域", sensitivity: "敏感度" },

package/lib/pipeline-activities.js

@@ -0,0 +1,178 @@
+/**
+ * 把 shell 观察压成**人能扫的「业务动作」清单**。
+ *
+ * ## 为什么需要这一层（三组实测逼出来的）
+ *
+ * 1. 拿单条命令去匹配手写步骤表，命中率只有 14.2~15.2%（非发版会话 4.4%，
+ *    区分力仅 3 倍）→ **拿清单套行为这条路走不通**。
+ * 2. 想用「整段命令」当分组键：每个会话中位 **539 组**、最多 7373 组
+ *    → 文献那套「聚类 + 人命名」直接照搬也不成立（网页活动本来只有几十个页面）。
+ * 3. 换「动词」当键：密度最高的全是 **PowerShell 管道语法**
+ *    （`write-output` 10619、`select-object` 10422、`}` 4864…）
+ *    → **「命令 ≈ 动作」这个预设是错的**：大部分"命令"不是活动，是句子成分。
+ * 4. 只留业务命令（git/gh/npm/node/docker…）后：业务段占 **6.5%**，
+ *    不同动词 **8 个**、不同前两词组 **1010 个** —— 这才是人能扫的量级。
+ *
+ * ## 这个模块的产出：一份「本次窗口观察到什么」清单
+ *
+ * 形态：`git status ×12`、`gh pr ×5`、`npm test ×3`。
+ * **不猜它对应哪一步**——那件事交给人（见 mneme-research 的 09 号文档）。
+ *
+ * ## 🔴 隐私：为什么只输出「动词 + 子命令」
+ *
+ * 完整命令行里**几乎必然含绝对路径**，而路径里含本机用户名。例如实测里真实出现过
+ * `set-location "c:\users\<用户名>\desktop\..."`。这条回执是要显示在界面上、
+ * 可能被截图的那一面——所以本模块有一条硬规则：
+ *
+ * > **位置参数一律丢弃，只保留动词、子命令与 `-` 开头的旗标。**
+ *
+ * 旗标是语义（`--rebase` / `--force` / `-m`），位置参数是数据（路径、文件名、id）。
+ * 只留前者，清单既表意又不泄露。这不是"顺手过滤"，是这一层存在的第二个理由。
+ */
+
+/**
+ * 业务命令的动词白名单。
+ *
+ * 判据不是"常见"，而是"**它的执行会构成工作流的一步**"——即它有语义
+ * （改仓库状态、发版、跑测试），而不是在组装文本（`write-output`、`foreach-object`）。
+ *
+ * 这张名单是**拍的**（实测里 6.5% 的段落在名单内），未验证覆盖率：
+ * 可能有业务动作用了别的工具（`python`、`curl`、`cargo`）。认不出来不产清单项，
+ * 是安全的方向——它只会让清单更短，不会让它更假。
+ */
+const BUSINESS_VERBS = new Set([
+  // 实测 21723 次调用里，真正命中的只有这四个：git / gh / npm / node。
+  // 其余先不收——认不出来只会让清单更短，不会让它更假；
+  // 等真有项目用上了再加（这一版刻意不做"猜未来会用到"的预留）。
+  "git", "gh", "npm", "npx", "node", "docker"
+]);
+
+/** 命令分隔符：与 pipeline-attribution 同一口径（只认两侧带空白的）。 */
+const SEPARATOR_RE = /\s*(?:;|&&|\|\||\|)\s*|\n/u;
+
+/** 重定向尾巴（`2>&1`、`> file`、`2>nul`）：不是命令的一部分。 */
+const REDIRECT_RE = /\s*\d?>\s*&?\s*\S+/gu;
+
+/** `cd <路径>`：前导定位语句，不是活动。 */
+const CD_RE = /^cd\s/iu;
+
+/**
+ * 这个 token 像不像一个**子命令**。
+ *
+ * 必须做这道校验，否则三件事都会发生（都是端到端实测抓到的）：
+ * 1. `node d:\dsh\...\probe.mjs` → 把**脚本路径**当成 sub，路径里的用户名被带出去；
+ * 2. `git -C $(Join-Path ...) log --oneline` → 把 `$(Join-Path` 当成 sub，清单里出现
+ *    `git (join-path -C --oneline` 这种读不懂的东西；
+ * 3. `node x.test.js` → **带点的文件名**被当成 sub（`x.test.js` 完全符合"小写字母起头
+ *    的短词"）。这条是加完前两条修复后复验时才冒出来的。
+ *
+ * 所以除了字符集，还要**排除含点的 token**：子命令带点是极罕见的
+ * （`git log` / `gh pr` / `npm test` / `kubectl get` 都不带），而文件名几乎都带。
+ * 宁可漏认一个，不可把文件名当子命令——后者会出现在给人看的清单里。
+ */
+function looksLikeSubcommand(token) {
+  if (typeof token !== "string") return false;
+  const t = token.replace(/^["']|["']$/gu, "");
+  // 一个正则同时挡住四类坏值：旗标（`-` 开头）、含点的文件名、`$(…)` 这类
+  // shell 片段、以及超长的东西。上一版写成五道 if，等价但更啰嗦。
+  return /^[a-z0-9][a-z0-9_-]{0,19}$/u.test(t);
+}
+
+/**
+ * 一条命令 → 一个业务动作。
+ *
+ * 返回 `{ verb, sub, flags }` 或 `null`（不是业务命令，或抽不出动词）。
+ * - `verb`：白名单里的动词（小写）
+ * - `sub`：**扫描出的第一个像子命令的 token**（不是"第一个非旗标 token"——那个
+ *   可能是路径或参数，见 `looksLikeSubcommand`）。找不到就是空串
+ * - `flags`：`-` 开头的旗标。**位置参数一律丢弃**（理由见文件头隐私一节）
+ */
+export function businessCommandOf(command) {
+  if (typeof command !== "string") return null;
+  const cleaned = command.replace(REDIRECT_RE, " ").trim();
+  if (cleaned === "" || CD_RE.test(cleaned)) return null;
+
+  const tokens = cleaned.split(/\s+/u).filter((t) => t !== "");
+  if (tokens.length === 0) return null;
+
+  const verb = tokens[0].toLowerCase().replace(/^["']|["']$/gu, "");
+  if (!BUSINESS_VERBS.has(verb)) return null;
+
+  // **扫描**而不是取第一个非旗标：`git -C <path> log` 的子命令在 `-C <值>` 之后。
+  let sub = "";
+  for (let i = 1; i < tokens.length; i += 1) {
+    if (looksLikeSubcommand(tokens[i])) {
+      sub = tokens[i].replace(/^["']|["']$/gu, "").toLowerCase();
+      break;
+    }
+  }
+
+  // 旗标：只留 `-` 开头的、短的、不含路径分隔符的（`--base=<path>` 这类直接丢）。
+  const flags = [];
+  for (const raw of tokens.slice(1)) {
+    const t = raw.replace(/^["']|["']$/gu, "");
+    if (t.startsWith("-") && t.length > 1 && t.length <= 24 && !/[/\\=]/u.test(t)) flags.push(t);
+  }
+
+  return { verb, sub, flags: [...new Set(flags)].slice(0, 4) };
+}
+
+/**
+ * 分组的键。
+ *
+ * 优先用子命令（`git status`）。**没有子命令时退而用第一个旗标**——因为对
+ * `node` / `npm` 这类工具，真正区分语义的常常就是旗标：`node --test`（跑测试）与
+ * `node --check`（查语法）是两件事，若键里只有 `node`，它们会被合并成一行，
+ * 清单就读不出差别了。这条是端到端实测里发现的（16 次 node 调用被并成一条）。
+ *
+ * **旗标仍然只是"补充"，不是主体**：`git status -C --porcelain` 的键是 `git status`，
+ * `-C`（它后面本来跟着一个被丢弃的路径）不该挤进键里。
+ */
+export function activityKey(activity) {
+  if (!activity) return "";
+  const tail = activity.sub || (Array.isArray(activity.flags) ? activity.flags[0] : "") || "";
+  return tail ? `${activity.verb} ${tail}` : activity.verb;
+}
+
+/**
+ * 一批观察 → 业务动作清单（按出现次数降序）。
+ *
+ * 每条：`{ key, verb, sub, count, flags }`；`flags` 是出现过的旗标并集（截断）。
+ * **不含任何位置参数**，因此不含路径与用户名。
+ */
+export function tallyActivities(observations) {
+  const groups = new Map();
+  let shellNoise = 0;
+  let totalSegments = 0;
+
+  for (const observation of observations || []) {
+    const command = observation?.command;
+    if (typeof command !== "string" || command.trim() === "") continue;
+    for (const raw of command.split(SEPARATOR_RE)) {
+      if (raw.trim() === "") continue;
+      totalSegments += 1;
+      const activity = businessCommandOf(raw);
+      if (!activity) {
+        shellNoise += 1;
+        continue;
+      }
+      const key = activityKey(activity);
+      const cur = groups.get(key) || { key, verb: activity.verb, sub: activity.sub, count: 0, flags: new Set() };
+      cur.count += 1;
+      for (const f of activity.flags) cur.flags.add(f);
+      groups.set(key, cur);
+    }
+  }
+
+  const activities = [...groups.values()]
+    .map((g) => ({ key: g.key, verb: g.verb, sub: g.sub, count: g.count, flags: [...g.flags].slice(0, 6) }))
+    .sort((a, b) => (b.count === a.count ? a.key.localeCompare(b.key) : b.count - a.count));
+
+  return {
+    activities,
+    // 两个数分开报：「业务动作很少」与「这条命令根本不是动作」是两件事。
+    businessSegments: activities.reduce((n, a) => n + a.count, 0),
+    shellNoise,
+    totalSegments
+  };
+}