@modusensus/dsh-mneme 0.8.13 → 0.8.14

package/src/api-standalone.js

@@ -1,4 +1,4 @@
-// Standalone HTTP API (v0.7.12): a plain node:http server for ecosystem
+// Standalone HTTP API: a plain node:http server for ecosystem
 // integrations that live outside the DSH host and cannot reach the plugin's
 // internal webServer routes (/api/dsh-mneme/*). Mirrors the JSON semantics of
 // those routes but with mandatory Bearer-token auth on everything except
@@ -17,12 +17,10 @@ import { createServer } from "node:http";
 import { randomBytes, timingSafeEqual } from "node:crypto";
 import { TYPES } from "./store.js";
 import { bootstrapFromDirectory } from "./bootstrap.js";
+import { PACKAGE_VERSION } from "./version-check.js";
 
 const DEFAULT_PORT = 8790;
 const DEFAULT_HOST = "127.0.0.1";
-// Hardcoded release version (package.json is bumped at publish time and may
-// lag the code that ships in between).
-const VERSION = "0.7.12";
 const MAX_PORT_ATTEMPTS = 20;
 
 /**
@@ -30,8 +28,13 @@ const MAX_PORT_ATTEMPTS = 20;
  * the next MAX_PORT_ATTEMPTS-1 ports, and finally falls back to port 0 so the
  * OS assigns a free port. Multiple DSH profiles/instances sharing the default
  * port no longer leave the standalone API permanently unavailable.
+ *
+ * strictPort opts out of that recovery (dsh-mneme-serve daemon, #363): a
+ * long-lived third-party integration pins the URL, so silently hopping ports
+ * would make clients talk to nothing (or, worse, to a future different data
+ * plane). A busy configured port is a configuration error there — fail loud.
  */
-function listenWithRetry(server, startPort, host, logger) {
+function listenWithRetry(server, startPort, host, logger, strictPort = false) {
   return new Promise((resolve, reject) => {
     let attempt = 0;
     const tryListen = (port) => {
@@ -42,6 +45,10 @@ function listenWithRetry(server, startPort, host, logger) {
       };
       const onError = (error) => {
         server.off("listening", onListening);
+        if (error?.code === "EADDRINUSE" && strictPort) {
+          reject(error);
+          return;
+        }
         if (error?.code === "EADDRINUSE" && attempt < MAX_PORT_ATTEMPTS - 1) {
           attempt++;
           const next = startPort + attempt;
@@ -186,18 +193,70 @@ async function handlePutBody(res, service, logger, id, text) {
   sendJson(res, 200, { memory: service.toApiList([service.getById(id)])[0] });
 }
 
+/**
+ * /context 的查询嵌入：best-effort，embedder 接口宽容与 searchMemories 同款
+ * （embedSingle 优先，兼容 embed-only 的 OpenAI 兼容客户端，issue #10）。
+ * 调用方负责 catch——嵌入失败降级规则档，绝不因此 500。
+ */
+async function embedQueryVector(embedder, q) {
+  const embedSingle = typeof embedder.embedSingle === "function"
+    ? embedder.embedSingle.bind(embedder)
+    : typeof embedder.embed === "function"
+      ? embedder.embed.bind(embedder)
+      : null;
+  if (!embedSingle) return undefined;
+  const vector = await embedSingle(q);
+  return Array.isArray(vector) && vector.length ? vector : undefined;
+}
+
+/**
+ * /context 查询嵌入的超时护栏（CodeRabbit on #371）：embedder 挂起（不抛错，
+ * 典型如第三方 ollama/openai 端点无响应）时不能让 HTTP 连接被无限占住——超时
+ * 按嵌入缺失处理，降级规则档。输掉的 embed promise 无法取消、自行结束后被丢弃，
+ * 无害；挂起的主要成本是一个泄漏的挂起任务，可接受。嵌入先完成时清掉定时器
+ * （CodeRabbit 同轮 Minor：别让每个请求都留一枚要等满超时的计时器）。
+ */
+function withEmbedTimeout(promise, timeoutMs) {
+  let timer;
+  const timeout = new Promise((resolve) => {
+    timer = setTimeout(() => resolve(undefined), timeoutMs);
+  });
+  return Promise.race([promise, timeout]).finally(() => clearTimeout(timer));
+}
+
+/**
+ * scope 查询参数（/context 与 /search 同口径，issue #370）：两参全缺 = 返回
+ * undefined（调用方不传 scope 走各自默认，行为与既往逐字节一致）；任一给出则
+ * 缺的一维按「解析不到」（null）走 isVisibleInScope 的 fail-closed——身份不明
+ * 的维度只见全局，不冒认，与宿主会话 scope 解析器同构。
+ */
+function scopeFromSearchParams(url) {
+  const agentScope = url.searchParams.get("agent_scope");
+  const workspaceScope = url.searchParams.get("workspace_scope");
+  if (agentScope === null && workspaceScope === null) return undefined;
+  return { agent_scope: agentScope, workspace_scope: workspaceScope };
+}
+
 /**
  * Create (and start) the standalone API server.
- * Accepts { service, store, config, logger, settings, port, host }:
+ * Accepts { service, store, config, logger, settings, port, host, embedder }:
  *   - token: persisted settings kv "external_api" wins; auto-generated
  *     (crypto.randomBytes(24).toString("base64url")) and persisted when empty.
  *   - port:  explicit arg > persisted settings > config.externalApiPort > 8790.
  *   - host:  explicit arg > config.externalApiHost > "127.0.0.1".
+ *   - strictPort: EADDRINUSE rejects instead of hopping ports (daemon mode;
+ *     default false keeps the in-host sidecar recovery described above).
+ *   - embedder: query-embedding handle for GET /context (issue #370) — same
+ *     instance the caller handed to service.setEmbedder; null degrades /context
+ *     to the rule + BM25 tier. Best-effort: embed failures never fail the route.
+ *   - embedTimeoutMs: /context query-embed guard (default 3000) — a hung
+ *     embedder must not hold the HTTP connection; timeout degrades to the rule
+ *     tier. Factory option (like strictPort), not a user config key.
  * Returns { server, port, host, token, ready }: `port` is the effective bound
  * port (updated to the OS-assigned one after `ready` resolves when asked to
  * bind port 0), `ready` resolves once listening and rejects if the bind fails.
  */
-export function createStandaloneApi({ service, store, config = {}, logger, settings, port, host, maintenance }) {
+export function createStandaloneApi({ service, store, config = {}, logger, settings, port, host, maintenance, strictPort = false, embedder = null, embedTimeoutMs = 3000 }) {
   const persisted = settings?.getExternalApi?.() ?? {};
 
   let token = typeof persisted.token === "string" ? persisted.token : "";
@@ -249,7 +308,7 @@ export function createStandaloneApi({ service, store, config = {}, logger, setti
           entities = store.db.prepare("SELECT count(*) AS c FROM entities").get().c;
         } catch { /* entities storage unavailable → 0 */ }
         sendJson(res, 200, {
-          version: VERSION,
+          version: PACKAGE_VERSION,
           memories: { total: service.count(), byType },
           entities,
           uptime_s: Math.floor(process.uptime())
@@ -517,6 +576,10 @@ export function createStandaloneApi({ service, store, config = {}, logger, setti
         const rerank = url.searchParams.get("rerank") !== "false";
         const occurredFrom = url.searchParams.get("occurred_from") ?? null;
         const occurredTo = url.searchParams.get("occurred_to") ?? null;
+        // scope 透传（issue #370）：searchMemories 本就收 scope，此前 8790 没有
+        // 入口——第三方（daemon 桥接侧）声明身份后，A2 软加权与 strictScope 硬
+        // 过滤才在检索面同样成立；与 /context 同口径（scopeFromSearchParams）。
+        const scope = scopeFromSearchParams(url);
         const query = q.trim();
         if (!query) {
           sendJson(res, 200, { items: [], mode: "keyword" });
@@ -528,6 +591,7 @@ export function createStandaloneApi({ service, store, config = {}, logger, setti
             mode,
             topK: limit,
             useRerank: rerank,
+            ...(scope ? { scope } : {}),
             ...(occurredFrom !== null || occurredTo !== null ? { occurredFrom, occurredTo } : {})
           })
         ).then((rows) => {
@@ -539,6 +603,43 @@ export function createStandaloneApi({ service, store, config = {}, logger, setti
         return;
       }
 
+      // --- GET /context: 注入候选一站式聚合（issue #370，#363 承诺）------------
+      // 给定话题返回「宿主此刻会注入什么」的数据等价物：injectCandidates 全语义
+      // （优先级分层 / 编码门控 / heat / scope 软加权 / hybrid 语义路 / pin 前置，
+      // service.js:1494）+ 画像 + 规则。结构化条目、不含渲染文本——语言 / 时间
+      // 前缀 / 热记忆是宿主会话概念，调用方（Mneme Bridge 等网页端桥接）自行渲染。
+      // 与宿主注入的两点差异都是 HTTP 面的有意为之：① 首次调用即走语义路（宿主
+      // 渲染必须同步，查询向量只能异步 prefetch 给下一轮，inject.js Bug4；这里
+      // 没有该约束）；② 不做跨轮轮换（daemon 无会话状态，调用方自管）。
+      // recall_runs 记账随 injectCandidates 内建（#217：注入是曝光型访问事件，
+      // mode='inject' 与检索命中同表分账）——宿主注入同样记，/context 自动同口径。
+      if (req.method === "GET" && pathname === "/context") {
+        const q = (url.searchParams.get("q") ?? "").trim();
+        const maxItemsRaw = Number(url.searchParams.get("topK") ?? url.searchParams.get("limit") ?? 5);
+        const maxItems = Number.isInteger(maxItemsRaw) && maxItemsRaw > 0 ? maxItemsRaw : 5;
+        // threshold 是 importance 阈值（injectCandidates 语义），与 /search 的
+        // 相似度 threshold 同名不同义——文档已点名，勿混。
+        const thresholdRaw = Number(url.searchParams.get("threshold") ?? 3);
+        const threshold = Number.isFinite(thresholdRaw) ? thresholdRaw : 3;
+        const scope = scopeFromSearchParams(url);
+        void Promise.resolve(q && embedder ? withEmbedTimeout(embedQueryVector(embedder, q), embedTimeoutMs) : undefined)
+          .catch(() => undefined)   // 查询嵌入失败降级规则档（与 searchMemories 同口径）
+          .then((queryVector) => {
+            const pinnedStats = {};
+            const items = service.injectCandidates({ query: q, maxItems, threshold, queryVector, scope, pinnedStats });
+            sendJson(res, 200, {
+              profile: (settings?.getProfile?.() ?? "").trim(),
+              rules: settings?.getRules?.() ?? [],
+              items: service.toApiList(items),
+              pinnedCount: pinnedStats.shown ?? 0
+            });
+          })
+          .catch(() => {
+            sendJson(res, 500, { error: "internal" });
+          });
+        return;
+      }
+
       sendJson(res, 404, { error: "not-found" });
     } catch {
       sendJson(res, 500, { error: "internal" });
@@ -552,7 +653,7 @@ export function createStandaloneApi({ service, store, config = {}, logger, setti
   });
   const ready = new Promise((resolve, reject) => {
     // listening handled by listenWithRetry
-    listenWithRetry(server, boundPort, boundHost, logger).then(resolve, reject);
+    listenWithRetry(server, boundPort, boundHost, logger, strictPort).then(resolve, reject);
   });
   // server.listen is called inside listenWithRetry
   ready.then(() => {

package/src/config.js

@@ -708,6 +708,13 @@ export const Config = z.object({
   // 恒 1，sleep 降级退回纯时间分层。
   // 也走 feature_flags（FEATURE_FLAG_BOOLEANS 白名单），面板可启停=线上回滚开关。
   heatEnabled: z.boolean().default(false),
+  // issue #218 / E5 效用考卷：heat 乘进注入排序在真实年龄混合下饿死老约束
+  // （现行量级 ≡ 拟合参数，注入集逐条相同；importance-only 遵从 +12.7pp），
+  // 故注入侧 heat 改为独立 opt-in：默认关 = heatEnabled 开启后热度字段/sleep
+  // 保护/前端投影照常，但注入排序乘数恒 1（与 heat 关闭逐字节一致）；
+  // 显式开启才恢复「层内乘 heat」的旧序。召回侧时钟（touchLastAccess）与
+  // sleep 降级联判不受本键影响——它们不参与注入排序。
+  injectHeatEnabled: z.boolean().default(false),
   // 广义指数形状参数 β（heat = exp(-λ·Δt^β)，issue #218 拍板）：β=1 纯指数。
   // 快慢以 Δt>1 小时为准——β<1 衰减更慢（亚线性长尾）、β>1 更快（超线性）；
   // 0<Δt<1 的首小时内方向相反（Δt^β 随 β 增大而变小）。专家调优项，不进面板白名单。

package/src/index.js

@@ -19,10 +19,10 @@ import { createStandaloneApi } from "./api-standalone.js";
 import { createMaintenance } from "./maintenance.js";
 import { createSettings } from "./settings.js";
 import { createCommandManager } from "./commands.js";
-import { createEmbedder } from "./embedding.js";
-import { createEmbedderByProvider } from "./local-embedder.js";
-import { LocalReranker } from "./reranker.js";
 import { createVectorIndex } from "./vector-index.js";
+// semantic(embedder/reranker/boot 回填)纯搬移至 src/semantic.js(PR2):宿主与
+// daemon(dsh-mneme-serve,#363)共用同一套装配,原文件保留 barrel 出口。
+import { createSemantic } from "./semantic.js";
 import { Config, applyLightModePreset, injectChildEnabled } from "./config.js";
 import { langOf } from "./lang.js";
 import { extractEntities } from "./entities/extractor.js";
@@ -149,43 +149,9 @@ export function createEntityStreamAdapter({ llm, agentDefaultModel, logger, serv
   };
 }
 
-/**
- * Issue #128: bounded backfill of rows still missing an embedding (active rows
- * only — needsEmbedding filters archived/forgotten). Exported for tests.
- *
- * Runs regardless of the model fingerprint: the old call-site gate returned
- * early when vector_meta already held the embedder's hash, permanently
- * orphaning rows whose embed failed at write time (embedder not ready /
- * provider rate limit) — one successful embed was enough to never backfill
- * again. markModel is idempotent when the fingerprint already matches, so
- * re-running costs nothing beyond the actually-missing rows.
- */
-export async function backfillMissingEmbeddings({
-  store, embedder, vectorIndex, logger,
-  maxTotal = 500, batchSize = 10, rateLimitMs = 200
-}) {
-  let indexed = 0;
-  for (let done = 0; done < maxTotal;) {
-    const rows = store.needsEmbedding(batchSize);
-    if (!rows.length) break;
-    for (const row of rows) {
-      try {
-        const text = [row.title, row.content].filter(Boolean).join("\n");
-        const vector = await embedder.embedSingle(text);
-        if (vector?.length) {
-          store.setEmbedding(row.id, vector);
-          indexed++;
-        }
-      } catch { /* skip the bad row */ }
-    }
-    done += rows.length;
-    // Rate limit: space out batches so the provider is not hammered.
-    if (store.needsEmbedding(1).length) await new Promise((r) => setTimeout(r, rateLimitMs));
-  }
-  if (indexed > 0 && embedder.modelHash) vectorIndex.markModel?.(embedder.modelHash, embedder.dimension);
-  logger?.info?.(`[dsh-mneme] auto-reindex backfilled ${indexed} embeddings on boot`);
-  return indexed;
-}
+// backfillMissingEmbeddings 已随语义装配整体搬至 src/semantic.js(纯搬移);
+// 保留 barrel 再出口 —— test/reindex-backfill.test.js 仍从本模块 import,调用方零改动。
+export { backfillMissingEmbeddings } from "./semantic.js";
 
 export const apply = (ctx, config) => {
   const rawCfg = Config(config);
@@ -339,150 +305,14 @@ export const apply = (ctx, config) => {
     }
   };
 
-  let embedder = null;
-  let reranker = null;
-  // #118: pending embedder-init retry timer, cleared on unload.
-  let embedRetryTimer = null;
-  if (lightMode) {
-    // Light mode: the whole vector pipeline stays off — no embedder (nothing
-    // pulls in ONNX/transformers), no reranker, no boot backfill (the preset
-    // also cleared autoReindexOnBoot). Recall degrades to keyword search and
-    // human mirror edits still merge on boot.
-    applyHumanEdits();
-  } else if (cfg.embedProvider === "openai") {
-    // vectorIndex is passed so the legacy OpenAI embedder records the producing
-    // model fingerprint after each successful embed (Bug3).
-    embedder = createEmbedder({ store, settings, logger: ctx.logger, vectorIndex });
-    service.setEmbedder(embedder);
-    // issue #135: 未配置时明确告警一次。此前 legacy OpenAI embedder 恒报
-    // ready=true，向量层「绿的但全哑」可以静默存在很久（本机持续了数周）。
-    // 只记日志、不阻断启动：轻量模式与「先跑起来再补配置」都是正当用法。
-    if (embedder.configured === false) {
-      ctx.logger?.warn?.(
-        "[dsh-mneme] 向量层未配置（vector-config 的 enabled/baseUrl/apiKey/model 有缺）："
-        + "语义召回、语义去重、rerank、sleep 冲突检测将静默失效，"
-        + "dream 的语义聚类会退化为全量窗口兜底。"
-        + "请在设置面板补全 embedding 端点与模型，或把 embedProvider 改为 local/ollama。"
-      );
-    }
-    // legacy OpenAI embedder needs no async init → human edits apply right away
-    applyHumanEdits();
-  } else {
-    try {
-      embedder = createEmbedderByProvider(cfg.embedProvider, {
-        model: cfg.embedProvider === "ollama" ? cfg.ollamaModel : cfg.localEmbedModel,
-        dimension: cfg.localEmbedDimension,
-        device: cfg.localEmbedDevice,
-        batchSize: cfg.localEmbedBatchSize,
-        // 池化方式必须与模型的训练口径一致（BGE 系 = CLS）。它既进 embed() 的调用，
-        // 也进 modelHash —— 池化改了就是换向量空间，既有索引会被判失配并重建。
-        pooling: cfg.localEmbedPooling,
-        cacheDir: cfg.embedModelCacheDir,
-        runtimeDir: cfg.runtimeDir,
-        // #188：embedModelMirror 接成 transformers 的下载镜像（此前死配置）。
-        remoteHost: cfg.embedModelMirror,
-        resilientModelDownload: cfg.resilientModelDownload,
-        baseUrl: cfg.ollamaBaseUrl,
-        logger: ctx.logger
-      });
-      service.setEmbedder(embedder);
-      // issue #6: wait for extractor init before applying human edits, so
-      // scheduled embeddings see a ready embedder.
-      const bootEmbedder = () => embedder.init()
-        .then(() => { applyHumanEdits(); return true; })
-        .catch(() => false);
-      // #118: the old one-shot probe permanently degraded search to keyword
-      // when Ollama was briefly unreachable at boot (recoverable only by
-      // restart). Retry briefly (5 attempts total: 1 initial + 4 × 15s);
-      // search degrades to keyword meanwhile because per-query embed failures
-      // are swallowed.
-      bootEmbedder().then((ok) => {
-        if (ok) return;
-        let tries = 4;
-        const retry = () => {
-          if (tries-- <= 0) {
-            ctx.logger?.warn?.("[dsh-mneme] embedder init retries exhausted, search degrades to keyword");
-            service.setEmbedder(null);
-            applyHumanEdits();
-            return;
-          }
-          embedRetryTimer = setTimeout(async () => {
-            if (await bootEmbedder()) return;
-            retry();
-          }, 15_000);
-        };
-        ctx.logger?.warn?.("[dsh-mneme] embedder init failed, retrying");
-        retry();
-      });
-    } catch (error) {
-      ctx.logger?.warn?.(`[dsh-mneme] embedder unavailable, search degrades to keyword: ${String(error)}`);
-      applyHumanEdits();
-    }
-  }
-
-  // Cross-encoder rerank over recall candidates. Best-effort: a failed model
-  // load only disables reranking, never search itself. Explicit opt-in only
-  // (rerankEnabled defaults to false): constructing LocalReranker is what pulls
-  // in onnxruntime, so the default config never loads it (item ⑥).
-  if (cfg.rerankEnabled && cfg.rerankProvider === "local") {
-    try {
-      reranker = new LocalReranker({
-        model: cfg.rerankModel,
-        batchSize: cfg.rerankBatchSize,
-        maxCandidates: cfg.rerankMaxCandidates,
-        scoreThreshold: cfg.rerankScoreThreshold,
-        device: cfg.localEmbedDevice,
-        cacheDir: cfg.embedModelCacheDir,
-        runtimeDir: cfg.runtimeDir,
-        // #188：量化档默认 q8（此前不传 dtype 会去要 1GB 级 fp32 模型）；
-        // embedModelMirror 此前是死配置，现接成 transformers 的下载镜像。
-        useDtype: cfg.rerankDtype,
-        remoteHost: cfg.embedModelMirror,
-        resilientModelDownload: cfg.resilientModelDownload,
-        logger: ctx.logger
-      });
-      service.setReranker(reranker);
-      reranker.init().catch((error) => {
-        ctx.logger?.warn?.(`[dsh-mneme] reranker init failed, rerank disabled: ${String(error)}`);
-        service.setReranker(null);
-      });
-    } catch (error) {
-      ctx.logger?.warn?.(`[dsh-mneme] reranker unavailable, rerank disabled: ${String(error)}`);
-    }
-  }
-
-  // Bug2: lazy auto-backfill of missing embeddings on boot. When the vector API
-  // is configured and rows still lack an embedding (e.g. written before vector
-  // search was enabled), the backfill runs in the background after a short
-  // delay. Gated on cfg.autoReindexOnBoot; rate-limited in small batches so a
-  // large backlog never floods the provider. Failures degrade silently —
-  // search stays keyword.
-  function scheduleAutoReindex() {
-    if (cfg.autoReindexOnBoot === false) return;
-    const attempt = (tries) => {
-      try {
-        if (!embedder || typeof embedder.embedSingle !== "function") return;
-        if ("ready" in embedder && embedder.ready !== true) {
-          // Local/ollama embedders init asynchronously; give them a moment
-          // before giving up on this boot (next boot retries).
-          if (tries > 0) setTimeout(() => attempt(tries - 1), 2000);
-          return;
-        }
-        if (!store.needsEmbedding(1).length) return; // nothing to backfill
-        // Issue #128: no fingerprint gate here anymore — a matching fingerprint
-        // used to return early and permanently orphan rows whose embed failed
-        // at write time. See backfillMissingEmbeddings().
-        backfillMissingEmbeddings({ store, embedder, vectorIndex, logger: ctx.logger })
-          .catch((error) => {
-            ctx.logger?.warn?.(`[dsh-mneme] auto-reindex failed: ${String(error)}`);
-          });
-      } catch (error) {
-        ctx.logger?.warn?.(`[dsh-mneme] auto-reindex failed: ${String(error)}`);
-      }
-    };
-    setTimeout(() => attempt(5), 5000);
-  }
-  scheduleAutoReindex();
+  // embedder/reranker/boot 回填装配已整体搬至 src/semantic.js(纯搬移,宿主与 daemon
+  // 共用):调用时序(applyHumanEdits 在各分支的触发点、#118 重试、autoReindexOnBoot)
+  // 原样保留在 createSemantic 内部,这里只拿引用。init 全失败的 embedder 引用仍会进入
+  // dream/sleep 的 semantic 面 —— 与搬移前一致:检索侧 setEmbedder(null) 降级关键词。
+  const semantic = createSemantic({
+    store, service, settings, cfg, logger: ctx.logger, vectorIndex, applyHumanEdits, lightMode
+  });
+  const { embedder, reranker } = semantic;
 
   // Custom commands: register persisted commands into the DSH command registry
   // on boot; add/remove re-register live through the API.
@@ -601,7 +431,7 @@ export const apply = (ctx, config) => {
 
   // #118: never let a pending embedder init retry fire after unload and touch
   // a torn-down context.
-  disposers.push(() => { if (embedRetryTimer !== null) clearTimeout(embedRetryTimer); });
+  disposers.push(() => semantic.dispose());   // #118 重试计时器 + boot 回填计时器(搬入 semantic.js 后由它自持)
 
   ctx.inject(["systemPrompt"], (promptCtx) => {
     if (cfg.autoInject) disposers.push(createInjector(promptCtx, service, settings, cfg));
@@ -649,7 +479,9 @@ export const apply = (ctx, config) => {
   // kv and is auto-generated on first boot by createStandaloneApi. Binding a
   // non-loopback host is the operator's documented responsibility.
   if ((settings.getExternalApi?.()?.enabled ?? cfg.externalApiEnabled) === true) {
-    const standalone = createStandaloneApi({ service, store, config: cfg, logger: ctx.logger, settings, maintenance });
+    // embedder 交给 /context 的查询嵌入（issue #370）：与 service.setEmbedder 同一
+    // 实例（semantic.js 装配产物），lightMode 下为 null，路由侧降级规则档。
+    const standalone = createStandaloneApi({ service, store, config: cfg, logger: ctx.logger, settings, maintenance, embedder });
     disposers.push(() => standalone.server.close());
     standalone.ready.catch((error) => {
       ctx.logger?.warn?.(`[dsh-mneme] standalone API failed to start: ${String(error)}`);