@modusensus/dsh-mneme 0.9.0 → 0.9.2

package/lib/embedding.js

@@ -31,10 +31,32 @@ function embeddingsUrl(baseUrl) {
  * Call the embeddings API for one text. Resolves to a Float64 array, or null
  * when the provider is not configured, the call fails, or the response is
  * unusable. Never throws: failures degrade to keyword search.
+ *
+ * The plain null return cannot tell the caller WHY — "model not loaded",
+ * "endpoint 404", "timeout" and "input rejected" all look identical, so the
+ * receipt ledger used to flatten them into one
+ * `embedding-request-returned-no-vector`. Use `embedTextDetailed` when the
+ * reason matters; this wrapper keeps the old contract for existing callers.
+ */
+export async function embedText(cfg, text) {
+  const out = await embedTextDetailed(cfg, text);
+  return out.vector;
+}
+
+/**
+ * Same call, but the failure mode is distinguishable: returns
+ * { vector: number[]|null, reason: null|string } where reason is one of
+ *   config-incomplete | request-failed:<err> | http-<status> |
+ *   response-not-json | response-no-vector | empty-text
+ * Never throws. `reason: null` means success.
  */
-export async function embedText({ baseUrl, apiKey, model }, text) {
+export async function embedTextDetailed({ baseUrl, apiKey, model }, text) {
   const url = embeddingsUrl(baseUrl);
-  if (!url || !apiKey || !model || !text) return null;
+  if (!url || !apiKey || !model || !text) {
+    // 空输入不是端点故障：区分开，否则「text 为空」会被误报成网络问题。
+    const missing = !url ? "baseUrl" : !apiKey ? "apiKey" : !model ? "model" : "text";
+    return { vector: null, reason: `config-incomplete:${missing}` };
+  }
   let res;
   try {
     res = await fetch(url, {
@@ -46,18 +68,33 @@ export async function embedText({ baseUrl, apiKey, model }, text) {
       body: JSON.stringify({ model, input: String(text).slice(0, 8000) }),
       signal: AbortSignal.timeout(DEFAULT_TIMEOUT_MS)
     });
-  } catch {
-    return null;
+  } catch (error) {
+    // 超时是 AbortSignal 抛的 TimeoutError；网络层错误（DNS/拒连）是 TypeError。
+    // 两者都走 request-failed，但带上类型，日志里能分清「慢」和「不通」。
+    const kind = error?.name === "TimeoutError" || error?.name === "AbortError" ? "timeout" : "network";
+    return { vector: null, reason: `request-failed:${kind}:${String(error?.message ?? error).slice(0, 200)}` };
+  }
+  if (!res.ok) {
+    // 状态码本身就是最有用的诊断：401/403 是钥匙、404 是路径、429 是限流、
+    // 5xx 是服务端。文本截断且不含请求体，日志安全。
+    let detail = "";
+    try {
+      const t = await res.text();
+      detail = String(t).slice(0, 200);
+    } catch { /* body unreadable, status alone is already informative */ }
+    return { vector: null, reason: `http-${res.status}${detail ? `:${detail}` : ""}` };
   }
-  if (!res.ok) return null;
   let body;
   try {
     body = await res.json();
   } catch {
-    return null;
+    return { vector: null, reason: "response-not-json" };
   }
   const vec = body?.data?.[0]?.embedding;
-  return Array.isArray(vec) && vec.length ? Array.from(vec) : null;
+  if (!Array.isArray(vec) || !vec.length) {
+    return { vector: null, reason: "response-no-vector" };
+  }
+  return { vector: Array.from(vec), reason: null };
 }
 
 /**
@@ -69,9 +106,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 +164,45 @@ 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})`);
+    const detailed = await embedTextDetailed(cfg, text);
+    if (detailed.reason) {
+      // 回执带上可区分的失败模式（http-404 / request-failed:timeout /
+      // config-incomplete:model / response-no-vector ...），不再把「模型没配」
+      // 「请求挂了」「响应没有向量」压成同一个词。状态页与日志按 reason 分诊。
+      const entry = { status: "failed", id, at, reason: detailed.reason };
+      ledger.record(entry);
+      logger?.warn?.(`[dsh-mneme] embed memory ${id} failed: ${detailed.reason}`);
+      return entry;
     }
+    const vector = detailed.vector;
+    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 +225,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 +276,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: "敏感度" },