@modusensus/dsh-mneme 0.8.16 → 0.9.0

package/lib/tools.js

@@ -7,6 +7,7 @@ import { matchesPlatform } from "./runtime/closure.js";
 import { verifyPayload } from "./runtime/verify.js";
 import { TOOL_GUIDE, CONTINUITY_TOOL_RULE } from "./guide.js";
 import { injectChildEnabled } from "./config.js";
+import { lastUserQuery } from "./inject.js";
 
 const TEXT_OUTPUT = (text) => [{ type: "text", text }];
 // Per-registry tool-name registry: guards against duplicate registration on
@@ -381,6 +382,14 @@ export function createTools(ctx, service, config, embedder) {
         render: (_args, value) => TEXT_OUTPUT(`Updated memory ${value.memory.id}: ${value.memory.title}`)
       },
       async execute(args) {
+        // v0.9.0：失败表的 query 是「当时到底想干什么」唯一的落点，而 service
+        // 层看不到会话（它只认 ctx.query，见 src/service.js 的 saveFailure 注释）。
+        // 工具层是唯一同时握着改写动作与本轮会话的入口：没给 reason 就退回当轮用户
+        // 原话，取法与注入侧共用同一份实现（src/inject.js 的 lastUserQuery），不复制
+        // 第二份。两边都取不到时仍然写 NULL——空串会假装「有意图」，NULL 才说实话。
+        const exec = arguments[1];
+        const reason = typeof args.reason === "string" ? args.reason.trim() : "";
+        const query = reason || lastUserQuery(exec) || undefined;
         const memory = service.update(args.id, {
           title: args.title,
           content: args.content,
@@ -389,10 +398,10 @@ export function createTools(ctx, service, config, embedder) {
           importance: args.importance,
           // 复核项 4（#170）：strictScope 下他 scope 的行按「不存在」处理（与 get 对齐），
           // 展开恒为 undefined，仅承担写入前校验。
-          ...(assertVisibleForTool(args.id, arguments[1])),
+          ...(assertVisibleForTool(args.id, exec)),
           ...(args.agent_scope !== undefined ? { agent_scope: args.agent_scope } : {}),
           ...(args.workspace_scope !== undefined ? { workspace_scope: args.workspace_scope } : {})
-        }, { query: args.reason });
+        }, { query });
         return { memory: { id: memory.id, title: memory.title, content: memory.content } };
       }
     }),

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, 9 model tools, automatic injection, session summarization, user profile/rules, custom slash commands, vector (semantic) search, and a Web GUI panel",
-  "version": "0.8.16",
+  "version": "0.9.0",
   "license": "MIT",
   "repository": {
     "type": "git",

package/scripts/publish-gate.mjs

@@ -0,0 +1,197 @@
+// 发布闸门：publish 步之后**必须**确认这个版本真的能被 registry 看见，看不见就整轮失败。
+//
+// 为什么需要它：原先这一步是
+//   echo "Published: $(npm view "@modusensus/dsh-mneme@${V}" version)"
+// 命令替换里的失败**不会**让 `set -e` 退出。v0.8.16 那次日志白纸黑字写着
+// `npm error code E404 / 404 No match found for version 0.8.16`，step 与 job 却都是绿的。
+// 也就是说「真发不出去」（token 失效、权限不足、npm 侧拒绝）与「发出去了」在 CI 上是同一种
+// 颜色，只有人翻日志才看得出来 —— 闸门的意义恰恰是没人翻日志的时候。
+//
+// 为什么是轮询而不是一次性查询：registry 有传播延迟，v0.8.16 实测 publish 到可见约 4.5 分钟
+// （11:15:52Z → 11:20:22Z）。一次性查询只有两种结局：忽略失败（就是现在的假绿），或者拿传播
+// 延迟当发布失败（假红）。幂等跳过那条路径（版本已存在）**首次探测即通过**，所以只有真发新版
+// 才付等待成本。
+//
+// 为什么探测走 registry 公开 HTTP 面而不是 `npm view`：不依赖 .npmrc 里的 token、不依赖 npm CLI
+// 的 E404 语义，而且能把「还没传播」与「网络异常」分开报出来 —— 两种都重试，但日志里要能区分，
+// 否则排障时又得靠猜。
+//
+// 与 scripts/changelog-prep.mjs 同一个理由：逻辑收在可注入的模块里才测得到（probe/sleep/now 全
+// 可注入，单测零网络零等待），入口只负责读参数与决定退出码。
+
+import { pathToFileURL } from "node:url";
+
+export const PACKAGE_NAME = "@modusensus/dsh-mneme";
+export const REGISTRY_ORIGIN = "https://registry.npmjs.org";
+
+/** 默认 10 分钟：实测传播 ~4.5 分钟，留一倍余量；超时=发布失败，宁可红也不许假绿。 */
+export const DEFAULT_TIMEOUT_MS = 10 * 60 * 1000;
+/** 默认 15 秒：一次发布最多 40 次探测，日志行数与 registry 负载都可接受。 */
+export const DEFAULT_INTERVAL_MS = 15 * 1000;
+/** 单次探测的 HTTP 超时：挂死的请求必须自己失败，不能吃掉整段预算。 */
+export const DEFAULT_PROBE_TIMEOUT_MS = 15 * 1000;
+
+/**
+ * 单版本的 registry URL。scoped 包名必须整体 encodeURIComponent（`@scope/name` → `%40scope%2Fname`）：
+ * 直接拼裸 `/` 会被当成路径分隔符，registry 回 404 —— 那正是「闸门自己造成的假红」。
+ */
+export function versionUrl(name, version, origin = REGISTRY_ORIGIN) {
+  return `${origin.replace(/\/+$/, "")}/${encodeURIComponent(name)}/${encodeURIComponent(version)}`;
+}
+
+/**
+ * 探测一次「该版本是否已在 registry 上」。
+ *
+ * 永不抛错：任何异常都折成 `{ok:false, reason, detail}`，让上层的重试与超时逻辑保持单一形状。
+ * `reason` 取值：`missing`(404，多半是还没传播) / `network`(请求本身失败) / `http`(非 2xx/404) /
+ * `bad-json` / `mismatch`(200 但版本号对不上)。
+ *
+ * @param {string} version 如 "0.8.16"
+ * @param {{name?: string, origin?: string, fetchImpl?: typeof fetch, timeoutMs?: number}} [options]
+ * @returns {Promise<{ok: true, version: string, tarball: string} | {ok: false, reason: string, detail: string}>}
+ */
+export async function probeVersion(version, {
+  name = PACKAGE_NAME,
+  origin = REGISTRY_ORIGIN,
+  fetchImpl = globalThis.fetch,
+  timeoutMs = DEFAULT_PROBE_TIMEOUT_MS
+} = {}) {
+  const url = versionUrl(name, version, origin);
+  let response;
+  try {
+    response = await fetchImpl(url, {
+      headers: { accept: "application/json" },
+      signal: AbortSignal.timeout(timeoutMs)
+    });
+  } catch (error) {
+    return { ok: false, reason: "network", detail: `请求失败：${error?.message ?? error}（${url}）` };
+  }
+  if (response.status === 404) {
+    return { ok: false, reason: "missing", detail: `HTTP 404，registry 上还看不到（${url}）` };
+  }
+  if (!response.ok) {
+    return { ok: false, reason: "http", detail: `HTTP ${response.status}（${url}）` };
+  }
+  let body;
+  try {
+    body = await response.json();
+  } catch (error) {
+    return { ok: false, reason: "bad-json", detail: `响应不是 JSON：${error?.message ?? error}` };
+  }
+  if (body?.version !== version) {
+    return { ok: false, reason: "mismatch", detail: `registry 返回的版本是 ${body?.version ?? "(缺失)"}` };
+  }
+  return { ok: true, version, tarball: body?.dist?.tarball ?? "" };
+}
+
+/**
+ * 轮询到版本可见为止；超时即 `{ok:false, reason:"timeout"}`。
+ *
+ * 契约（单测锁的就是这条）：**看不见就绝不返回 ok:true**。任何把超时折叠成成功、或者把
+ * 「探测失败」当成「跳过校验」的改法，都等于退回 v0.8.16 那种假绿。
+ *
+ * @param {string} version
+ * @param {{name?: string, origin?: string, timeoutMs?: number, intervalMs?: number,
+ *          now?: () => number, sleep?: (ms: number) => Promise<void>,
+ *          probe?: () => Promise<{ok: boolean, detail?: string}>, log?: (line: string) => void}} [options]
+ */
+export async function waitForPublished(version, {
+  name = PACKAGE_NAME,
+  origin = REGISTRY_ORIGIN,
+  timeoutMs = DEFAULT_TIMEOUT_MS,
+  intervalMs = DEFAULT_INTERVAL_MS,
+  now = () => Date.now(),
+  sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms)),
+  probe = () => probeVersion(version, { name, origin }),
+  log = () => {}
+} = {}) {
+  const startedAt = now();
+  let attempts = 0;
+  let lastError = "";
+  for (;;) {
+    attempts += 1;
+    const result = await probe();
+    // 探测成功即算通过，**不再回头比期限**：预算是「等多久才放弃」，不是「多久之后就算没发布」。
+    // 单次探测自带 HTTP 超时（默认 15 秒），所以晚到的成功最多超出预算十几秒；而版本真的在
+    // registry 上就等于发布成功，因为晚到几秒把它判红才是假红——这个闸门存在的理由正是消灭
+    // 假绿，不该顺手制造另一种失真。反过来，探测失败仍严格按预算收口（见下）。
+    if (result?.ok) {
+      return { ok: true, version, attempts, waitedMs: now() - startedAt, tarball: result.tarball ?? "" };
+    }
+    lastError = result?.detail ?? "未知原因";
+    const waitedMs = now() - startedAt;
+    log(`第 ${attempts} 次探测（已等 ${Math.round(waitedMs / 1000)}s）：${lastError}`);
+    if (waitedMs >= timeoutMs) {
+      return { ok: false, reason: "timeout", attempts, waitedMs, lastError };
+    }
+    // 只睡到预算耗尽为止：最后一次探测落在超时点上，不额外多睡一整轮。
+    await sleep(Math.min(intervalMs, timeoutMs - waitedMs));
+  }
+}
+
+/**
+ * 入口参数：位置参数是版本号，另可覆盖 `--timeout-ms` / `--interval-ms`（排障与手动跑用）。
+ * 缺版本号如实回报 `missing-version`，由入口打印用法并退出 1。
+ */
+export function parseArgs(argv = []) {
+  const out = { version: "", timeoutMs: DEFAULT_TIMEOUT_MS, intervalMs: DEFAULT_INTERVAL_MS };
+  const positional = [];
+  for (let i = 0; i < argv.length; i += 1) {
+    const arg = argv[i];
+    if (arg === "--timeout-ms" || arg === "--interval-ms") {
+      const key = arg === "--timeout-ms" ? "timeoutMs" : "intervalMs";
+      const value = Number(argv[i + 1]);
+      if (!Number.isFinite(value) || value <= 0) return { ok: false, reason: `${arg} 需要一个正数` };
+      out[key] = value;
+      i += 1;
+      continue;
+    }
+    positional.push(arg);
+  }
+  if (positional.length !== 1) return { ok: false, reason: "missing-version" };
+  out.version = positional[0];
+  return { ok: true, ...out };
+}
+
+/** 入口：CI 与手动都用它；失败一律 `process.exit(1)`，绝不吞掉。 */
+export async function main(argv = process.argv.slice(2), {
+  log = console.log,
+  error = console.error,
+  wait = waitForPublished
+} = {}) {
+  const parsed = parseArgs(argv);
+  if (!parsed.ok) {
+    error(`用法：node scripts/publish-gate.mjs <版本号> [--timeout-ms 600000] [--interval-ms 15000]`);
+    error(`参数有误：${parsed.reason}`);
+    return 1;
+  }
+  log(`等待 ${PACKAGE_NAME}@${parsed.version} 在 registry 上可见（最多 ${parsed.timeoutMs / 1000}s）…`);
+  const result = await wait(parsed.version, {
+    timeoutMs: parsed.timeoutMs,
+    intervalMs: parsed.intervalMs,
+    log
+  });
+  if (!result.ok) {
+    error(
+      `发布闸门未通过：${PACKAGE_NAME}@${parsed.version} 在 ${Math.round(result.waitedMs / 1000)}s 内` +
+      `（${result.attempts} 次探测）始终看不到 —— 最后一次：${result.lastError}`
+    );
+    error(`publish 步很可能失败了（token 失效 / 权限不足 / npm 侧拒绝），请翻上面 publish 步的日志。`);
+    return 1;
+  }
+  const waitedSec = Math.round(result.waitedMs / 1000);
+  log(`✓ ${PACKAGE_NAME}@${result.version} 已在 registry 上可见（第 ${result.attempts} 次探测，等了 ${waitedSec}s）`);
+  if (result.tarball) log(`  tarball: ${result.tarball}`);
+  return 0;
+}
+
+// import 即执行会让单测没法只 import 纯函数（changelog-prep.mjs 的同一教训），故用主模块判别。
+// 比较用 pathToFileURL：手拼 `file://${argv[1]}` 在本机（Windows 盘符 + 非 ASCII 路径）拼不出合法 URL，
+// 判别会恒假 —— 那样的失败是静默的：脚本什么也不做，还退出 0。
+//
+// 用 `process.exitCode` 而不是 `process.exit()`：刚做完 HTTP 请求就硬退，会在 Windows 上撞到
+// libuv 的 `Assertion failed: !(handle->flags & UV_HANDLE_CLOSING)`（实测 0.8.16 成功路径复现），
+// 退出码变成 0xC0000409 而不是 0 —— 一个把成功报成崩溃的退出路径，正好与本次要修的假绿同类。
+if (process.argv[1] && import.meta.url === pathToFileURL(process.argv[1]).href) {
+  process.exitCode = await main();
+}

package/src/api.js

@@ -1,16 +1,19 @@
 import { URL } from "node:url";
+import { isAbsolute } from "node:path";
 import { timingSafeEqual, randomBytes } from "node:crypto";
 import { FEATURE_FLAG_SPEC } from "./settings.js";
 import { TYPES } from "./store.js";
 import { TYPE_FILE, renderMirrorText, renderFileHeader, parseHumanEdits, MIRROR_READONLY_TYPES } from "./mirror.js";
 import { langOf } from "./lang.js";
 import { computeHeat } from "./heat.js";
-import { describeStreamFailure, resolveRoute } from "./dream.js";
+import { EFFORT_REJECT_RE, describeStreamFailure, resolveRoute, withEffortFallback } from "./dream.js";
 import { getInjectionSnapshot } from "./inject.js";
 import { describeLocalRuntime, publicRuntimeStatus } from "./runtime/loader.js";
 import { hostModulesDir, provisionRuntime } from "./runtime/provision.js";
 import { classify, fetchLatestVersion, PACKAGE_VERSION } from "./version-check.js";
 import { parseReclaimQuery, parseReclaimJson, readReclaimFields, reclaimReply, RECLAIM_UNAVAILABLE } from "./reclaim-http.js";
+import { readPipelineDoc } from "./pipeline.js";
+import { readCandidateDoc } from "./candidates.js";
 
 // headers：少数端点（/export 附件下载）需要追加 Content-Disposition 等响应头。
 function sendJson(res, status, payload, headers = {}) {
@@ -376,13 +379,30 @@ export function createApi(ctx, service, settings, commands, embedder, semantic =
   // the same error wording the audit rows carry. Optional reasoningEffort
   // mirrors what the consolidation would send — the panel can verify a model
   // actually accepts the configured effort without tripping a full run.
+  //
+  // 档位被拒时探针必须和真实 run 一样降级：这里是全仓唯一「接受并转发调用方档位、
+  // 却此前没有兜底」的调用面——巩固/睡眠/蒸馏/总览/实体抽取都包在 withEffortFallback
+  // 里，档位被拒就丢掉字段重试一次（issue #9/#109/#135）。直调 llm.stream 的其余各面
+  // 要么本来就在兜底之内（dream.js/summarize.js/sleep.js 的共用辅助），要么是
+  // src/index.js 的手写版兜底，要么像 pre-inject-gate 的判定池那样根本不转发档位。
+  // 探针原先没有这层，于是同一份配置「后台真的跑得通、点一下测试就报红」，把用户
+  // 引向「换哪家 Provider 都失败」的错误诊断（issue #215 的后续）。降级跑通后响应带
+  // effortDropped:true，面板据此说明「档位不被接受、已按无档位连通」，而不是与「真的
+  // 连不上」同色。
   async function testLlmConnectivity(llm, provider, model, reasoningEffort) {
     const startedAt = Date.now();
     const elapsed = () => Date.now() - startedAt;
     const modelId = `${provider}:${model}`;
-    try {
+    // 流级失败原因：withEffortFallback 只用它做拒收甄别，回给面板的仍是同一条
+    // describeStreamFailure 文案（与审计行同口径，不制造第二套措辞）。
+    let streamError = "";
+    // 降级标记刻意放在 attempt 之外：fallback 里置位、attempt 里读出，结果对象
+    // 据此带上 effortDropped——降级是「换个姿势跑通了」，不是失败。
+    let droppedEffort = false;
+
+    const attempt = async (effort) => {
+      streamError = "";
       let reply = "";
-      let error = "";
       for await (const chunk of llm.stream({
         provider,
         model,
@@ -391,7 +411,7 @@ export function createApi(ctx, service, settings, commands, embedder, semantic =
         // reply 恒为空，「真的答了 ok」对思考模型不成立。按实际用量计费，手动
         // 按钮无放大风险。
         maxTokens: 1024,
-        ...(reasoningEffort && reasoningEffort !== "none" ? { reasoningEffort } : {}),
+        ...(effort && effort !== "none" ? { reasoningEffort: effort } : {}),
         // role 用 user 而非 system（#189 后续）：0.1.6-alpha.1 起适配器把 system
         // 抽成顶层参数，system-only 对话会被官方 API 以
         // 「messages: at least one message is required」整单拒绝——探测按钮 502。
@@ -406,12 +426,39 @@ export function createApi(ctx, service, settings, commands, embedder, semantic =
       })) {
         if (chunk.type === "text-delta" && typeof chunk.text === "string") reply += chunk.text;
         if (chunk.type === "finish" && (chunk.reason?.kind === "error" || chunk.reason?.kind === "aborted")) {
-          error = describeStreamFailure(chunk.reason);
+          streamError = describeStreamFailure(chunk.reason);
           break;
         }
       }
-      if (error) return { ok: false, durationMs: elapsed(), error, modelId };
-      return { ok: true, durationMs: elapsed(), modelId, reply: reply.trim().slice(0, 100) };
+      const dropped = droppedEffort ? { effortDropped: true } : {};
+      if (streamError) {
+        // 只在「确实带了档位」时把流级拒收交回给 withEffortFallback 的 undefined
+        // 分支——rc.1 的适配器不抛错，把 provider 的拒收折叠成终止 finish chunk，
+        // 不看这里那次重试就是死代码。不带档位时原样上报：探针不该因为一句文案
+        // 没匹配上正则就退化成 500。
+        if (effort && effort !== "none" && EFFORT_REJECT_RE.test(streamError)) return undefined;
+        // 失败行不带 effortDropped：该字段只有一个含义——「连通了，但不是用你配的
+        // 档位连通的」（见下方成功分支的注释），失败时它只是噪音。
+        return { ok: false, durationMs: elapsed(), error: streamError, modelId };
+      }
+      return { ok: true, durationMs: elapsed(), modelId, reply: reply.trim().slice(0, 100), ...dropped };
+    };
+
+    try {
+      const result = await withEffortFallback(
+        ctx,
+        reasoningEffort,
+        () => attempt(reasoningEffort),
+        () => { droppedEffort = true; return attempt(""); },
+        () => streamError
+      );
+      // result === undefined 只可能来自上面那次「判据一致」的主动交还（两边用同
+      // 一份 EFFORT_REJECT_RE，走到这里等于假设被推翻）：退回已捕获的流失败原
+      // 因，绝不让探针 500。
+      if (result === undefined) {
+        return { ok: false, durationMs: elapsed(), error: streamError || "no stream result", modelId };
+      }
+      return result;
     } catch (error) {
       return { ok: false, durationMs: elapsed(), error: String(error?.message ?? error), modelId };
     }
@@ -1596,8 +1643,77 @@ export function createApi(ctx, service, settings, commands, embedder, semantic =
     }
   });
 
+  // --- M.O.（Modus Operandi · 手法）工作流 ---
+  // 只读端点，读的是**项目里**的 `<项目>/.mneme/pipelines/*.json`（文件头在
+  // src/pipeline.js），项目层优先、插件包里那份降级成全局层；投影成
+  // mneme.pipeline/v1 交给面板与 agent——两边读同一份，画面只是它的投影。
+  // 刻意不做旗标闸门：旗标管的是**客户端座位**（关=一个座位都不注册），不是数据面；
+  // 多一个只读端点不会让任何人看见它，而给它加闸门只会让「为什么面板打不开」多一种成因。
+  register({
+    kind: "exact",
+    path: "/api/dsh-mneme/pipeline",
+    handler(req, res) {
+      try {
+        const url = new URL(req.url, "http://localhost");
+        const id = url.searchParams.get("id") || null;
+        const project = url.searchParams.get("project");
+        // project 是**会话工作目录**，由面板侧解析后带过来——工作目录只有客户端拿得到
+        // （宿主会话头里的 header.cwd），服务端没有「当前项目」这个概念。
+        // 不是绝对路径就**拒掉**，不能忽略：忽略了会静默退成「全局」，而全局看起来
+        // 一切正常——那正是这版要修掉的那类错。
+        if (project !== null && !isAbsolute(project)) {
+          sendJson(res, 400, { error: "project-not-absolute", detail: project });
+          return;
+        }
+        sendJson(res, 200, readPipelineDoc({ projectRoot: project, id }));
+      } catch (error) {
+        // 工作流是人手写的 JSON，报错本身就是给人看的：说清哪一条、坏在哪，
+        // 而不是回一句 internal 让人去翻日志。
+        sendJson(res, 500, {
+          error: "pipeline-unreadable",
+          detail: String((error && error.message) || error)
+        });
+      }
+    }
+  });
+
+  // --- M.O. 候选层（绕行走出来、还没进仓库的那些路） ---
+  // 和 /pipeline 读的是两处不同的东西，别混：
+  //   /pipeline    定稿，住**仓库**（<项目>/.mneme/pipelines/），可提交、可 review
+  //   /candidates  候选，住**本地**（<memoryDir>/candidates/<项目键>/），随时长、随时扔
+  // 分开是刻意的：候选是草稿，一天可能长十条死九条，进仓库就是垃圾；
+  // 而定稿只放人亲手批过的东西——候选是定稿的唯一入口。
+  //
+  // 这一刀只给**读**：提议与批准的动作还没有落点（那要等执行侧）。
+  // 契约里显式写着 boundaries.autoPromote/autoApprove/injectIntoMemory 三个 false，
+  // 免得以后有人以为忘了做。
+  register({
+    kind: "exact",
+    path: "/api/dsh-mneme/candidates",
+    handler(req, res) {
+      try {
+        const url = new URL(req.url, "http://localhost");
+        const project = url.searchParams.get("project");
+        if (project !== null && !isAbsolute(project)) {
+          sendJson(res, 400, { error: "project-not-absolute", detail: project });
+          return;
+        }
+        // memoryDir 从 config 拿（与 store 同源）；取不到就退回默认，与 config.js 的默认值一致。
+        const memoryDir = (config && typeof config.memoryDir === "string" && config.memoryDir.trim())
+          ? config.memoryDir
+          : "~/.dsh/memory";
+        sendJson(res, 200, readCandidateDoc({ memoryDir, projectRoot: project }));
+      } catch (error) {
+        sendJson(res, 500, {
+          error: "candidates-unreadable",
+          detail: String((error && error.message) || error)
+        });
+      }
+    }
+  });
+
   return {
-    routes: 34,
+    routes: 36,
     dispose: () => {
       for (const dispose of disposers) dispose();
     }