@sema-agent/server 7.43.0 → 7.44.0

package/dist/boot/stores.js

@@ -1,17 +1,3 @@
-/**
- * design/158 A10:composition root 分段 —— 持久层装配(StoreBackend / memory engine / roster /
- * background-agent / attachment / mailbox / memory sync / session store + 姿势断言 / breaker)。
- *
- * 纯搬运:函数体逐字来自 `main.ts`(原 627-932 行),缩进不变;新增的只有 import 与包壳。
- *
- * ⚠️ **位置即契约**:
- *  1. 本段**就地改写 `config.sessionBackend`**(`auto` → `tidb|memory`,local backend 再归一为 `tidb`)。
- *     这两行是后续所有消费点(createSessionStore / ensureChildSessionDurable 的 tidb 门 / /health 标签)
- *     的前置条件,必须留在本段这个位置,不能上移(backend 还没开)也不能下移(消费点已读)。
- *  2. `assertCloudSnapshotBlobPosture` 与两条 REQUIRE_PRINCIPAL 拒启断言必须在 sessionStore 造出来之后、
- *     任何路由装配之前 —— fail-loud 拒启的意义就在于"还没开始服务"。
- *  3. `breakerState` 放在段尾:brain(下一段)要它,而它要 backend。
- */
 import { join } from "node:path";
 import { FileBackgroundAgentStore, FileMailboxStore, FileRosterStore, FileUsageWindowStore, InMemoryUsageWindowStore } from "@sema-agent/core";
 import { createMemorySyncRunner, createMemorySyncTransport } from "../memory-sync-client.js";
@@ -34,10 +20,9 @@ import { ensurePgTaskListSchema, ensureTiDBTaskListSchema } from "../plugins/tas
 import { assertCloudSnapshotBlobPosture, openStoreBackendWithFallback } from "../plugins/store-backend.js";
 import { buildMemoryRemoteLaneWarn, memoryEngineBackendFor, memoryEngineRemoteLanePosture } from "../memory-scope.js";
 import { assertToolResultProvenanceSchema } from "../plugins/tool-result-store-sql.js";
+import { assertPermissionRuleApprovalSchema } from "../plugins/permission-rule-store-sql.js";
 import { buildMemoryWriteBoundaryAudit, effectiveMemoryPersistenceCapable } from "./memory-boundary.js";
 import { buildMemoryPosture } from "../memory-posture.js";
-/** #252:dark 三词 → 启动日志的人话(词表是机器面的真源,散文是它的**投影**,不是第二个真源)。
- *  穷举 `Record<MemoryDarkReason, …>`:词表加员 ⇒ 这里编译红,不会静默漏一句人话。 */
 const DARK_REASON_PROSE = {
     engine_off: () => "MEMORY_ENGINE=off",
     multi_tenant_file_backend: () => "multi-tenant on the FILE backend (no tenant isolation; set MEMORY_ENGINE_BACKEND=pg|tidb to light up)",
@@ -45,32 +30,17 @@ const DARK_REASON_PROSE = {
 };
 export async function openStores(ctx) {
     const { config, logger, metrics, localRoot } = ctx;
-    // One shared SQL store backend for L1 + L2 (TiDB/MySQL or PostgreSQL per DB_BACKEND). Owned here.
     let backend;
-    let storeBackendDegraded = false; // S5: auto-probe degraded this replica to in-memory (surfaced via gauge + /health)
-    // `auto` probes a configured DB and degrades to in-memory if it's unreachable (local/intranet binaries:
-    // "use my DB if I can reach it, else memory"). Explicit `tidb` fails fast instead — silently dropping
-    // persistence the operator asked for would lose runs. (`tidb` here = "the SQL DB"; DB_BACKEND picks the engine.)
+    let storeBackendDegraded = false;
     const wantDb = config.sessionBackend === "tidb" ||
-        config.dbBackend === "local" || // local (clay 2026-06-25): always build the DB-less in-memory/file StoreBackend
+        config.dbBackend === "local" ||
         (config.sessionBackend === "auto" && !!(config.tidb || config.pg));
     if (wantDb) {
-        // 构造 + ensureSchema 同罩一层降级臂(2026-07-28 修):原先 try 只罩 ensureSchema,而 local 形真正
-        // 会抛的是构造里的 mkdir + 数据根 BootLock ——「裸 boot 不得拒启」那条口径对 local 从未生效过。
-        // 降级/fail-loud 的判据与理由见 openStoreBackendWithFallback 顶注。
         const opened = await openStoreBackendWithFallback(config, logger);
         backend = opened.backend;
         storeBackendDegraded = opened.degraded;
     }
-    // S5 review LOW-1: always render the series (0 = healthy) — gauge absence is indistinguishable from
-    // "old build without this metric", which breaks `== 0`-style alert rules.
     metrics.setGauge("store_backend_degraded", storeBackendDegraded ? 1 : 0);
-    // #119 升级前置断言(core 5.26.0 提货):`CREATE TABLE IF NOT EXISTS` 对**存量** tool_result 是空操作 ⇒
-    // 没删表就升上来的部署,出处两列与加宽的 ref 列都不在,而每一次 offload 写都会撞 unknown column、被
-    // core 的失败臂吞成一条内联占位(服务照跑、工具产物全丢)。判据与恢复动作见
-    // assertToolResultProvenanceSchema 的头注。
-    // 🔴 位置:**不在** `ensureSchema` 里 —— 那条通道的契约是「只发 CREATE」(test/ensure-schema.test.ts 的
-    // 运行时门),一条只读探针进去也算破例。放在 DDL 之后、任何路由装配之前,拒启的意义仍在(还没开始服务)。
     {
         const mysqlPool = backend?.mysqlPool?.();
         const pgPool = backend?.pgPool?.();
@@ -78,9 +48,13 @@ export async function openStores(ctx) {
             await assertToolResultProvenanceSchema(async (sql) => ({ rows: (await pgPool.query(sql)).rows }), "pg");
         else if (mysqlPool)
             await assertToolResultProvenanceSchema(async (sql) => ({ rows: (await mysqlPool.query(sql))[0] }), "tidb");
+        if (config.permissionRulesEnabled) {
+            if (pgPool)
+                await assertPermissionRuleApprovalSchema(async (sql) => ({ rows: (await pgPool.query(sql)).rows }), "pg");
+            else if (mysqlPool)
+                await assertPermissionRuleApprovalSchema(async (sql) => ({ rows: (await mysqlPool.query(sql))[0] }), "tidb");
+        }
     }
-    // S21 (SILENT-FALLBACK P1): MINIO_* partially set silently falls back to SQL-blob snapshots. Warn on the
-    // partial config and always render which backend blobs actually use.
     {
         const minioReq = ["MINIO_ENDPOINT", "MINIO_ACCESS_KEY", "MINIO_SECRET_KEY"];
         const present = minioReq.filter((v) => (process.env[v] ?? "") !== "");
@@ -89,36 +63,15 @@ export async function openStores(ctx) {
         }
         metrics.setGauge("snapshot_blob_backend", 1, { backend: config.snapshotBlobStore ? "minio" : "sql" });
     }
-    // Resolve `auto` to the concrete backend the rest of the wiring understands (createSessionStore,
-    // runStore, the startup summary). A DB-backed L2 with no backend degrades to in-memory the same way.
     if (config.sessionBackend === "auto")
         config.sessionBackend = backend ? "tidb" : "memory";
-    // local backend: route the session store through backend.session() (LocalSessionStore — the §0.5 OwnerAware twin),
-    // NOT the bare TtlSessionStore the "memory" path returns; "tidb" here means "the backend's durable store" generically.
     if (config.dbBackend === "local" && backend)
         config.sessionBackend = "tidb";
-    // Long-term memory (design/138 S1, clay 2026-07-08): the injection-first file-based memory ENGINE is the
-    // only memory plane — `RunnerDeps.memoryBackend` is core's switch (materialize → session file ops →
-    // harvest; no remember/recall tools). SINGLE-USER TURNKEY ONLY: the file basement has no tenant
-    // isolation, so a multi-tenant deployment (requirePrincipal) gets `undefined` = memory dark, fail-closed
-    // (memoryEngineBackendFor + memoryScopeFor enforce the same gate). The legacy MemoryStore plane
-    // (MEMORY_BACKEND/EMBEDDING_*) was dropped without migration; `scripts/drop-memory-tables.sql` drops the table.
-    // S3-TOB(设计 §1.3,后经改判与边界重切):backend 选择器——file=现状(单用户/host);pg|tidb=
-    // DB durable 真身(零卷主档:memory/ 文件面=materialize 的 ephemeral 工作副本,harvest 回 DB=持久化
-    // 时点)。DB backend 是多租户点亮的唯一门(显式 opt-in);选了 DB 但池不可用/方言不匹配=fail-loud 拒启
-    // (no-stopgap:绝不静默降 File/dark)。
     let memoryEngine;
-    // 142-S2.5:per-(scope,peer) 同步游标面(sync_cursors)——POST /v1/memory/sync/:scope 的持久化半场。
-    // 只在 DB memory plane 上点亮(file 形态路由 501,不接);与 entry plane 同池同方言。
     let memorySyncCursors;
-    /** #252:两支 SQL 后端从实例 getter 读到的档位真值;file/off 腿留 undefined(该腿无此指示面)。 */
     let vectorMode;
     if (config.memoryEngineBackend !== "file" && config.memoryEngineEnabled) {
         const dialect = config.memoryEngineBackend;
-        // 142-S5.1 production history sink: every applied patch appends one
-        // agent_memory_engine_history row via the backend's optional history opts. The wrapper's ONLY
-        // job is the metrics leg — count lost rows BEFORE rethrowing (the backend swallows + warns with
-        // its own cumulative count; the audit line's breakage must itself be auditable).
         const countedHistorySink = (store) => ({
             appendHistory: async (rows) => {
                 try {
@@ -130,30 +83,15 @@ export async function openStores(ctx) {
                 }
             },
         });
-        // #228:检索档位(lexical|portable|native)是「后端上限 × embedder 在场」的**推断结果**,不是旋钮
-        // ([3590] 裁①)。下面两支各自从**实例的 getter** 读真值——不在这里自己推断,推断出的档与实际跑的档
-        // 一旦分家,启动日志就成了另一句谎([3606]①:lexical 在跑必须运维可见)。
-        // ⚠️ #252:声明上移到函数作用域(启动日志之外,`buildMemoryPosture` 也要读这个真值)——两支的赋值
-        // 逐字不变,file/off 那一臂照旧留 `undefined`(file 引擎没有档位指示面,不折成 lexical)。
         if (dialect === "pg") {
             const pool = backend?.pgPool();
             if (!pool)
                 throw new Error("MEMORY_ENGINE_BACKEND=pg requires DB_BACKEND=pg (the memory engine binds the same PG pool) — refusing to start half-configured");
             const q = async (text, params) => { const r = await pool.query(text, params); return { rows: r.rows }; };
-            // ⚠️ 维度守卫的**位置**(诚实记档,不编造对表):这里 ensure schema 不传 `memoryVector`,即 embedding
-            // 列是 `jsonb`(portable 档),schema 侧**没有维度**可与 MEMORY_EMBEDDER_DIM 对表。boot 期能做的
-            // 只有「DIM 是正整数」(config.ts parseMemoryEmbedder);真正的维度守卫在写入路径两处:
-            // ① 本仓 embedder 拿到长度不符的响应直接抛(绝不截断/补零);
-            // ② `PgMemoryEngineBackend.embeddingParam` 对长度不符的向量返回 null,该行退回词面档、不写坏向量。
             await ensurePgMemoryEngineSchema(q);
             await ensurePgMemoryHistorySchema(q);
-            await ensurePgMemorySyncSchema(q); // 142-S2.5: sync_cursors(+push_queue)同池 ensure,幂等
+            await ensurePgMemorySyncSchema(q);
             memorySyncCursors = new PgMemorySyncStore(q);
-            // #228:配了 MEMORY_EMBEDDER_*(config 层已把半配/坏值/错后端全拒掉)⇒ 注入,vectorMode 由 lexical
-            // 升到 portable;没配 ⇒ undefined,逐字保持改前行为。
-            // onFailure(codex 复审 F2):embed 抛出去之后,applyPatches 的外层 catch 会把它折成一条
-            // `io error: …` **冲突**(core 的冲突词表把它讲成「并发改动」),search 那腿则直接退回词面档 ——
-            // 两条路都不会在部署面留下「向量供应商挂了」的信号。这条腿就是那个信号(抛照抛,只是被看见)。
             const embedder = memoryEmbedderFor(config, {
                 onFailure: (err) => {
                     metrics.inc("memory_embed_failed_total", { backend: dialect });
@@ -164,14 +102,6 @@ export async function openStores(ctx) {
                     });
                 },
             });
-            // design/234 embedder 指纹门(clay 终裁 [3647]⑤ 方向=清空重建):同维度换模型是**静默**混空间形
-            // ——旧空间与新空间的向量在同一列里做 cosine,排序变噪音,没有任何一层会说出来。指纹
-            // `{model,dimensions}` 明文存单行元表,boot 一次比对:不等/无主/不可解析 ⇒ 先清 `embedding` 列、
-            // 后写元表(次序即正确性,反序中途崩溃=新 identity 已记而旧向量还在=正是被修的病),写后 CAS
-            // 重读收敛并发副本。⚠️ 位置:ensure*Schema 之后、`new PgMemoryEngineBackend` **之前** —— 比对跑在
-            // backend 构造之后 = 服务已经能用旧空间向量检索了。门自身失败一律抛(拒启)。
-            // A 态(embedder 缺席)门整个不装:连 ensure 都不调,元表不动(旧 identity 保留,配置回归同
-            // identity 时存量向量直接续用)。⚠️ ③b 扫的是**源码文本**,调用写在 if 内照样入册(K1)。
             if (embedder !== undefined && config.memoryEmbedder !== undefined) {
                 await ensurePgMemoryEmbedderMetaSchema(q);
                 await reconcileEmbedderFingerprint(q, { model: config.memoryEmbedder.model, dimensions: config.memoryEmbedder.dimensions }, { log: logger });
@@ -183,26 +113,11 @@ export async function openStores(ctx) {
                         "SAME identity later reuses vectors only for rows that have not been touched in the meantime",
                 });
             }
-            // #319 copy-out 生产化站(core 5.47/5.48 契约冻结面)—— **本装配点即换装点,不另起一支**:
-            // 这条腿上的 `PgMemoryEngineBackend` 就是 [4706] 点名的 PG twin(它是 core 1.267 整段移交过来的
-            // copy-out;生产化=把它补到冻结形,不是在旁边再写一只)。本站补的两条行为条款(header 携
-            // `exposure` / `search` 两带序)落在**读面**,所以换装的实际形状是:
-            //   · DDL 零变化 —— origin 在库里是 frontmatter jsonb 里的普通字段(138 S3 形),没有新列、
-            //     没有迁移、没有回填;ensure*Schema 的调用序逐字未动。
-            //   · 旋钮零新增 —— 两带序不是部署开关:后端只在调用方**显式**传 `opts.exposureBands` 时分带,
-            //     缺席 = pre-336 单带字节形。请求方是 core 引擎的读侧,按 `RunnerDeps.memoryProvenance`
-            //     (本仓 MEMORY_PROVENANCE=off|carry,见 boot/runner-deps.ts)自己决定 —— server 不代它翻。
-            //   · 因此本行**不需要**任何前置开关或灰度位:同一只 backend,老调用方拿到逐字节相同的答复,
-            //     新调用方(升到 5.47+ 的 core)拿到带序与 exposure 事实。
-            // 验收面 = `test/memory-engine-db-integration.test.ts`:core 自己的 28 格契约(两方言真库)+
-            // 钉1-钉7(重启存续/并发抢 slug/无副作用读/跨 scope 拒/原生档两带序/谓词对表/同分截断)。
             const pgMem = new PgMemoryEngineBackend(q, {
                 history: countedHistorySink(new PgMemoryHistoryStore(q)),
                 ...(embedder !== undefined ? { embedder } : {}),
             });
             vectorMode = pgMem.vectorMode;
-            // 工作面根:DB 形态下 memory/ 目录=per-worker ephemeral 物化区(丢了重建,控制面同);
-            // 复用 localDataRoot 下独立子树,绝不与 File backend 的持久 memory/ 混写。
             memoryEngine = { backend: pgMem, root: join(config.localDataRoot ?? localRoot, "memory-work") };
         }
         else {
@@ -211,18 +126,12 @@ export async function openStores(ctx) {
                 throw new Error("MEMORY_ENGINE_BACKEND=tidb requires DB_BACKEND=mysql — refusing to start half-configured");
             await ensureTiDBMemoryEngineSchema(pool);
             await ensureTiDBMemoryHistorySchema(pool);
-            await ensureTiDBMemorySyncSchema(pool); // 142-S2.5: sync_cursors(+push_queue)同池 ensure,幂等
+            await ensureTiDBMemorySyncSchema(pool);
             memorySyncCursors = new TiDBMemorySyncStore(pool);
-            // tidb 记忆后端 v1 无向量档(传 embedder 它自己 fail-loud 拒);config 层已保证 MEMORY_EMBEDDER_*
-            // 只可能与 pg 后端同时在场,所以这一支不注入,恒 lexical。
             const tidbMem = new TiDBMemoryEngineBackend(pool, { history: countedHistorySink(new TiDBMemoryHistoryStore(pool)) });
             vectorMode = tidbMem.vectorMode;
             memoryEngine = { backend: tidbMem, root: join(config.localDataRoot ?? localRoot, "memory-work") };
         }
-        // embedder 身份(model + dim)一并自报(codex 复审 F1 的**部分**缓解,记档):本仓没有向量指纹列
-        // (要加列 = 动 SQL,超出 #228 单),所以「同维度换模型 ⇒ 旧向量与新查询向量不同空间、排序变噪音」
-        // 这件事在库里查不出来;能做的是把当前跑的模型写进启动日志,让换模型这件事在运维面留痕(USAGE 里
-        // 的对应纪律:换模型/换维度前先清 `agent_memory_engine_entry.embedding`)。
         logger.info("memory_engine_enabled", {
             enabled: true,
             backend: dialect,
@@ -234,10 +143,6 @@ export async function openStores(ctx) {
     }
     else {
         memoryEngine = memoryEngineBackendFor(config);
-        // [1845]②(cli 桌面撞坑;壳侧此前同坑已各自修过——两个宿主都踩=第三个宿主还会踩):操作员用
-        // LOCAL_DATA_ROOT 明确要了隔离数据根,MEMORY_ENGINE_DIR 却缺省 ⇒ file 形 memory engine 落 core
-        // 默认链(AGENT_DATA_DIR → ~/.ai-agent)= **静默共享全机 memory 库**。不改行为(单机用户可能就要
-        // 共享),只把「你现在在共享」说出来。
         if (memoryEngine && process.env.LOCAL_DATA_ROOT && !config.memoryEngineDir) {
             logger.warn("memory_engine_dir_defaulted", {
                 root: memoryEngine.root,
@@ -245,40 +150,22 @@ export async function openStores(ctx) {
             });
         }
     }
-    // #214 记忆边界不变式([3492]② 立案):记忆没有写工具 —— 模型是用 fs 工具往记忆根写文件的,所以整条
-    // 「记住 X」链的成立条件是**记忆根落在该次任务的 fs 授权边界内**。判据本体(含为什么是 warn 不是拒启、
-    // 为什么围栏根未知时闭嘴)在 boot/memory-boundary.ts;这里只负责把 boot 期的真事实喂进去。
-    // 围栏根的口径与 resolve-spec 的 fs 写门同源:host 语义车道才有本机围栏可谈 —— `REMOTE_EXEC` 未设的
-    // in-process 形,手就在本进程 cwd 跑;显式 `host` 形取 operator 配的 workspaceBase(没配 = 每任务临时
-    // 目录,boot 期不可知 ⇒ 空数组 ⇒ 不判)。其它车道一律非 host 语义,走 remote 那一臂。
     {
         const lane = config.remoteExec?.provider;
         const hostSemanticsLane = lane === undefined || lane === "host";
-        // core 的 remote 判决(与文件平面是两根轴):`isRemoteExecutionEnv` 是鸭子类型,我方**所有**
-        // REMOTE_EXEC 车道(含 `host` —— remote-env-host.ts 实现了 suspendVM/workspaceHandle/execStream,
-        // 亲验)都满足;未设 provider = in-process(core 拿 StubExecutionEnv)。
         const coreRemoteExecutionEnv = config.remoteExec !== undefined;
-        // 🔴 codex 复审(medium,已核真):`REMOTE_EXEC=host` 的 `workspaceBase` **不是**任务围栏 —— host
-        // factory 每任务在它下面另铸一个 `sema-host-*` 子目录,而且调用方的 per-session cwd 还能整个换掉它。
-        // 拿 workspaceBase 当围栏,会把「记忆根是真任务目录的**兄弟**」这一形误判成「在围栏内」而闭嘴 ——
-        // 恰恰是本判据要抓的那种坏部署。所以 host 腿一律报**未知**(空数组 ⇒ 不判),只有 in-process 腿
-        // (手就在本进程 cwd 上跑,boot 期这一位是真的)才给围栏根。宁可少说,不可说错。
         const containmentRoots = lane === undefined ? [process.cwd()] : [];
         const audit = buildMemoryWriteBoundaryAudit({
             memoryRoot: memoryEngine?.root,
             lane: lane ?? "in-process",
             hostSemanticsLane,
             coreRemoteExecutionEnv,
-            // #266 A3 源头修:审计读**有效值**(host 腿 env 缺席时装配层自动 true)——自动补位后 ① 号 warn
-            // 不再响(它警的正是「写指令被撤且无人声明」,现在装配层声明了);显式 env 恒赢在 derive 单源里执法。
             declaredCapable: effectiveMemoryPersistenceCapable(config),
             containmentRoots,
-            engineBackend: config.memoryEngineBackend, // 只进文案:哪个旋钮真能挪动这条腿的根
+            engineBackend: config.memoryEngineBackend,
         });
         for (const w of audit.warnings)
             logger.warn(w.tag, { detail: w.detail, lane: lane ?? "in-process", root: memoryEngine?.root ?? null });
-        // #266:自动补位必须在 boot 日志可见(感知链路纪律)——部署方一眼可核「这台机的 capable 是装配层
-        // 按 host 腿车道事实补的」,并知道显式 MEMORY_PERSISTENCE_CAPABLE 可覆盖。只在真自动时发一行。
         if (config.memoryPersistenceCapable === undefined && effectiveMemoryPersistenceCapable(config) === true) {
             logger.info?.("memory_persistence_capable_auto_declared", {
                 lane: lane ?? "in-process",
@@ -286,10 +173,6 @@ export async function openStores(ctx) {
             });
         }
     }
-    // RosterStore(agent-team S1 server 半场,[1070]① 提货单;core 1.316 `RunnerDeps.rosterStore`):
-    // 具名子 agent 持久名册。形态跟 StoreBackend:tidb/pg=SQL twins(语义三条+真双库验证,
-    // roster-store-sql.ts 顶注);local=core FileRosterStore(dataRoot 下 roster.json,core 自带原子写/
-    // 损坏安全);无 backend(纯内存 dev)=不挂(core 用活注册表,跨 run 指针面自然缺席——诚实)。
     let rosterStore;
     {
         const mysqlPool = backend?.mysqlPool?.();
@@ -304,8 +187,6 @@ export async function openStores(ctx) {
             rosterStore = new TiDBRosterStore(mysqlPool);
         }
         else if (backend?.kind === "local") {
-            // #109([2392] 提货):onCorruptRead 披露座接线——腐读响亮 warn([2195] 族:不静默折空)。
-            // 三挂点里 server 真用的只有这一个(session-policy=自家 SQL 双店;mailbox 用的 FileMailboxStore 无此座)。
             rosterStore = new FileRosterStore(join(config.localDataRoot ?? localRoot, "roster.json"), {
                 onCorruptRead: (info) => logger.warn("roster_corrupt_read", { path: info.path, reason: info.reason }),
             });
@@ -313,15 +194,6 @@ export async function openStores(ctx) {
         if (rosterStore)
             logger.info("roster_store_enabled", { backend: pgPool ? "pg" : mysqlPool ? "tidb" : "file" });
     }
-    // BackgroundAgentStore(design/151 S1 server 半场,[1503] 提货单;core 1.364 durable background agents):
-    // 后台子代 `a*` 行的 durable 执行记录——settle 后转录 session 不再 eager release(TaskOutput/
-    // AgentTranscript 完成后照读全程),清理移交 reapDurableAgents(reaper 区)。形态跟 roster:
-    // tidb/pg=SQL twins(真双库验证,background-agent-store-sql.ts 顶注);local=core
-    // FileBackgroundAgentStore(dataRoot 下 background-agents/,core 自带 ledger+snapshot 原子写);
-    // 无 backend(纯内存 dev)=不挂(core 契约:store 不接线=pre-151 逐字节等价——单进程 live 注册表
-    // 已覆盖读面,诚实缺席)。⚠️ 同实例双点挂载:RunnerDeps.backgroundAgentStore(读半场)+
-    // ScenarioDeps→SubagentToolOptions.background.agentStore(写半场)都用这一个引用——engine 无法核对
-    // 配对,半接=静默死特性(RB-37①)。
     let backgroundAgentStore;
     {
         const mysqlPool = backend?.mysqlPool?.();
@@ -336,28 +208,16 @@ export async function openStores(ctx) {
             backgroundAgentStore = new TiDBBackgroundAgentStore(mysqlPool);
         }
         else if (backend?.kind === "local") {
-            // core 1.368([1516]②)listScopes 落地:file 实现自带枚举——1.248 拍的「local+多租户 reap 缺口」
-            // warn-once 已撤(reaper 腿现在真枚举,不再假设单 scope)。
             backgroundAgentStore = new FileBackgroundAgentStore(config.localDataRoot ?? localRoot);
         }
         if (backgroundAgentStore)
             logger.info("background_agent_store_enabled", { backend: pgPool ? "pg" : mysqlPool ? "tidb" : "file" });
     }
-    // D-1 通用文件上传(clay 拍 2026-07-27):独立附件 store(不骑 snapshot blob 面——那套的 orphan GC
-    // 会把非 manifest 引用的 bytes 误收;生命周期也不同:附件跟 task/session 绑定)。形态跟 StoreBackend
-    // 三态:tidb/pg=SQL twins(真双库验证)、local=文件店;无 backend(纯内存 dev)=不挂 ⇒ 路由 501。
-    // 四半场:①上传/取回/删除(http/server.ts 路由)②提交时绑定+objective 告知+host lane 物化
-    // (resolveSpec 内,下方)③远程 lane env 建立时物化(executionEnvFactory 包装,下方)④生命周期
-    // (E21 purge 级联 + 未绑定 TTL reaper)。
     let taskAttachmentStore;
     {
         const mysqlPool = backend?.mysqlPool?.();
         const pgPool = backend?.pgPool?.();
         if (pgPool || mysqlPool) {
-            // clay 裁(2026-07-27):**云形态对象存储必配**——附件字节本体进 MinIO(SQL 只存 meta/门/生命周期)。
-            // 复用快照 lane 的同一 MinIO 部署配置(MINIO_ENDPOINT/ACCESS/SECRET,零重映射),但**附件专属
-            // keyPrefix**:对象键=sha256,与快照 blob 同 sha 不同生命周期,同名字空间会互删。未配 ⇒ 附件面
-            // 不接线(路由 501)+ error 级日志——这是部署配置错误,不静默降级回「字节进 DB」(该形已被裁掉)。
             const minio = config.snapshotBlobStore;
             if (!minio) {
                 logger.error("attachments_disabled_object_store_required", {
@@ -383,11 +243,6 @@ export async function openStores(ctx) {
         if (taskAttachmentStore)
             logger.info("task_attachment_store_enabled", { backend: pgPool ? "pg+minio" : mysqlPool ? "tidb+minio" : "file", maxBytes: config.attachmentMaxBytes });
     }
-    // S3c(core 1.374 行为车,[1531]):teammate 信箱——SendMessage 对 SETTLED named teammate 的 tier-3
-    // 懒复活链(durable 行解析→claim-CAS→mailbox append→reviveSpawn→attach 屏障后 ack)。激活三件套=
-    // RunnerDeps.mailboxStore + backgroundAgentStore 同挂 + delegation 工具在场,三缺一=1.373 文本字节
-    // 不变(诚实拒)。形态同上:tidb/pg=SQL twins(mailbox-store-sql.ts,发车复审八修顶注);local=
-    // core FileMailboxStore;纯内存 dev=不挂。回执句族(details.error 枚举)wire 透传零改动。
     let mailboxStore;
     {
         const mysqlPool = backend?.mysqlPool?.();
@@ -401,7 +256,6 @@ export async function openStores(ctx) {
             mailboxStore = new TiDBMailboxStore(mysqlPool);
         }
         else if (backend?.kind === "local") {
-            // #113([2399]③→[2408] core 5.2.0 补座):腐读披露——照 roster 同形;torn-tail 静默=core 有意边界。
             mailboxStore = new FileMailboxStore(config.localDataRoot ?? localRoot, {
                 onCorruptRead: (info) => logger.warn("mailbox_corrupt_read", { path: info.path, reason: info.reason }),
             });
@@ -409,11 +263,6 @@ export async function openStores(ctx) {
         if (mailboxStore)
             logger.info("mailbox_store_enabled", { backend: pgPool ? "pg" : mysqlPool ? "tidb" : "file" });
     }
-    // design/166-T1:治理窗账本店——只在 USAGE_WINDOWS 配置时构造(两键成对进 RunnerDeps,core 的
-    // 「windows 有 store 无=INACTIVE 警告」在构造上被排除)。形态跟 mailbox:tidb/pg=SQL twins
-    // (ensure-first+行锁,真双库验证,usage-window-store-sql.ts 顶注);local=core FileUsageWindowStore
-    // (构造器内部自拼 usage-windows/,直传数据根——复审新6);纯内存 dev=core InMemoryUsageWindowStore
-    // (进程内计数,单进程 dev 的诚实形——治理窗设了就得生效,不因无持久层而静默失活)。
     let usageWindowStore;
     if (config.usageWindows) {
         const mysqlPool = backend?.mysqlPool?.();
@@ -434,15 +283,8 @@ export async function openStores(ctx) {
         }
         logger.info("usage_window_store_enabled", { backend: pgPool ? "pg" : mysqlPool ? "tidb" : backend?.kind === "local" ? "file" : "memory", windows: config.usageWindows.length });
     }
-    // 142-S5 §1.4: the per-scope export READ face lights up only on the DB memory plane (the multi-tenant
-    // truth lives in the scope-partitioned tables; the file posture exports by copying the memory dir, so
-    // the route 501s honestly there). History-table WRITE wiring: inside the backend construction above
-    // (S5.1, opts.history — the write point lives in the handed-over backend code).
     const memoryExportBackend = config.memoryEngineBackend !== "file" ? memoryEngine?.backend : undefined;
-    const memoryLane = memoryEngineRemoteLanePosture(config); // N0: worker/sandbox file-plane split posture
-    // #252 件2/件3:记忆面姿态 —— **单一推导点**(纯,memory-posture.ts),两个读面(operator 诊断 /
-    // 能力位)都投影它,启动日志的 dark 报因也走它的闭集词,于是「日志说暗、能力位说亮」不可能发生。
-    // 位置:两支引擎装配都结束之后(要 `memoryEngine` 与 `vectorMode` 两件装配结果)。
+    const memoryLane = memoryEngineRemoteLanePosture(config);
     const memoryPosture = buildMemoryPosture({
         config,
         engineWired: memoryEngine !== undefined,
@@ -454,23 +296,12 @@ export async function openStores(ctx) {
             ? { enabled: true, backend: "file", dir: memoryEngine.root }
             : {
                 enabled: false,
-                // 复审 F-11:按最终门结果报因,多租户 file=隔离判据,其余照旧。
-                // #252:散文由**闭集词**派生(`memoryPosture.darkReason`)——机器面与人面从此不会各报各的因。
                 reason: DARK_REASON_PROSE[memoryPosture.darkReason ?? "engine_off"](memoryLane?.lane),
             });
     }
-    // N0 boot warn: loud in BOTH postures — "dark" so an upgrade that silently turns memory off is visible,
-    // "forced" so an operator override states what it depends on (harvest only sees the WORKER fs). 文案与分腿
-    // 判据在 memory-scope.buildMemoryRemoteLaneWarn(纯,可单测);这里只喂**装配结果**(引擎真接上了没有)——
-    // DB 腿的引擎在 :113 就点亮了,与车道姿态无关,照旧打 dark 文案会与上面的 memory_engine_enabled 对撞。
     const laneWarn = buildMemoryRemoteLaneWarn(config, memoryEngine !== undefined);
     if (laneWarn)
         logger.warn("memory_engine_remote_lane", laneWarn);
-    // 142-S2.5-W1: TOC 同步 client 腿——只在 file memory 形态接线(loadConfig 已拒 DB backend
-    // 上的 MEMORY_SYNC_*,这条分支到不了)。boot 后 fire-and-forget 一轮(失败 warn 不阻断——纯本地现状
-    // 是安全降级面);之后 harvest 真有 patch 落地时再触发(onMemoryHarvestReport 站点,inflight 节流)。
-    // 引擎 dark(多租户/MEMORY_ENGINE=off/remote lane)⇒ 无本地盘可同步:warn 不 throw(dark 的三个成因
-    // 各有自己的 loud 日志在上方,这里补“sync 因此没跑”这半句,operator 可见不半配)。
     let memorySyncRunner;
     if (config.memorySync) {
         if (memoryEngine) {
@@ -480,7 +311,6 @@ export async function openStores(ctx) {
                 memoryRoot: memoryEngine.root,
                 transport: createMemorySyncTransport({ url: config.memorySync.url, token: config.memorySync.token }),
                 log: logger,
-                // S2.5 分批(core 1.284):未设=不分批 wire 字节不变;设了=续轮 loop 至收敛(MAX_SYNC_ROUNDS 警戒)。
                 ...(config.memorySync.maxPushEntries !== undefined ? { maxPushEntries: config.memorySync.maxPushEntries } : {}),
                 ...(config.memorySync.maxPullEntries !== undefined ? { maxPullEntries: config.memorySync.maxPullEntries } : {}),
             });
@@ -491,13 +321,6 @@ export async function openStores(ctx) {
             logger.warn("memory_sync_configured_but_memory_dark", { note: "MEMORY_SYNC_URL is set but the file memory engine is dark (multi-tenant / MEMORY_ENGINE=off / remote exec lane) — no sync rounds will run" });
         }
     }
-    // #318([4659] F2 → [4692] 定谳):会话级任务清单车道。形态与 roster/mailbox/background-agent 同族
-    // (pg/tidb = SQL twins;无 SQL 后端 = 进程级 per-session 内存店 —— 这一支**刻意不缺席**:缺席就是
-    // 修前那个「每 turn 一只新私店」的病本身,而 local/内存形至少要把同一会话的跨 turn 连续性拿回来)。
-    // 全部判据(listKey 派生、LRU、为什么 SQL 形也缓存实例)见 boot/task-list-lane.ts 顶注。
-    // ⚠️ 建表在**本文件**发 —— `test/schema-baseline-generated.test.ts` 判据 ③b 拿「boot/stores.ts 里真被
-    // await 的 ensure 名」与 schema 基线生成器的驱动清单做集合相等对账(消灭「两条方言同时漏一族表」的
-    // 对称盲区,`usage_window` 曾整族漏在基线外)。DDL 藏进车道文件 = 那道门看不见它。
     const taskListLane = await (async () => {
         const mysqlPool = backend?.mysqlPool?.();
         const pgPool = backend?.pgPool?.();
@@ -507,20 +330,7 @@ export async function openStores(ctx) {
             await ensureTiDBTaskListSchema(mysqlPool);
         return createTaskListLane({ mysqlPool, pgPool, logger });
     })();
-    const sessionStore = createSessionStore(config, backend, metrics); // S25: stale-affinity evict fingerprint
-    // 🪦 S6 启动门(旧):判据曾是 `!sessionStore.ownerOf`,core 2.11.0 给 TtlSessionStore 补了 owner 面后**恒假**。
-    //    2026-08-01 复审一度把判据改成「归属能否跨重启存活」以复活它 —— **那是错的,已撤**(cli [C46] 的
-    //    多租真机围栏当场证伪:`REQUIRE_PRINCIPAL=true` + 内存店必须**起得来**且真隔离)。
-    //    错在威胁模型:内存店重启后**会话数据本身也没了**,"先到者认领 session id" 认领到的是空壳,
-    //    alice 的历史随进程消失 —— 归属丢失 ≠ 数据泄露。真正危险的是**数据留存而归属丢失**的 file 形,
-    //    那一形由下面那道 local 门拦住(它的论证里 "session/run CONTENT is durable there" 正是这个区别)。
-    //    ⇒ 这道门防的威胁(store 没有归属能力)已被 core 2.11.0 消除,补偿该撤,不该换个判据续命。
-    //    判据跟目的走、不跟补偿走(cli [C46] 的原话,我抄下)。反向钉见 test/security.test.ts。
-    // The local in-memory backend HAS an ownerOf (LocalSessionStore), so the guard above passes — but its owner map is
-    // process-local + lost on restart, so it cannot DURABLY enforce multi-tenant ownership (post-restart a session id is
-    // re-claimable by whoever attaches first). Refuse REQUIRE_PRINCIPAL on it: a real multi-tenant
-    // boundary needs the durable DB backend; single-user local runs with REQUIRE_PRINCIPAL=false (the principal may
-    // still ride for memory-scoping). The file-backed follow-on (durable owners) can revisit this.
+    const sessionStore = createSessionStore(config, backend, metrics);
     if (config.requirePrincipal && backend?.kind === "local") {
         throw new Error("REQUIRE_PRINCIPAL=true is not supported on the local file backend (DB_BACKEND=local): session/run CONTENT is " +
             "durable there, but OWNER attribution is process-local and lost on restart (store-backend.ts §0.5 — durable " +
@@ -528,27 +338,17 @@ export async function openStores(ctx) {
             "(DB_BACKEND=mysql|pg) for multi-tenant, or run local single-user with REQUIRE_PRINCIPAL=false (a BFF may " +
             "still inject x-agent-principal per request for memory scoping and audit attribution).");
     }
-    // (c)(clay 拍 a+c,2026-07-27)云形快照 blob 姿势门:mysql|pg 后端缺 MinIO ⇒ fail-loud(bytes-in-DB
-    // 撞包墙已两役实证);SNAPSHOT_BLOB_ALLOW_SQL_BYTES=true 显式逃生(单机/测试台,吃 (a) 的 per-blob 帽)。
     if (backend)
         assertCloudSnapshotBlobPosture(backend.kind, config);
-    // Posture warning (audit B, security.ts): an owner-aware store without REQUIRE_PRINCIPAL means the
-    // principal layer is optional per request. Owned sessions are still protected (the authorizer rejects
-    // anonymous/mismatched attach), but new headerless submissions create anonymous sessions any token
-    // holder can attach to — a multi-tenant deployment should set REQUIRE_PRINCIPAL=true.
     if (!config.requirePrincipal && sessionStore.ownerOf) {
         logger.warn("principal_optional", {
             note: "owner-aware session store with REQUIRE_PRINCIPAL=false — owned sessions are protected, but headerless callers can create/share anonymous sessions; set REQUIRE_PRINCIPAL=true for multi-tenant",
         });
     }
     metrics.dynamicGauge("sessions_warm", "Sessions held in the warm cache", () => sessionStore.size);
-    // 1.38 cross-replica circuit-breaker state: shared via TiDB when a pool exists AND the breaker is
-    // enabled; otherwise core's per-process Map (single replica / no DB / breaker off). Refresh loop is
-    // unref'd so it never holds the process open.
     const breakerState = backend?.breaker && config.resilience.circuitBreaker
         ? backend
             .breaker((streak) => {
-            // LOW (SILENT-FALLBACK P1): cross-replica breaker write-through failures were a bare swallow.
             metrics.setGauge("counter_flush_fail_streak", streak, { table: "circuit_breaker", kind: "write_through" });
             if (streak > 0)
                 metrics.inc("breaker_writethrough_failed_total", { backend: backend.kind });
@@ -558,7 +358,7 @@ export async function openStores(ctx) {
                 logger.info("breaker_writethrough_recovered", {});
         })
             .startRefresh()
-        : undefined; // local omits breaker() → core's per-process Map
+        : undefined;
     return {
         backend, storeBackendDegraded, memoryEngine, memorySyncCursors, rosterStore, backgroundAgentStore,
         taskAttachmentStore, mailboxStore, memoryExportBackend, memorySyncRunner, sessionStore, breakerState,

package/dist/boot/task-list-lane.js

@@ -1,28 +1,14 @@
 import { createMemoryTaskListStore } from "@sema-agent/core";
 import { BoundedSessionMap } from "../bounded-session-map.js";
 import { createPgTaskListStore, createTiDBTaskListStore, deletePgTaskList, deleteTiDBTaskList, taskListKeyFor, } from "../plugins/task-list-store-sql.js";
-/** 同时活着的会话清单实例上限(LRU,逐最老)。与 perSessionCwd/perSessionShellEnv 同量级。 */
 export const MAX_TASK_LIST_SESSIONS = 4096;
-// listKey 派生式的**属主是 store 文件**(`plugins/task-list-store-sql.ts` 的 {@link taskListKeyFor}
-// ——字节约束在那边,留存腿也按同一只函数批量删行;派生有两份 = 在线删得掉、留存腿删不掉)。
-// 这里只是把它一并导出,消费方(index.ts / 测试)不必知道它住在哪一层。
 export { taskListKeyFor } from "../plugins/task-list-store-sql.js";
-/**
- * 车道构造(boot 期一次)。
- *
- * ⚠️ **建表不在这里**:`ensure{TiDB,Pg}TaskListSchema` 由 `boot/stores.ts` 在构造之前 await
- * (与 roster/mailbox/background-agent/usage-window 四族逐字同姿势)。理由不是风格——
- * `test/schema-baseline-generated.test.ts` 判据 ③b 拿「`boot/stores.ts` 里真被 await 的 ensure 名」
- * 与「生成器驱动的清单」做**集合相等**对账,那是消灭「两条方言同时漏一族表」这个对称盲区的唯一
- * 不对称真源(`usage_window` 曾整族漏在基线外)。DDL 藏在本文件里 = 那道门看不见它。
- */
 export function createTaskListLane(opts = {}) {
     const { mysqlPool, pgPool, logger } = opts;
     const maxSessions = opts.maxSessions ?? MAX_TASK_LIST_SESSIONS;
     const cache = new BoundedSessionMap(maxSessions);
     let backend;
     let mint;
-    /** 后端侧的整份清单抹除(memory 形无后端 ⇒ 只靠下面的缓存逐出)。 */
     let purge;
     if (pgPool) {
         backend = "pg";
@@ -41,7 +27,6 @@ export function createTaskListLane(opts = {}) {
     }
     const storeFor = (sessionId) => {
         const hit = cache.get(sessionId);
-        // 命中即回写 = 刷新 MRU(BoundedSessionMap 的 `get` 刻意不动顺序,逐出闩只看 `set` 的插入序)。
         if (hit !== undefined) {
             cache.set(sessionId, hit);
             return hit;
@@ -51,9 +36,6 @@ export function createTaskListLane(opts = {}) {
         return fresh;
     };
     const deleteBySession = async (sessionId) => {
-        // 先逐出缓存再删后端:反过来的话,两者之间的窗口里一次并发解析会拿到**旧实例**(memory 形
-        // 是旧数据本身;SQL 形是刚被删空的分区,新写会把行插回去)。缓存先走 = 那扇窗里的解析看到的
-        // 是一份新铸的空清单,与「会话已删」一致。
         cache.delete(sessionId);
         await purge(sessionId);
     };

package/dist/boot/webfetch-summarize-lane.js

@@ -1,50 +1,6 @@
-/**
- * A-057.5 [CONFIRMED high](2026-08-19 三轴组复审,真机探针复现)—— WebFetch 摘要面的
- * **per-model key plane**,与 `boot/side-query-lane.ts` 同一只 wrapper、同一条纪律。
- *
- * ## 病灶(#303 的第四面,逐字同形)
- *
- * #303 的头注写「side-query 是 key plane 三面里**唯一**缺席的那一面」—— 那句话是假的。
- * `createWebFetchSummarizer(brain, model)` 的 `brain` 是 `RunnerDeps.brain` 那只**裸网关 brain**
- * (`boot/budget-tracing.ts` 的 `createBrain(config, …)`,`get apiKey()` 恒回 `config.gatewayApiKey`),
- * 而 core 的摘要腿(`dist/tools/web.js`)铸 options 只放 `{ signal }`——`WebFetchSummarizerOptions`
- * 结构性没有 key 座位。于是 openai brain 的那两行照旧:
- *   `const apiKey = options?.apiKey ?? config.apiKey;`   ← 缺席即回落**主网关 key**
- *   `const root = (model.baseUrl || config.baseUrl || "")` ← 却**按模型**选路
- * ⇒ summarize 角色解析到一只带自有 `baseUrl` + `apiKeyEnv/sealedApiKey` 的模型时,**主网关 key 被发到
- * 那只模型自己的外部 URL**;而且这不落在 #303 已具名接受的那条残余里(那条说的是「**没有** per-model
- * key 的 off-route 模型仍收网关 key」)—— 这只模型**有**自己的 key,却拿不到。
- *
- * 第二半同样成立:毒丸(sealed key 解不开)在本面**静默回落网关账号** —— 本面根本不经
- * `resolveModelApiKey`,`key-resolver.ts` 顶注那句「a broken sealed key must NEVER silently burn the
- * shared gateway account」在这条路上不成立。
- *
- * ## 修形 = 照 #303 的配方接第四面(不是新造语义)
- *
- * brain 换成 `createPerModelKeyBrain(brain, getKeyResolver)`:
- *  · 有 per-model key ⇒ 注入 `options.apiKey`,请求带模型自己的凭据;
- *  · 无 ⇒ 不注入 ⇒ 回落网关 key(与主推理链/side-query 逐字同语义,additive 契约;该残余的成文与
- *    跨面收严件见 side-query-lane.ts 顶注「具名残余」段与 A-057.59);
- *  · 毒丸 ⇒ **上抛**,一个字节都不发(CLAUDE.md #157 安全轴 fail-closed)。
- * wrapper 只包本席这一只引用,`RunnerDeps.brain` 零扰动(与 side-query 席同形)。
- *
- * ## 为什么住在 `boot/` 而不是继续躺在 `main()` 的闭包里
- *
- * ① 这是一条**可发射的 LLM 面**,必须能被黑盒探针(真 fetchImpl 捕 Authorization)直接驱动 —— 躺在
- *    `main()` 里只能靠源码字面锚,而本仓已成文「源码字面锚有致命假绿形」(A-057.4/.11 那一族);
- * ② 发射面枚举门(`test/per-model-key.test.ts` 的 `DIRECT_EMISSION_FACES`)按**文件**登记在册,第四面
- *    有自己的文件才登记得住。
- *
- * 原地保留的两条既有语义(E-MED-2/E-MED-3,[1900]/[1904] 复审批):
- *  · **惰性解析**:模型每次调用现取 —— `config.models`/`config.roles` 会被 center 的 effective 热应用
- *    `mutateInPlace` 整表替换,boot 期急求值会把摘要器永久 pin 在占位/旧模型上;
- *  · **fail-soft**:`resolveTaskModel` 在无可解析角色时 throw,这是全仓唯一 boot 期裸调用点;解析失败
- *    ⇒ 本次不摘要(core 的 summarize 抛错是 fail-open:回退原文 + note),绝不崩 boot。
- */
 import { createWebFetchSummarizer, resolveTaskModel as coreResolveTaskModel } from "@sema-agent/core";
 import { createPerModelKeyBrain } from "./side-query-lane.js";
 export function createWebFetchSummarizeLane(ctx) {
-    // 与 side-query 席同形:wrapper 装配一次,resolver 靠 `getKeyResolver` 活取(热应用后下一次调用即生效)。
     const brain = createPerModelKeyBrain(ctx.brain, ctx.getKeyResolver, { gatewayBaseUrl: ctx.config.gatewayBaseUrl });
     return async (content, prompt, signal) => {
         const model = (() => {
@@ -58,9 +14,6 @@ export function createWebFetchSummarizeLane(ctx) {
         })();
         if (!model)
             throw new Error("summarize model unresolved for this deployment");
-        // core 2.13.0:返回形放宽为 additive union(`string | { text, truncated? }`)—— 这里**原样转发**
-        // core summarizer 的返回值,不在本仓收窄成 string(收窄会把 core 的截断披露 `truncated` 吃掉,
-        // 让「内容被截断」这个事实在 fence 外消失)。
         return createWebFetchSummarizer(brain, model)(content, prompt, signal);
     };
 }