@modusensus/dsh-mneme 0.10.1 → 0.12.0

package/src/api.js

@@ -3,10 +3,12 @@ import { isAbsolute } from "node:path";
 import { existsSync, readdirSync } from "node:fs";
 import { homedir } from "node:os";
 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";
+// op 形状谓词单一份（评审 P3：两份皮会让形状修洞漏一边）。
+import { isValidFactOps } from "./profile-facts.js";
 import { computeHeat } from "./heat.js";
 import { EFFORT_REJECT_RE, describeStreamFailure, resolveRoute, withEffortFallback } from "./dream.js";
 // Issue #521：面板要按归一化原因显示 skipped，归一化只有一份实现（住在
@@ -19,6 +21,14 @@ 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";
+// Issue #386 第 6 条：从目录引导（bootstrap）在面板侧也要有入口。协议层口径只在
+// bootstrap-http.js 里写一份，与 Bearer 数据面共用（#411 那条纪律：两张皮只许剩
+// 鉴权与路径不同）。
+import { parseBootstrapJson, readBootstrapDir, bootstrapReply, BOOTSTRAP_UNAVAILABLE } from "./bootstrap-http.js";
+import { bootstrapFromDirectory } from "./bootstrap.js";
+// Issue #386 第 7 条：面板能改的键 vs schema 里存在的键，两份清单的唯一算法在这里。
+// 这里引的是同一份（不是照抄），谁改白名单都对得上。
+import { describeConfigKeys, flagKeysFromSpec } from "./config-keys.js";
 import { parseShareBody, shareReply, shareFilename, parseReceiveBody, receiveReply, parseUndoBody, undoReply } from "./share-http.js";
 import { readPipelineDoc, loadPipelines, projectPipelineDir } from "./pipeline.js";
 import { loadRunsById, runsDir, RUNS_SUFFIX } from "./pipeline-runs.js";
@@ -189,7 +199,10 @@ function parseBody(text) {
 // maintenance 是第 9 个位置参数，默认 null：既有调用点（测试里的 14 处）全是位置传参、
 // 不传它，必须继续工作——不传时 /maintenance/reclaim 回 503 maintenance-unavailable，
 // 而不是把「没接线」伪装成崩溃（#386 第 4 条）。
-export function createApi(ctx, service, settings, commands, embedder, semantic = null, apiToken = "", config = null, maintenance = null, profileExtract = null) {
+// choro（M1）：chorography 读侧查询对象（createChoroQueries 产物）。缺省 null =
+// 宿主内 API 在 headless/测试环境没有接 queries，choro 路由回 503。它与 service
+// 刻意分开传——chorography 的所有权模型与记忆域相反（spec §3），不塞进 service。
+export function createApi(ctx, service, settings, commands, embedder, semantic = null, apiToken = "", config = null, maintenance = null, profileExtract = null, choro = null, facts = null) {
   const disposers = [];
 
   // #182 注入状态探测：面板状态页的「极简模式下注入按宿主设计关闭」提示需要
@@ -231,14 +244,10 @@ export function createApi(ctx, service, settings, commands, embedder, semantic =
   // **反推不出待重启**，必须另比一次冻结值——这是本字段存在的唯一理由。
   // 只报「显式覆盖 ≠ 冻结值」的键：未被覆盖的键运行时值就是 cfg 值，不存在落差；
   // config 缺席（旧调用方直连、未传 cfg）时无从比较，返回空数组而不编造。
-  const flagKeys = [
-    ...FEATURE_FLAG_SPEC.booleans,
-    ...Object.keys(FEATURE_FLAG_SPEC.ints),
-    ...Object.keys(FEATURE_FLAG_SPEC.numbers),
-    ...FEATURE_FLAG_SPEC.strings,
-    ...FEATURE_FLAG_SPEC.urls,
-    ...Object.keys(FEATURE_FLAG_SPEC.enums)
-  ];
+  // 顺序见 config-keys.js 的 flagKeysFromSpec（booleans → ints → numbers → strings
+  // → urls → enums）。这张表曾经在这里手拼一遍，第 7 条把「面板能改哪些键」做成
+  // 对外清单之后，两处各算一份就会立刻分歧——所以搬进模块，这里只引。
+  const flagKeys = flagKeysFromSpec();
   // 嵌套键在 kv 里按点号平铺（"memoryQualityFilter.enabled"），运行时 cfg 里
   // 是嵌套对象，effective 从对象子字段取值；其余键照旧从 cfg 顶层取。
   // 这张表必须与 settings.js 白名单里的点号键一一对应：#254 加键时漏了这里，
@@ -589,7 +598,10 @@ export function createApi(ctx, service, settings, commands, embedder, semantic =
         const preview = renderUserSettingsBlock({
           settings,
           config,
-          agentId: url.searchParams.get("agent")
+          agentId: url.searchParams.get("agent"),
+          // 事实段与注入共用同一渲染函数（user-settings.js 的同源纪律）：装配了
+          // profile-facts 就传读口，开关与有无的判定在渲染函数内部（关=零读数）。
+          factsProvider: typeof facts?.factsProvider === "function" ? facts.factsProvider : null
         });
         sendJson(res, 200, { persona: settings.getPersona(), preview });
       } catch {
@@ -598,6 +610,115 @@ export function createApi(ctx, service, settings, commands, embedder, semantic =
     }
   });
 
+  // --- 「Agent 眼中的你」自动事实（2026-11-06，对标 ChatGPT 记忆 / DS Bot 每 bot
+  // 的 MEMORY.md 事实清单）----------------------------------------------
+  // 三条路由都**不碰 user_settings**：手填画像神圣（#497 口径），事实住
+  // profile_facts 独立三表，模型只在 dream 轮里增改、人在面板上逐条修正。
+  // GET：卡内事实 + 账本尾 + 最近回执，一次请求喂饱面板那张卡。flag 关着也照读
+  // ——历史上开过又关掉的库里事实还在，面板要能展示它（与 /profile 的 GET 同理）。
+  register({
+    kind: "exact",
+    path: "/api/dsh-mneme/profile-facts",
+    policy: "token-write",
+    handler(req, res) {
+      try {
+        if (typeof facts?.listFacts !== "function") return sendJson(res, 503, { error: "unavailable" });
+        const url = new URL(req.url, "http://localhost");
+        const raw = url.searchParams.get("agent");
+        const agent = typeof raw === "string" ? raw.trim() : "";
+        sendJson(res, 200, {
+          cards: facts.cardKeys(),
+          agent,
+          facts: facts.listFacts(agent, { includeArchived: true }),
+          journal: facts.listJournal(agent, { limit: 12 }),
+          runs: facts.listRuns(agent, { limit: 5 })
+        });
+      } catch {
+        sendJson(res, 500, { error: "internal" });
+      }
+    }
+  });
+
+  // POST /apply：面板的逐条人工修正（增/改/归档），actor=manual，与自动轮共用
+  // 同一份 applyOps 与同一本账。flag 关着也放行——修正存量事实不需要维护轮开着。
+  register({
+    kind: "exact",
+    path: "/api/dsh-mneme/profile-facts/apply",
+    policy: "token-write",
+    handler(req, res) {
+      if (req.method !== "POST") {
+        res.writeHead(405, { Allow: "POST" });
+        res.end("");
+        return undefined;
+      }
+      if (typeof facts?.applyManualOps !== "function") return sendJson(res, 503, { error: "unavailable" });
+      return readBody(req, res).then((text) => {
+        if (text === null) return undefined;
+        const body = parseBody(text);
+        const agent = typeof body.agent === "string" ? body.agent.trim() : "";
+        const ops = Array.isArray(body.ops) ? body.ops : [];
+        if (!ops.length) return sendJson(res, 400, { error: "ops required" });
+        // 形状谓词与解析层共用一份（isValidFactOps）：update 与 add 同样必须带
+        // content——缺了会把「undefined」写进事实正文并从此每帧注入。
+        if (!isValidFactOps(ops)) return sendJson(res, 400, { error: "invalid ops" });
+        let result;
+        try {
+          result = facts.applyManualOps(agent, ops);
+        } catch (error) {
+          // /run 有完整的错误映射，这条写路径也不能把同步异常（SQLite I/O）裸抛
+          // 给宿主——500 + 一句 internal，与 GET 分支的 try/catch 同款。
+          ctx.logger?.warn?.(`dsh-mneme: profile-facts apply failed: ${String(error?.message ?? error)}`);
+          return sendJson(res, 500, { error: "internal" });
+        }
+        sendJson(res, 200, {
+          applied: result.applied,
+          failures: result.failures,
+          dupsSkipped: result.dupsSkipped,
+          facts: facts.listFacts(agent, { includeArchived: true })
+        });
+        return undefined;
+      });
+    }
+  });
+
+  // POST /run：手动维护轮。policy `token` 与 /profile/extract 同款取舍：无读分支
+  // + 一次 LLM 调用，声明成 token-write 会让开放读清单按「GET 开放」把它算进去。
+  // run 本体经 service.enqueue 与 dream/sleep 串行，不与巩固轮抢模型。
+  register({
+    kind: "exact",
+    path: "/api/dsh-mneme/profile-facts/run",
+    policy: "token",
+    handler(req, res) {
+      if (req.method !== "POST") {
+        res.writeHead(405, { Allow: "POST" });
+        res.end("");
+        return undefined;
+      }
+      if (config?.profileFactsEnabled !== true) return sendJson(res, 409, { error: "disabled" });
+      if (typeof facts?.runFor !== "function") return sendJson(res, 503, { error: "unavailable" });
+      return readBody(req, res).then((text) => {
+        if (text === null) return undefined;
+        const body = parseBody(text);
+        const agent = typeof body.agent === "string" ? body.agent.trim() : "";
+        const queued = service?.enqueue
+          ? service.enqueue(() => facts.runFor(agent, { trigger: "manual" }))
+          : facts.runFor(agent, { trigger: "manual" });
+        return queued.then(
+          (receipt) => sendJson(res, 200, receipt),
+          (error) => {
+            // 「没配模型」与「模型不配合」两码（profileExtract 同款映射）：
+            // 前者重跑也一样，后者可重试。noop 是正常结局（没有新记忆），200。
+            const code = typeof error?.code === "string" ? error.code : "";
+            if (code === "no-route") return sendJson(res, 503, { error: code });
+            if (code === "unparseable" || code === "stream-failed") return sendJson(res, 502, { error: code });
+            ctx.logger?.warn?.(`dsh-mneme: profile facts run failed: ${String(error?.message ?? error)}`);
+            return sendJson(res, 500, { error: "internal" });
+          }
+        );
+      });
+    }
+  });
+
   // --- dream/sleep 模型连通性 + 模型发现（settings 面板）----------------------
   // Connectivity probe for a dream/sleep model route: runs one minimal LLM call
   // through the same harness path the consolidation uses and reports success /
@@ -1308,6 +1429,27 @@ export function createApi(ctx, service, settings, commands, embedder, semantic =
     }
   });
 
+  // 沉淀曲线（面板「8 周沉淀」图）：按天返回 added / merged / archived 三条序列。
+  // 与 llm-audit/stats 并列但不同源——那边算的是「花了多少 token」，这边算的是
+  // 「进来了多少条、真被巩固掉多少条、归档了多少条」。合并数与新增数背离时
+  // （2026-10-25~10-31 那段：新增照旧、合并归零）这张图是唯一能一眼看出来的地方。
+  // 窗口钳制 1-365 天（缺省 56，正好是热力图的 8 周），口径见 store.getConsolidationStats。
+  register({
+    kind: "exact",
+    path: "/api/dsh-mneme/semantic/consolidation-stats",
+    policy: "open",
+    handler(req, res) {
+      try {
+        const url = new URL(req.url, "http://localhost");
+        const days = Math.max(1, Math.min(365, Number(url.searchParams.get("days") ?? 56) || 56));
+        const stats = service.getConsolidationStats?.({ days }) ?? null;
+        sendJson(res, 200, stats ?? { error: "unavailable" });
+      } catch {
+        sendJson(res, 500, { error: "internal" });
+      }
+    }
+  });
+
   // --- 记忆级溯源读出口（#399 写、#421 读）-----------------------------------
   // #399 把蒸馏窗口的原文落进 distill_records、把 memory → (session, seq 区间)
   // 的归因写进 memory_provenance，但只做了写：库里有答案、service.provenanceFor
@@ -1548,7 +1690,26 @@ export function createApi(ctx, service, settings, commands, embedder, semantic =
         const url = new URL(req.url, "http://localhost");
         const limit = Math.min(1000, Math.max(1, Number(url.searchParams.get("limit") ?? 500) || 500));
         const entities = service.listEntities?.({ limit }) ?? [];
-        sendJson(res, 200, { entities, total: entities.length });
+        // total 是**全库**实体数，不是本次切片长度：目录带 limit，面板拿它当
+        // 「一共抽出多少实体」，填切片长度会让 1.6 万实体永远显示成 500。
+        // 老宿主（service 上没有 countEntities）回落到切片长度，不抛。计数本身失败也
+        // 只回落、不冒泡：它在外层 try 里，一抛整条响应就变成 500，已经把切片读出来的
+        // 那份列表也跟着丢掉——一个装饰性的总数不该决定目录能不能显示。
+        let total = entities.length;
+        // totalExact 是给面板看的：计数失败或老宿主没这个方法时，total 只能退回切片
+        // 长度，那已经不是「全库有多少」而只是「这次取回多少」。不回这个标记，面板
+        // 会把切片长度当成全库数照常显示——正是这条路由原来那个「永远 500」的错法。
+        let totalExact = false;
+        if (typeof service.countEntities === "function") {
+          try {
+            total = service.countEntities();
+            totalExact = true;
+          } catch {
+            total = entities.length;
+            totalExact = false;
+          }
+        }
+        sendJson(res, 200, { entities, total, totalExact });
       } catch {
         sendJson(res, 500, { error: "internal" });
       }
@@ -1808,6 +1969,85 @@ export function createApi(ctx, service, settings, commands, embedder, semantic =
     }
   });
 
+  // --- 从目录引导（bootstrap，#386 第 6 条）------------------------------------
+  // 后端能力从 #220 起就在（src/bootstrap.js：六类确定性产物、零 LLM、吃
+  // saveWithDedupe 的去重），但只有 Bearer 数据面一条入口，面板够不着——「用户照
+  // 文档去找入口，发现产品界面里没有」。
+  //
+  // policy 取 token 而不是 token-write：它写记忆（虽然幂等），与 /import 同类，
+  // 而 /import 就是整条要 token 的。GET 不给读分支：没有「预览一次引导会写什么」
+  // 的形态，硬造一个 dryRun 等于把 bootstrap.js 拆成两半，收益不抵风险。
+  //
+  // 为什么不在服务端限制目录范围：插件没有「工作区根」概念（bootstrap.js 的注释
+  // 写着不猜路径），而这条路由与 /export、/import 同级，本来就能读写整库；额外加
+  // 一个路径白名单只会让人以为它比邻座更安全。
+  register({
+    kind: "exact",
+    path: "/api/dsh-mneme/bootstrap",
+    policy: "token",
+    handler(req, res) {
+      try {
+        if (req.method !== "POST") {
+          sendJson(res, 404, { error: "not-found" });
+          return;
+        }
+        return readBody(req, res).then((text) => {
+          if (text === null) return;
+          const parsed = parseBootstrapJson(text);
+          if (!parsed.ok) {
+            sendJson(res, 400, { error: parsed.error });
+            return;
+          }
+          // 顺序：先判 body 形状与 dir，再判能力是否接线。缺 dir 是调用方的问题，
+          // 报「能力没接线」会把人引到错误的排查方向（reclaim 那边同一条纪律）。
+          const dirResult = readBootstrapDir(parsed.body);
+          if (!dirResult.ok) {
+            sendJson(res, 400, { error: dirResult.error });
+            return;
+          }
+          if (typeof service?.saveWithDedupe !== "function") {
+            sendJson(res, 503, { error: BOOTSTRAP_UNAVAILABLE });
+            return;
+          }
+          return bootstrapReply({
+            bootstrapper: ({ dir }) => bootstrapFromDirectory({ service, dir, logger: ctx.logger }),
+            dir: dirResult.dir,
+            warn: (msg) => ctx.logger?.warn?.(msg)
+          }).then(({ status, body }) => sendJson(res, status, body));
+        });
+      } catch {
+        sendJson(res, 500, { error: "internal" });
+      }
+    }
+  });
+
+  // --- 配置键覆盖面（#386 第 7 条，只读）--------------------------------------
+  // 面板能改的键（settings.js 白名单）与 schema 里存在的键（config.js）是两张表，
+  // 从没被摆在一起对过。这条路由把它们交/差出来，回答「哪些键只能改配置文件」。
+  //
+  // 只回**键名与计数**，一个值都不回：apiToken 这类敏感键的名字出现在「仅配置
+  // 文件」清单里正是这条 issue 想让人看见的东西（否则用户不知道它存在），但值
+  // 出这道门就会成为一个新的泄漏面。
+  //
+  // policy 取 open：与 /inject-status、/features 的读分支同级——面板要渲染，且
+  // 键名本身已经逐条写在 docs/CONFIGURATION.md 里（公开文档），不构成新秘密。
+  register({
+    kind: "exact",
+    path: "/api/dsh-mneme/config-keys",
+    policy: "open",
+    handler(req, res) {
+      try {
+        if (req.method !== "GET") {
+          sendJson(res, 404, { error: "not-found" });
+          return;
+        }
+        sendJson(res, 200, describeConfigKeys());
+      } catch {
+        sendJson(res, 500, { error: "internal" });
+      }
+    }
+  });
+
   // --- 巩固状态（dream 面板）--------------------------------------------------
   // 只读：最近巩固运行（最多 5 条，created_at DESC）+ 未解决冲突队列。
   // pendingMemoryIds 从未解决冲突行提取涉及的记忆 id，去重后上限 200，避免积
@@ -2431,6 +2671,168 @@ export function createApi(ctx, service, settings, commands, embedder, semantic =
     }
   });
 
+  // --- chorography（仓库地志）M1 读侧路由 -------------------------------
+  // spec §7 消费面的面板数据源。四条全 policy "open"：只读、宿主围栏统一鉴权
+  // （与 /list、/version-check 同级）；**chorographyEnabled 关闭时一律 409
+  // disabled**（#497 先例：路由挂着、逻辑层挡——面板据此渲染「未启用」空态）。
+  // 仓库/模块/页面全部只从 choro_* 表与仓库磁盘读（真源是盘上的 MD），没有
+  // 任何写路径；生成入口在 M2 才有（T1 生成轮同批接）。
+  // choro 参数缺省 null：headless/测试环境没有 queries 时这四条路由回 503
+  // unavailable（语义分叉见 #497：503 = 环境缺件，409 = 用户没开）。
+  function choroGate(req, res) {
+    if (!choro) {
+      sendJson(res, 503, { error: "unavailable", reason: "choro-queries-unavailable" });
+      return false;
+    }
+    if (!config || config.chorographyEnabled !== true) {
+      sendJson(res, 409, { error: "disabled", reason: "chorography-not-enabled" });
+      return false;
+    }
+    return true;
+  }
+  function choroResolveOr4xx(req, res) {
+    const repo = choro.resolveRepo(
+      new URL(req.url, "http://localhost").searchParams.get("repo")
+    );
+    if (!repo || repo.ambiguous) {
+      sendJson(res, repo && repo.ambiguous ? 400 : 404, {
+        error: repo && repo.ambiguous ? "repo-ambiguous" : "repo-not-found",
+        repos: repo && repo.ambiguous ? repo.ambiguous : undefined
+      });
+      return null;
+    }
+    return repo;
+  }
+
+  register({
+    kind: "exact",
+    path: "/api/dsh-mneme/choro/repos",
+    policy: "open",
+    handler(req, res) {
+      if (!choroGate(req, res)) return;
+      sendJson(res, 200, { repos: choro.listRepos() });
+    }
+  });
+
+  register({
+    kind: "exact",
+    path: "/api/dsh-mneme/choro/modules",
+    policy: "open",
+    handler(req, res) {
+      if (!choroGate(req, res)) return;
+      const repo = choroResolveOr4xx(req, res);
+      if (!repo) return;
+      const { modules, edges } = choro.moduleMap(repo.id);
+      sendJson(res, 200, {
+        repo: { id: repo.id, name: repo.name, gitBaseline: repo.git_baseline },
+        modules,
+        edges
+      });
+    }
+  });
+
+  register({
+    kind: "exact",
+    path: "/api/dsh-mneme/choro/page",
+    policy: "open",
+    handler(req, res) {
+      if (!choroGate(req, res)) return;
+      const repo = choroResolveOr4xx(req, res);
+      if (!repo) return;
+      const slug = new URL(req.url, "http://localhost").searchParams.get("slug");
+      if (!slug) {
+        sendJson(res, 400, { error: "slug-required" });
+        return;
+      }
+      const page = choro.readPage(repo.id, slug);
+      if (!page) {
+        sendJson(res, 404, { error: "page-not-found", slug });
+        return;
+      }
+      if (page.error) {
+        // 409 保留已登记的页与未知 slug 的区别，恢复方式取决于文件状态。
+        sendJson(res, 409, {
+          error: page.error,
+          slug: page.slug,
+          relPath: page.relPath,
+          hint: page.error === "page-missing"
+            ? "run `dsh-mneme-choro <repo> --apply` to rebuild"
+            : "check the local file and its permissions"
+        });
+        return;
+      }
+      sendJson(res, 200, { page });
+    }
+  });
+
+  register({
+    kind: "exact",
+    path: "/api/dsh-mneme/choro/search",
+    policy: "open",
+    handler(req, res) {
+      if (!choroGate(req, res)) return;
+      const repo = choroResolveOr4xx(req, res);
+      if (!repo) return;
+      const url = new URL(req.url, "http://localhost");
+      const hits = choro.search(repo.id, url.searchParams.get("q"), {
+        moduleSlug: url.searchParams.get("module"),
+        limit: Number(url.searchParams.get("limit") ?? 20)
+      });
+      // 向量路（收尾档 P37/P39）：embedder 可用时惰性物化 + 余弦 Top-N，独立成
+      // semantic 数组——两路分数量纲不同，不混排序。embedder 缺席（CLI/测试装配）
+      // → semantic: null，调用方据此退纯关键词。永不抛：向量路挂了不影响 hits。
+      const embedder = choro.embedder ?? null;
+      const finish = (semantic) => sendJson(res, 200, { q: url.searchParams.get("q"), hits, semantic });
+      if (!embedder) { finish(null); return; }
+      // 必须 return 整条链：invoke/测试是 await route.handler(...)，不 return 就
+      // 会在响应发出之前返回（实测：semantic 永远缺席、body 恒空）。
+      // 顺序（P37/P38）：先嵌查询拿 expectDim → 惰性物化（dim 失配全量重嵌）→
+      // 本轮 semantic 用刚物化完的最新向量算。
+      return Promise.resolve()
+        .then(() => choro.embedQueryText(embedder, url.searchParams.get("q")))
+        .then((qv) => choro.embedPageVectors(repo.id, embedder, { expectDim: qv ? qv.length : null }).then(() => qv))
+        .then((qv) => choro.semanticTopN(repo.id, qv, { limit: Number(url.searchParams.get("limit") ?? 10) }))
+        .then((semantic) => finish(semantic))
+        .catch(() => finish(null));
+    }
+  });
+
+  // 面板重建入口（收尾档 P34）：T0 apply 秒级同步回执；**T1 不上 HTTP**——单模块
+  // 30–240s 起步的长任务不适合挂死面板请求，CLI（--t1）仍是 T1 唯一入口。
+  // policy token-write：写的是仓库磁盘的 .chorography/**，属数据面写。
+  register({
+    kind: "exact",
+    path: "/api/dsh-mneme/choro/run",
+    policy: "token-write",
+    handler(req, res) {
+      if (req.method !== "POST") {
+        sendJson(res, 405, { error: "method-not-allowed", allow: "POST" }, { Allow: "POST" });
+        return;
+      }
+      if (!choroGate(req, res)) return;
+      // return 链：同上，await route.handler 必须等到响应真的发出（nudge 同款）。
+      return readBody(req, res).then((text) => {
+        if (text === null) return; // readBody 已回 413
+        const body = parseBody(text);
+        const repoRef = body && typeof body === "object" ? body.repo : null;
+        const repo = choro.resolveRepo(repoRef);
+        if (!repo || repo.ambiguous) {
+          sendJson(res, repo && repo.ambiguous ? 400 : 404, {
+            error: repo && repo.ambiguous ? "repo-ambiguous" : "repo-not-found",
+            repos: repo && repo.ambiguous ? repo.ambiguous : undefined
+          });
+          return;
+        }
+        try {
+          const receipt = choro.runT0Apply({ repoRoot: repo.root_path });
+          sendJson(res, 200, { ok: true, receipt });
+        } catch (err) {
+          sendJson(res, 500, { error: "t0-failed", detail: String((err && err.message) || err) });
+        }
+      });
+    }
+  });
+
   return {
     routes: countRoutes(),
     dispose: () => {

package/src/bootstrap-http.js

@@ -0,0 +1,105 @@
+// 从目录引导（bootstrap）的 HTTP 口径 —— 唯一实现。
+//
+// 为什么要单独一个模块：这张脸原本只有一个入口（Bearer 数据面 src/api-standalone.js
+// 的 POST /bootstrap），#386 第 6 条要给面板补入口，于是就有了第二个。历史教训写在
+// reclaim-http.js 的开头：#410 修好面板侧之后数据面还停在旧形态（#411），整段复制
+// 必然漂移。所以解析、校验、答复形状从第一份就落在这里，两个入口只留路径与鉴权不同。
+//
+// 这里只做协议层的事：解析、校验、把 bootstrapFromDirectory 的结果包成答复。真正的
+// 解析在 src/bootstrap.js——它读目录、抽六类确定性产物，零 LLM。
+//
+// 与 reclaim-http.js 的一处刻意不同：这里**不做 confirm 两步确认**。bootstrap 是
+// 幂等的（吃 saveWithDedupe 的 (type,title,scope) 去重，`_overwrite` 只刷新内容），
+// 重复跑不会翻倍，也不会删任何东西，所以不需要「先看报告再执行」那道门。
+
+/**
+ * 「引导能力没接线」的错误码。两个入口各有一次顺序敏感的显式检查（503 要赢过 400：
+ * 端点整个没接线时报「dir 不合法」是误导），所以这条不能只藏在 bootstrapReply 里；
+ * 但也必须是同一份字符串。
+ */
+export const BOOTSTRAP_UNAVAILABLE = "bootstrap-unavailable";
+
+/**
+ * 记日志这一手，只许经这里。
+ *
+ * 照 `share-http.js` 的同一份理由抄（C5 评审裁定）：warn 裸调时，宿主 logger 自己坏掉就会
+ * 从 catch 块里再抛出去，而两侧 handler 那个外层 try 在 .then 的回调里早已退栈——现场
+ * 就是「一个字节都没回」（#410）。守卫住在层里，两张脸（in-process 与 Bearer 数据面）
+ * 拿到的就是同一个脾气，不必每张脸各记一次。
+ */
+function warnSafely(warn, message) {
+  try {
+    warn?.(message);
+  } catch { /* 记日志是自己的事，坏了的日志不许把已经算好的答复一起带走 */ }
+}
+
+/** 引导失败的 warn 文案。两条路径共用，日志里不会出现两种拼法。 */
+function bootstrapWarnMessage(error) {
+  return `[dsh-mneme] bootstrap failed: ${String(error)}`;
+}
+
+/**
+ * 解析 POST body（已读成文本）的结构。只判 JSON 与顶层形状，dir 在 readBootstrapDir
+ * 里读——两步分开是为了保住「invalid-json → invalid-body → 能力是否接线 → dir」这个
+ * 顺序，这个顺序是既有对外行为。
+ *
+ * 不用 api.js 的 parseBody：它把坏 JSON 吞成 {}，而 invalid-json 与 invalid-body 是
+ * 两个不同的错（前者是调用方发坏了，后者是发成了数组/null）。
+ *
+ * @returns {{ok: true, body: object} | {ok: false, error: string}}
+ */
+export function parseBootstrapJson(text) {
+  let body;
+  try {
+    body = JSON.parse(text || "{}");
+  } catch {
+    return { ok: false, error: "invalid-json" };
+  }
+  if (body === null || typeof body !== "object" || Array.isArray(body)) {
+    return { ok: false, error: "invalid-body" };
+  }
+  return { ok: true, body };
+}
+
+/**
+ * 读 dir 并归一化。
+ *
+ * 只收非空字符串：插件没有「工作区根目录」的概念，绝不猜路径（猜错就会去读一个
+ * 与用户意图无关的目录，然后把里面的东西写进记忆库）。`trim()` 之后再判空，
+ * 但**回传原串**而不是 trim 后的——两端空白在 Windows 路径里不合法，交给 fs 报
+ * dir-not-found 比在这里静默改写更诚实。
+ *
+ * @returns {{ok: true, dir: string} | {ok: false, error: string}}
+ */
+export function readBootstrapDir(body) {
+  if (typeof body.dir !== "string" || !body.dir.trim()) {
+    return { ok: false, error: "missing-dir" };
+  }
+  return { ok: true, dir: body.dir };
+}
+
+/**
+ * 把一次引导请求变成 { status, body }。调用方只管 sendJson，不自己拼答复。
+ *
+ * 报告一律不加包装层（就是 bootstrapFromDirectory 的原样返回）：面板与数据面都直接
+ * 读 created / merged / items 这几格。
+ *
+ * `BootstrapError` 带 `code`（missing-dir / dir-not-found / not-a-directory），它们
+ * 是**调用方的输入问题**，回 400 并把 code 当错误码；其余异常是内部问题，回 500，
+ * 且不能让 warn 把异常本身吞掉。
+ *
+ * @param {{bootstrapper: ((input: {dir: string}) => Promise<object>)|null,
+ *          dir: string, warn?: ((msg: string) => void)|null}} input
+ * @returns {Promise<{status: number, body: object}>}
+ */
+export function bootstrapReply({ bootstrapper, dir, warn = null }) {
+  if (!bootstrapper) return Promise.resolve({ status: 503, body: { error: BOOTSTRAP_UNAVAILABLE } });
+  return Promise.resolve()
+    .then(() => bootstrapper({ dir }))
+    .then((summary) => ({ status: 200, body: summary }))
+    .catch((error) => {
+      if (error?.code) return { status: 400, body: { error: error.code } };
+      warnSafely(warn, bootstrapWarnMessage(error));
+      return { status: 500, body: { error: "internal" } };
+    });
+}

package/src/bootstrap.js

@@ -177,7 +177,11 @@ async function collectCandidates(root) {
  */
 export async function bootstrapFromDirectory({ service, dir, logger } = {}) {
   if (typeof dir !== "string" || !dir.trim()) throw new BootstrapError("missing-dir");
-  const root = dir.trim();
+  // 只 trim 判空，**不**把 trim 结果当路径（#386 第 6 条评审）：协议层 readBootstrapDir
+  // 刻意回传原串，理由写着「两端空白交给 fs 报 dir-not-found 比静默改写更诚实」；这里
+  // 若再 trim 一次，那个承诺就变成了空话——用户填 " /repo " 会被悄悄换成 "/repo"，
+  // 读的是另一个目录，而他一无所知。路径不合法就让 statSync 去报。
+  const root = dir;
   let st;
   try {
     st = statSync(root);