@sema-agent/server 7.43.0 → 7.44.0

package/dist/http/routes/leader.js

@@ -5,23 +5,13 @@ export async function handleLeader(req, res, url, ctx) {
     await handleLeaderBody(req, res, url, ctx, miss);
     return !miss.fell;
 }
-/** 路由体 = 从 `server.ts` 的 `handle()` 里**整段剪切**过来的原文(唯一改动:统一去缩进两格)。
- *  注意本域的落空语义:`deps.leaderEndpoint` 在但 URL 不匹配、或 endpoint 返回 undefined,都要**继续**
- *  往下走(原文的 if 块不 return),故只有真的应答过才算已处理——由末尾的 `miss.fell` 如实表达。 */
 async function handleLeaderBody(req, res, url, ctx, miss) {
     const { deps } = ctx;
     const { readJson, rateLimited, quotaExceeded, leaseDenied } = ctx.helpers;
-    // v2 leader endpoint (design/50): POST /v1/leader (async, like /v1/runs) + GET /v1/leader/:id.
     if (deps.leaderEndpoint) {
         const isLeaderPost = req.method === "POST" && url === "/v1/leader";
         const isLeaderGet = req.method === "GET" && /^\/v1\/leader\/[^/]+$/.test(url);
         if (isLeaderPost || isLeaderGet) {
-            // BL-4: gate the leader route through the SAME identity layer as /v1/runs — previously it skipped
-            // authorize/requirePrincipal entirely and recorded no owner, so any service-token holder could submit
-            // and read ANY tenant's leader run. Enforce requirePrincipal (401 before any work), then pass the
-            // resolved principal so the endpoint records it as the run owner (POST) and 404s non-owners (GET).
-            // 🔴 F-fix: VERIFIED identity (gatedPrincipal) for the leader-run owner — a spoofable header would let a
-            // direct-door caller submit/read another tenant's leader run (the recorded owner gates the GET 404).
             if (deps.config.requirePrincipal && !gatedPrincipal(req, deps.config)) {
                 sendError(res, 401, "auth.principal_required", `missing principal header '${deps.config.principalHeader}'`);
                 return;
@@ -38,9 +28,6 @@ async function handleLeaderBody(req, res, url, ctx, miss) {
                     sendError(res, 400, "request.invalid_json", "invalid JSON body");
                     return;
                 }
-                // #193 车4 件1:`Idempotency-Key` 头接到 leader 的 durable 提交幂等上(与 POST /v1/runs、
-                // POST /v1/images/bakes 同一条头名)。原始头值原样递给 endpoint —— 按提交者 scope + 定宽
-                // hash 都发生在那一层(`leaderIdemKey`),路由层不做语义加工。
                 const r = await deps.leaderEndpoint.handle("POST", url, body, requester, headerStr(req.headers["idempotency-key"]) ?? null);
                 if (r) {
                     sendJson(res, r.status, r.body);

package/dist/http/routes/memory-bundle.js

@@ -3,29 +3,8 @@ import { sendJson, sendError } from "../send.js";
 import { gatedPrincipal, explicitOperatorOk } from "../principal-gate.js";
 export const MEMORY_BUNDLE_EXPORT_PATH = "/v1/memory/export";
 export const MEMORY_BUNDLE_IMPORT_PATH = "/v1/memory/import";
-/** export 请求体 —— **形**验(义归 core;见文件头「验型的分权」)。 */
 const ExportRequestSchema = z.object({ scopes: z.array(z.string().min(1)).min(1) });
-/** import 请求体 —— 只断言 `bundle` 是个**对象**;整包判决是 core 的单一属主面。
- *  `z.record(z.string(), z.unknown())` 而不是 `z.object({...})`:在本层写出 bundle 的字段表就是复制
- *  core 的 schema(第二真源),而 `z.unknown()` 的 record 恰好表达「结构由下游判」。 */
 const ImportRequestSchema = z.object({ bundle: z.record(z.string(), z.unknown()) });
-/**
- * core 抛出的**已分类**错误 → HTTP 状态。闭集穷举 `switch`:core 新增一个码 ⇒ 这里落 `undefined`
- * ⇒ 走 500 fail-loud(而不是被某个默认臂静默塞进 4xx)。安全轴上的静默默认值正是本仓禁止的东西。
- *
- *  · `config.memory_{export,import}_request` = **调用方**给的请求参数不合法(非空/去重/可序列化)⇒ 400;
- *  · `memory.export_incomplete` = 店**声明自己说不清**(chain-degraded / 无导出复合面)⇒ 409:不是请求
- *    的错、也不是服务器故障,是**当前状态**下这个包铸不出来(去修 chain 或换后端后重试即改判);
- *  · `memory.import_rejected` = 请求**形**合法但**内容**不可接受(整包拒批,零落地)⇒ 422 —— 与 400
- *    分家是承重的:400 说"你的 HTTP 请求写错了",422 说"包本身被判不合格",两句话的运维动作不同。
- *
- * 🔴 每一支都把码**再写一遍字面量**(而不是 `sendError(res, status, code, …)` 把变量透下去):错误码
- * 目录门(test/error-code-catalog-live.test.ts)是**扫源码字面量**的,变量态的码整条对它隐形 ⇒ 这四个
- * 码会「wire 上发得出来、附录 A 里查不到」。同门另有一张中继登记表可走,但那张表是**有上限的棘轮**
- * (「码不写字面量」不许变成默认写法),而这里本来就该是一张闭集词表 —— 写字面量既过门又把闭集写实。
- */
-// ⚠️ 形参叫 `coreCode` 而不是 `code`:错误体自 core 3.0.0 起**只有** `errorCode`,而 test/error-code-key-gate
-// 扫的是「还在发 legacy `code` 键」的站点(文本判据)——一个叫 `code` 的形参会被它当成那种站点收走。
 function sentCoreCode(res, coreCode, message) {
     switch (coreCode) {
         case "config.memory_export_request":
@@ -44,36 +23,19 @@ function sentCoreCode(res, coreCode, message) {
             return false;
     }
 }
-/** core 的抛出形 = `Error` + `.code`(engine.js 逐字)。裸 as-cast 禁令下的判别式读法。 */
 function codeOf(err) {
     if (!(err instanceof Error))
         return undefined;
     const { code } = err;
     return typeof code === "string" ? code : undefined;
 }
-/**
- * 引擎调用的统一收尾:已分类的码**原样**上 wire(码与 core 的诊断文案都不改写 —— 那句文案是运维排障
- * 的第一手材料,判据帖 G3 就断言它含 "chain-degraded");未分类的一律 500 且**不回显**内部文本。
- * 返回 true = 已应答。
- */
 function sentClassifiedFailure(res, ctx, face, err) {
     const code = codeOf(err);
     if (code !== undefined && sentCoreCode(res, code, err instanceof Error ? err.message : String(err)))
         return true;
     ctx.deps.logger?.warn?.(`memory_bundle_${face}_failed`, { err: String(err) });
-    return false; // 未分类 ⇒ 调用方发它自己那句 500(见下面两处的**内联字面量**)
+    return false;
 }
-/**
- * `MemoryImportReport` → wire 的**显式白名单**投影。
- *
- * 🔴 为什么是显式白名单而不是整行透传:报告是**治理处置**的清单,core 日后加一个新的处置座(例如又一
- * 类"被扣下的行"),整行透传会让它**静默**上 wire 而没人给它写过契约;白名单让它变成**编译错误**
- * (`test/memory-bundle-http.test.ts` 的差集断言 = `wire-whitelist-exhaustiveness` 同款门形)。
- * 今天**每一个**键都在场:每一条都是 operator 判「这次导入到底发生了什么」必须看到的东西,一个都
- * 不该省 —— 「每个否定处置都被报告,绝不静默」是 core 对这份报告的原话。
- */
-// 🔴 **不要**给这个函数标 `: Record<string, unknown>` 返回型:那会让 `keyof ReturnType<…>` 塌成 `string`,
-// 上面那道编译期差集门当场变成**恒真**(vacuous)—— 写这条钉时正踩到过。返回型交给推断,键集才是字面的。
 export function buildImportReportWire(r) {
     return {
         v: r.v,
@@ -107,35 +69,21 @@ async function handleMemoryBundleBody(req, res, url, ctx, miss) {
         miss.fell = true;
         return;
     }
-    // ── 身份(401)── direct-door safe:验证过的身份,不是可伪造的头。
     const principal = gatedPrincipal(req, deps.config);
     if (deps.config.requirePrincipal && !principal) {
         sendError(res, 401, "auth.principal_required", `missing principal header '${deps.config.principalHeader}'`);
         return;
     }
-    // ── 授权(403)── 治理面 fail-closed,与 adoption / retention-ops 同一条门。
-    // ⚠️ 文案写**内联字面量**而不是抽个模块常量:文案冻结门(test/api-error-text-freeze.test.ts)是**扫源码
-    //    文本**的,把 message 换成一个常量名的写法它结构性够不到 ⇒ 这句 wire 文案就没有被冻住。
-    //    ⚠️ 本段注释里也不许照抄一个带状态码与引号码名的调用样例 —— 那道门的提取器会把**注释里**的样例
-    //    当成一条真站点收走(写这条注时真的踩到过:凭空多出一个 `403:code` 对)。
-    //    两口同受众同理由,所以两处逐字同一句(族断言按去重集合比,同串出现两次不改判)。
     if (!explicitOperatorOk(principal, deps.config.operatorPrincipals)) {
         sendError(res, 403, "auth.operator_only", "memory governance bundles are an operator-only deployment action");
         return;
     }
-    // ── 能力(501)── 在授权之后:部署形态不对越权者泄漏。
-    // ⚠️ 与 `capability.memory_store_required`(GET 导出面要 DB 平面)**刻意不合并**:两码的运维动作相反
-    //    (那条要 pg|tidb,本条要引擎在场且后端带 bundle 复合面),消费端真会分支——附录 A 判据②。
-    // 🔴 缺席有**两个**成因,文案两个都点名(codex [medium] 后修:此前只说「引擎没接线」,而 pg/tidb 部署
-    //    是引擎接了、后端没那两个可选面 —— 只说一半会让运维去查一个根本没问题的旋钮)。两因同码:消费端
-    //    的分支一样(本部署做不了 bundle,换部署形态),分成两码只会让码表长一倍而判据不变(判据②)。
     const engineExport = deps.memoryBundleExport;
     const engineImport = deps.memoryBundleImport;
     if (engineExport === undefined || engineImport === undefined) {
         sendError(res, 501, "capability.memory_engine_required", "memory governance bundles are not available on this deployment — they require a wired memory engine (MEMORY_ENGINE=on) whose backend implements the v2-c bundle composite (exportSnapshotOf / importBundleCommit); the file memory backend does, the pg/tidb memory backends do not");
         return;
     }
-    // ── 验型(400)── 体读的 413/400(超长 / 坏 JSON)由顶层 typed catch 统一处理(鉴权已完成)。
     const raw = await ctx.helpers.readJson(req);
     if (isExport) {
         const parsed = ExportRequestSchema.safeParse(raw);
@@ -144,14 +92,10 @@ async function handleMemoryBundleBody(req, res, url, ctx, miss) {
             return;
         }
         try {
-            // 🔴 bundle **原样**下发(含 `doc` 披露段)—— 投影它就是替铸包方复述披露,见文件头。
             const bundle = await engineExport(parsed.data.scopes);
             sendJson(res, 200, bundle);
         }
         catch (err) {
-            // 未分类 ⇒ 500,文案是**内联整串**(不是 `memory bundle ${face} failed` 模板):冻结门的模板臂只
-            // 钉到第一个 `${` 为止,"memory bundle " 这个前缀会把「哪一半炸了」留在门外,而那正是消费端能从
-            // 500 上读到的全部信息。同族先例:"memory export failed" / "memory sync failed"(memory-policy.ts)。
             if (!sentClassifiedFailure(res, ctx, "export", err))
                 sendError(res, 500, "internal.error", "memory bundle export failed");
         }
@@ -163,10 +107,6 @@ async function handleMemoryBundleBody(req, res, url, ctx, miss) {
         return;
     }
     try {
-        // 整包判决(结构/完整性/授权信封)全在 core:本层递交的就是调用方给的那个对象。
-        // 递交的是**未校验**的对象:整包判决(结构/完整性/授权信封)是 core 的单一属主面,所以 seam 的
-        // 入参类型就写 `unknown` —— 在本层把它断言成 MemoryExportBundle 是**说谎**(我们并不知道它是),
-        // 而说谎的那一下正好把类型检查关灯(type-hygiene 门抓的就是这个)。
         const report = await engineImport(parsed.data.bundle);
         sendJson(res, 200, buildImportReportWire(report));
     }

package/dist/http/routes/memory-policy.js

@@ -3,22 +3,7 @@ import { parseMemorySyncRequest } from "../../memory-sync.js";
 import { sendJson, sendError } from "../send.js";
 import { gatedPrincipal, explicitOperatorOk } from "../principal-gate.js";
 const ORG_PREFIX = "org:";
-/**
- * #271 件3(#275 A2 车立的欠账,[4163] 我方认领)—— `GET /v1/memory/export` 的 keyset 分页上限。
- *
- * 在此之前本面是**整盘导出**:一个几千条目的盘就是一个几 MB 的响应体,壳侧(sema-web 只读页)
- * 无从分次要 —— 那是它真实撞到的天花板。分页是 **additive** 的:`?limit=` 缺席 ⇒ 旧契约逐字不变
- * (全量数组、响应键一个不多),所以现行消费端零破坏;要分页的调用方自己带 `limit` 进来。
- *
- * ⚠️ 诚实记档:本面的分页封的是**回体**(wire 天花板),不是 DB 读 —— reader
- * (`exportMemoryScope`)仍是整 scope 一次读出。真正的下推需要 core 的 `MemoryBackend.listHeaders`
- * 长出分页参数(上游接缝,源头修复纪律:不在本层用别的口硬凑)。壳侧的痛点(响应体大小/首屏)由
- * 本形解决,库侧的读放大另案。
- */
 export const MEMORY_EXPORT_MAX_LIMIT = 500;
-/** 游标 = 条目 `id` 的不透明 base64url(声明序=id 升序;id 是 entry 平面的 PK ⇒ 唯一,单键即全序,
- *  不像 roster 的 `(spawnedAt, handle)` 需要 tiebreak)。`before` / `nextBefore` 是本仓分页的
- *  **同一套词**(roster 先例):调用方只把上一页的 `nextBefore` 原样回传,不解读内容。 */
 function encodeExportCursor(c) {
     return Buffer.from(JSON.stringify(c)).toString("base64url");
 }
@@ -37,38 +22,14 @@ function decodeExportCursor(raw) {
         return { ok: false, why: "cursor payload lacks a non-empty `id`" };
     return { ok: true, cursor: { id } };
 }
-/** 本面是否让目录参与判决。闭集穷举 switch:新增第三个模式是**编译**错误,不会静默落进某个默认臂
- *  ——这条门在授权轴上,静默默认值正是它不许有的东西。 */
 function directoryDecidesThisFace(mode) {
     switch (mode) {
         case "enforce":
             return true;
         case "audit":
-            return false; // 见 gateMemoryScope 顶注的 codex R1 段
+            return false;
     }
 }
-/**
- * memory-policy 两面(export 读 / sync 写)共用的属主门 —— design/170 件A §7「第二消费者收编」。
- *
- * 收编前本门把 `org:*` 写死 operator-only(注逐字「membership waits for the S3 登记簿」),于是同一进程里
- * 「谁属于 org:acme」有两个答案:core 准入门问授权目录、本面问 operatorPrincipals。收编后 `org:` 成员性
- * 只由 `deps.orgMemoryDirectory` 回答(与准入 seam 同一个实例、同一份缓存)。
- *
- * 判决序(前两级刻意在目录之前 —— 它们不需要目录也成立,顺带让常路零额外 I/O):
- *  ① 本人 user 盘逐字匹配 ⇒ 通过;② 显式 operator ⇒ 通过(ops/迁移面不依赖目录在场);
- *  ③ `org:` 键 + 目录在场 + **enforce 模式** ⇒ 查目录:瞬时不可用照原样上抛;取数成功但无该键 ⇒
- *     `not_found`;`need==="write"` 另要条目 `write === true`(读授予不隐含写授予,与准入面 writeScope
- *     收窄同源);④ 其余(`userproj:` 等目录没有答案的键、无目录源的部署、audit 模式)⇒ `not_found`。
- *
- * **audit 模式为什么在本面等于「不接目录」**(codex 对抗审 R1,2026-08-07):`audit` 是 operator 表态
- * 「这份目录还没被验证过,先别拿它做判决」。拿未验证的目录去开真数据面(读)甚至写面,是这条表态能
- * 造成的最严重后果——方向恰好反了;`audit=零行为变化` 的公开契约在本面因此读作「逐字保持收编前的
- * operator-only」,连额外那一跳目录 I/O 和 enforce 才有的 503 响应形都不引入。org 面的诊断信号属于
- * 准入侧的 `memory_admission_total{outcome,mode}`,不在本面另开一路。
- *
- * 拒绝一律 `not_found` 而非 403:本面的零存在性 oracle 纪律不变(与 run/trace 属主门同口径),
- * 「不是成员」和「没这个 scope」对调用方必须不可区分。
- */
 async function gateMemoryScope(deps, principal, scope, need) {
     if (scope === formatUserScope(principal))
         return { kind: "allow" };
@@ -86,18 +47,16 @@ async function gateMemoryScope(deps, principal, scope, need) {
         return { kind: "not_found" };
     return need === "write" && grant.write !== true ? { kind: "not_found" } : { kind: "allow" };
 }
-/** 门的拒绝臂下发:瞬时 ⇒ 503 `memory.admission_required` + `retryAfterSec`(秒上取整,永不 0 —— C6;
- *  族形与 sync 提交腿的同码响应逐字一致);终局 ⇒ 404 零 oracle。返回 true = 已应答,调用方须 return。 */
 function sendScopeGateRefusal(res, gate) {
     if (gate.kind === "allow")
         return false;
     if (gate.kind === "unavailable") {
         const retryAfterSec = Math.max(1, Math.ceil(gate.retryAfterMs / 1000));
-        res.setHeader("retry-after", String(retryAfterSec)); // 体里有等待提示 ⇒ 标准头同值(与同步提交腿的同码应答逐字一致)
+        res.setHeader("retry-after", String(retryAfterSec));
         sendError(res, 503, "memory.admission_required", "org memory directory unavailable — authorization could not be established", { retryAfterSec });
         return true;
     }
-    sendError(res, 404, "not_found.memory_scope", "not found"); // owner gate: no existence oracle
+    sendError(res, 404, "not_found.memory_scope", "not found");
     return true;
 }
 export async function handleMemoryPolicy(req, res, url, ctx) {
@@ -105,27 +64,11 @@ export async function handleMemoryPolicy(req, res, url, ctx) {
     await handleMemoryPolicyBody(req, res, url, ctx, miss);
     return !miss.fell;
 }
-/** 路由体 = 从 `server.ts` 的 `handle()` 里**整段剪切**过来的原文(唯一改动:统一去缩进两格)。裸 `return;`
- *  的语义原样 =「本域已应答」;走到函数尾才是「没匹配上」,置 `miss.fell` 交回装配器继续下一个域。
- *  跨域的东西(deps / 助手 / 单域状态)一律在首行解构出来,于是下面每一行都逐字不变。 */
 async function handleMemoryPolicyBody(req, res, url, ctx, miss) {
     const { deps } = ctx;
     const { readJson } = ctx.helpers;
-    // 142-S5 §1.4 — GET /v1/memory/export?scope=<key>: per-scope memory export (传输中立包=条目全量数组;
-    // C-additive 落点). After the global service-credential gate (a credential/SSO-JWT is already
-    // verified); the OWNER gate here is the tenant boundary: the verified principal may export exactly its OWN
-    // user disk (`scope === formatUserScope(principal)` — core's mint, byte-identical to memoryScopeFor's) or be
-    // an explicit operator (explicitOperatorOk, ops/migration face), or — design/170 件A §7 收编 — a
-    // DIRECTORY MEMBER of an `org:` key (the same org-memory directory instance core's admission seam reads,
-    // so one process holds ONE answer to "who belongs to org:acme"). Anything else = 404, NEVER 403 (zero
-    // existence oracle, run/trace owner-gate parity); a directory that cannot answer = 503, never 404.
-    // `userproj:*` stays operator-only by construction (the directory has no answer for that key shape).
-    // proj:* keys of repo-backed projects never live in this DB (铁律: git is their authority) — an owner
-    // asking for one just gets an empty set, honestly.
     if (url === "/v1/memory/export" && req.method === "GET") {
-        // Auth BEFORE availability (501-before-auth precedent): the backend posture must not oracle
-        // to a caller who couldn't read anything anyway.
-        const principal = gatedPrincipal(req, deps.config); // direct-door safe: verified identity, never the spoofable header
+        const principal = gatedPrincipal(req, deps.config);
         if (!principal) {
             sendError(res, 401, "auth.unauthorized", "unauthorized");
             return;
@@ -134,7 +77,7 @@ async function handleMemoryPolicyBody(req, res, url, ctx, miss) {
             sendError(res, 501, "capability.memory_store_required", "memory export requires a DB memory backend (MEMORY_ENGINE_BACKEND=pg|tidb)");
             return;
         }
-        const q = new URL(req.url ?? "", "http://x").searchParams; // route-level `url` is query-stripped
+        const q = new URL(req.url ?? "", "http://x").searchParams;
         const scope = q.get("scope");
         if (!scope) {
             sendError(res, 400, "request.query_invalid", "missing ?scope=<key>");
@@ -142,18 +85,12 @@ async function handleMemoryPolicyBody(req, res, url, ctx, miss) {
         }
         if (sendScopeGateRefusal(res, await gateMemoryScope(deps, principal, scope, "read")))
             return;
-        // 分页参数的验型排在**属主门之后**(与 roster 的「先门后参」同序):越界者恒 404,再坏的查询串
-        // 也不许把它换成 400 —— 那就是一格「这个 scope 存在」的信号。
         const limitRaw = q.get("limit");
         if (limitRaw !== null && !(/^[0-9]+$/.test(limitRaw) && Number(limitRaw) >= 1 && Number(limitRaw) <= MEMORY_EXPORT_MAX_LIMIT)) {
             sendError(res, 400, "request.query_invalid", `limit must be a decimal integer in 1..${MEMORY_EXPORT_MAX_LIMIT}`);
             return;
         }
         const beforeRaw = q.get("before");
-        // 🔴 `before` 必须与 `limit` 同行(codex 对抗复审 H2):否则「缺席 limit = 旧契约逐字不变」有两个
-        // 破口 —— 合法游标会让调用方拿到**过滤过的**子集却按全量读,坏游标会把旧行为的 200 全量变 400。
-        // 取**响亮拒**而不是「静默忽略 before」:后者让「分页时忘了带 limit」的调用方悄悄收到整盘,
-        // 正是本件要消灭的那个天花板。两个参数都不带的旧调用**一个字节都没碰到这条腿**。
         if (beforeRaw !== null && limitRaw === null) {
             sendError(res, 400, "request.query_invalid", "before requires an explicit limit — without one this endpoint returns the whole scope by contract");
             return;
@@ -165,26 +102,19 @@ async function handleMemoryPolicyBody(req, res, url, ctx, miss) {
         }
         try {
             const entries = await deps.memoryExport(scope);
-            // 🔴 缺席 limit = **旧契约逐字不变**:同一个数组、同一个顺序、响应键一个不多(sema-web 现行
-            // 消费零破坏)。分页面才排序/切片 —— 两条腿在真部署上给出同一个序(reader 是
-            // exportMemoryScope,两方言读面都 ORDER BY id),但冻结面不靠"碰巧相同",它就不动。
-            if (limitRaw === null) { // `before` 无 limit 已在上面 400 掉 ⇒ 这里等价于「两个分页参数都不在场」
+            if (limitRaw === null) {
                 sendJson(res, 200, { scope, exportedAt: new Date().toISOString(), entries });
                 return;
             }
-            // 声明序 = **id 升序**(entry 平面的既有确定序;id 是 PK ⇒ 唯一,单键游标无同值 tiebreak 洞)。
-            // 本面自己排,不继承 reader 的顺序:游标的正确性(无重无漏)是本面的承诺,不是上游的巧合。
             const sorted = [...entries].sort((a, b) => (a.id < b.id ? -1 : a.id > b.id ? 1 : 0));
             const after = decoded?.ok === true ? sorted.filter((e) => e.id > decoded.cursor.id) : sorted;
-            const page = after.slice(0, Number(limitRaw)); // limitRaw 在此必然在场且已验型(上面两道门)
+            const page = after.slice(0, Number(limitRaw));
             const last = page[page.length - 1];
             const hasMore = last !== undefined && after.length > page.length;
             sendJson(res, 200, {
                 scope,
                 exportedAt: new Date().toISOString(),
                 entries: page,
-                // `truncated` 与 `nextBefore` 同生同灭,但**两个都要有**:前者回答「这是全量吗」(缺席 limit
-                // 的旧契约给的就是全量,所以带 limit 时必须显式说不是),后者回答「从哪儿接着要」。
                 ...(hasMore ? { truncated: true, nextBefore: encodeExportCursor({ id: last.id }) } : {}),
             });
         }
@@ -194,14 +124,8 @@ async function handleMemoryPolicyBody(req, res, url, ctx, miss) {
         }
         return;
     }
-    // 142-S2.5 — POST /v1/memory/sync/:scope: the central-side sync face(设计 §2.5;裁定
-    // plan 随数据走——reconcile/nextSyncBaseline 是 core 纯函数,由持数据的本 server 在 performMemorySync
-    // (memory-sync.ts) 里直接调用;此处只持 HTTP 半场). Gate ORDER mirrors the export face verbatim:
-    // auth (401) → backend posture (501, file 形态诚实拒绝——单用户 file 面自己就是 TOC 侧,没有中心
-    // 权威半场可服务) → owner gate (404 zero-oracle: verified principal 的 user 盘逐字匹配 / explicit
-    // operator / `org:` 键的目录成员且条目 write:true;userproj: 仍 operator-only) → 验型 (422 typed)。
     if (req.method === "POST" && url.startsWith("/v1/memory/sync/")) {
-        const principal = gatedPrincipal(req, deps.config); // direct-door safe: verified identity, never the spoofable header
+        const principal = gatedPrincipal(req, deps.config);
         if (!principal) {
             sendError(res, 401, "auth.unauthorized", "unauthorized");
             return;
@@ -210,8 +134,6 @@ async function handleMemoryPolicyBody(req, res, url, ctx, miss) {
             sendError(res, 501, "capability.memory_store_required", "memory sync requires a DB memory backend (MEMORY_ENGINE_BACKEND=pg|tidb)");
             return;
         }
-        // :scope rides the path percent-encoded (scope keys carry `:`/`@`/`/`); route-level `url` is
-        // query-stripped but NOT decoded. A malformed escape is a client error, typed 400.
         let scope;
         try {
             scope = decodeURIComponent(url.slice("/v1/memory/sync/".length));
@@ -224,11 +146,9 @@ async function handleMemoryPolicyBody(req, res, url, ctx, miss) {
             sendError(res, 400, "memory_sync_invalid_scope", "missing :scope");
             return;
         }
-        // 写面:门与 export 面同一个 `gateMemoryScope`,只在 `need` 上分家 —— org 条目须 `write === true`
-        // 才放行(读授予不隐含写授予)。属主/operator 两级与读面逐字同判。
         if (sendScopeGateRefusal(res, await gateMemoryScope(deps, principal, scope, "write")))
             return;
-        const body = await readJson(req); // 413/400 (oversize / bad JSON) via the typed top-level catch — auth already done
+        const body = await readJson(req);
         const parsed = parseMemorySyncRequest(body, scope);
         if (!parsed.ok) {
             sendError(res, 422, "memory_sync_invalid_body", parsed.error);
@@ -239,22 +159,12 @@ async function handleMemoryPolicyBody(req, res, url, ctx, miss) {
             sendJson(res, 200, out);
         }
         catch (err) {
-            // applyPatches 可能已落库而 putCursor 失败——500 是诚实信号:客户端按同一 baseRevs 重放即
-            // 幂等自愈(identical revs 全程 no-op),绝不静默吞。
             deps.logger?.warn?.("memory_sync_failed", { scope, peer: parsed.value.peer, err: String(err) });
             sendError(res, 500, "internal.error", "memory sync failed");
         }
         return;
     }
-    // Effective server-enforced governance (CLI /permissions + /auto-mode). READ-only — a cloud
-    // supervisor shell CANNOT change server-side gating (the CLI's "permission modes" are tighten-only client
-    // cosmetics; the authoritative policy lives here, applied live in resolveSpec). Worker-global config (same for
-    // every principal), non-secret config surface like /v1/capabilities, so a principal is OPTIONAL (only enforced
-    // under REQUIRE_PRINCIPAL). Lets the client render the REAL autonomy band + command rules instead of fabricated ones.
     if (url === "/v1/policy" && req.method === "GET") {
-        // F-fix: gatedPrincipal (VERIFIED) for the presence gate — on a direct door the legit caller authenticates by
-        // JWT (no x-agent-principal header), so a `principalFrom` gate would 401 a valid reader. Worker-global config
-        // (no per-tenant leak either way); the correctness/consistency twin of the run-owner gates. (BFF/gated: same.)
         const principal = gatedPrincipal(req, deps.config);
         if (deps.config.requirePrincipal && !principal) {
             sendError(res, 401, "auth.principal_required", `missing principal header '${deps.config.principalHeader}'`);

package/dist/http/routes/notify-wake.js

@@ -1,33 +1,17 @@
 import { taskNotificationInboxEntry } from "../../orchestration/workflow-completion-inbox.js";
 import { sendJson, sendError } from "../send.js";
 import { gatedPrincipal, explicitOperatorOk } from "../principal-gate.js";
-/**
- * `POST /v1/sessions/:id/wake` 的路由形 —— **单源导出**,因为它有两个消费者:本模块的分发,
- * 和 `server.ts` 的 `isBillableSubmitPath`(wake 会烧模型,必须吃 drain / model-roster-pending /
- * 无 service-token 三道提交门)。
- *
- * 🔴 为什么提成常量:2026-07-31 的缝合审查出这两处**曾经不同步** —— 匹配形写死在本文件里,
- * 名单在 server.ts 里,wake 从来没进过名单,于是同一条 `driveResumeIntoRunLog` 模型腿
- * 从 `/v1/assistant/tasks/:id/resume` 进来受三道门管、从 wake 进来一道都不受。
- * 共用一个常量之后,再想漏就得两处一起改。
- */
 export const SESSION_WAKE_RE = /^\/v1\/sessions\/[^/]+\/wake$/;
 export async function handleNotifyWake(req, res, url, ctx) {
     const miss = { fell: false };
     await handleNotifyWakeBody(req, res, url, ctx, miss);
     return !miss.fell;
 }
-/** 路由体 = 从 `server.ts` 的 `handle()` 里**整段剪切**过来的原文(唯一改动:统一去缩进两格)。裸 `return;`
- *  = 「本域已应答」;走到函数尾才是「没匹配上」。跨域的东西一律在首行解构出来。 */
 async function handleNotifyWakeBody(req, res, url, ctx, miss) {
     const { deps } = ctx;
     const { steerableRuns } = ctx.registry;
     const { readJson, rateLimited, quotaExceeded, leaseDenied } = ctx.helpers;
     const { resumeWake } = ctx.legs;
-    // design/144 §2 server 半场(external-notification-bridge 的 HTTP 入站门):把「会话外事件」
-    // (daemon job 终态等)注入目标 session。live(本副本活流)→ core `TaskStream.notify()`(task_type=
-    // "external" core 铸造,sanitize/围栏/三态投递全在 core);idle → inbox park(external 独立键域,
-    // [769]① 防预占)→ 下次开流 drain。帧契约=[446] bg_notification 同族。入站鉴权在此(core 只管注入段)。
     if (req.method === "POST" && /^\/v1\/sessions\/[^/]+\/notify$/.test(url)) {
         if (rateLimited(req, res) || quotaExceeded(req, res))
             return;
@@ -49,8 +33,6 @@ async function handleNotifyWakeBody(req, res, url, ctx, miss) {
             sendError(res, 400, "request.field_invalid", "task_id must be a non-empty string of at most 190 characters");
             return;
         }
-        // [5028]/A-002.1 同纪律双向锚:satisfies 保「表内无词表外的词」(core 删/改词 ⇒ 编译红),
-        // 穷举断言保「词表无表外的词」(core 加词 ⇒ 编译红)——单靠 satisfies 只有前半,加词会静默 400 拒合法值。
         const NOTIFY_STATUSES = ["completed", "failed", "killed", "cancelled", "event"];
         const _notifyExhaustive = true;
         void _notifyExhaustive;
@@ -74,13 +56,11 @@ async function handleNotifyWakeBody(req, res, url, ctx, miss) {
             sendError(res, 400, "request.field_invalid", "source must be a string of at most 190 characters when present");
             return;
         }
-        // 入站 owner 门(fail-closed,exemptions 路由同款):未知 session 404;他人 session 404 无 oracle;
-        // store 错误 500 传播绝不放行;无 ownerOf 面(env-only)=501 诚实(入站门没有地基就不开门)。
         if (!deps.sessionStorage?.ownerOf) {
             sendError(res, 501, "capability.session_ownership_required", "external notify requires the session-ownership face (sessionStorage.ownerOf)");
             return;
         }
-        const notifyOwner = await deps.sessionStorage.ownerOf(notifySession); // throws → outer 500(fail-closed)
+        const notifyOwner = await deps.sessionStorage.ownerOf(notifySession);
         if (notifyOwner === undefined) {
             sendError(res, 404, "not_found.session", "session not found");
             return;
@@ -98,7 +78,6 @@ async function handleNotifyWakeBody(req, res, url, ctx, miss) {
             ...(nb.seq !== undefined ? { seq: nb.seq } : {}),
             ...(nb.source !== undefined ? { source: nb.source } : {}),
         };
-        // live 半场:目标 session 的活流在本副本 → core notify verb(task_type="external" core 铸,不可伪装内部帧)。
         const liveTaskId = await deps.runStore?.getActiveTaskId?.(notifySession).catch(() => undefined);
         const liveStream = liveTaskId !== undefined && liveTaskId !== null ? steerableRuns.get(liveTaskId) : undefined;
         if (liveStream) {
@@ -108,17 +87,13 @@ async function handleNotifyWakeBody(req, res, url, ctx, miss) {
                 return;
             }
             catch (e) {
-                // 只有「流已结束」竞态才回落 park;core 的明确拒绝(notify.invalid_payload 等)原样 4xx——
-                // 把合同拒绝误 park = 无效通知洗成 202(fail-closed 谱系,复审 finding)。
                 const code = e.code;
                 if (typeof code === "string" && code.startsWith("notify.")) {
                     sendError(res, 400, code, e instanceof Error ? e.message : "invalid notification");
                     return;
                 }
-                /* 其余=活流刚结束竞态 → durable park(与 steer 的 live→suspended 同姿势) */
             }
         }
-        // idle 半场:park 进 inbox(external 键域;redact/cap 在 taskNotificationInboxEntry 内)→ 下次开流 drain。
         if (!deps.workflowCompletionInbox) {
             sendError(res, 501, "capability.workflow_store_required", "external notify park requires the workflow completion inbox (WORKFLOW_RUN_STORE)");
             return;
@@ -128,16 +103,13 @@ async function handleNotifyWakeBody(req, res, url, ctx, miss) {
         return;
     }
     if (req.method === "POST" && SESSION_WAKE_RE.test(url)) {
-        // design/144 §3(core 1.283 wake arm):对 task_done 纯 park 的「消息唤醒」。非门决策——不 allow/deny
-        // 任何 pending 动作,只解除 park 并把消息(或已 park 的 pendingSteer)作为续跑首轮输入。有未决门 =
-        // core `wake.gate_pending` 拒(永不绕审批);空 park + 无 message = `wake.nothing_to_deliver` 拒。
         if (!deps.checkpointStore) {
             sendError(res, 501, "capability.checkpoint_store_required", "wake requires the checkpoint store");
             return;
         }
         if (rateLimited(req, res) || quotaExceeded(req, res) || (await leaseDenied(req, res)))
-            return; // 续跑=烧模型
-        const principal = gatedPrincipal(req, deps.config); // direct-door-secure(trusted 承载 operator 权威)
+            return;
+        const principal = gatedPrincipal(req, deps.config);
         if (deps.config.requirePrincipal && principal === undefined) {
             sendError(res, 401, "auth.principal_required", `missing principal header '${deps.config.principalHeader}'`);
             return;
@@ -155,12 +127,6 @@ async function handleNotifyWakeBody(req, res, url, ctx, miss) {
             sendError(res, 400, "request.field_invalid", "message must be a non-empty string when present");
             return;
         }
-        // 🕐 **#316 同族登记(本批不改行为)**:wake 与 legacy `/decide` 走同一条 `driveResumeIntoRunLog`
-        // 模型腿 —— 响应之前同步跑完整条续跑,时长 = 模型往返、无服务端上限([4664]① 定谳的同族三腿之一)。
-        // 本批只把 legacy decide 改成 200 受理形(那是 [4660] 雪崩实测首环);本腿是 wire BREAKING,按能力
-        // 显式表态制([3780] 裁 A)候消费方认领后同形改造 —— 改法 = `resumeWake` 透传 `acceptEarly: true`。
-        // ⚠️ 本腿多一条判据要一起想:它走 `mintFreshRun`(铸新 run 行),受理体里的 `taskId` 因此是**新铸的**
-        // 那个 id —— 改造时受理形必须带上它,否则壳没有可 poll 的锚。
         const out = await resumeWake(wakeSession, wakeBody.message, principal, req);
         sendJson(res, out.status, out.body);
         return;

package/dist/http/routes/observability.js

@@ -5,23 +5,8 @@ export async function handleObservability(req, res, url, ctx) {
     await handleObservabilityBody(req, res, url, ctx, miss);
     return !miss.fell;
 }
-/** 路由体 = 从 `server.ts` 的 `handle()` 里**整段剪切**过来的原文(唯一改动:统一去缩进两格)。裸 `return;`
- *  的语义原样 =「本域已应答」;走到函数尾才是「没匹配上」,置 `miss.fell` 交回装配器继续下一个域。
- *  跨域的东西(deps / 助手 / 单域状态)一律在首行解构出来,于是下面每一行都逐字不变。 */
 async function handleObservabilityBody(req, res, url, ctx, miss) {
     const { deps } = ctx;
-    // Per-principal cumulative cost usage (CLI /cost + /usage + status usage tab). The READ twin of
-    // the cost-quota GATE (quotaExceeded): `check` is read-only (does NOT consume). Principal-scoped — a caller
-    // only ever sees its OWN spend (keyed exactly like the gate). When no cumulative quota is configured
-    // (deps.costQuota absent) → enabled:false (NOT an error) so the CLI shows "no cumulative quota; per-task cap
-    // = $X" instead of failing. ⚠️ in-memory CostQuota is per-replica (undercounts across replicas) — the TiDB
-    // twin (deps.costQuota = TiDBCostQuota) is the cross-replica-accurate backend; both satisfy `.check()`.
-    // P2 (design/73 §7.2 dashboard floor): READ-ONLY per-(taskSignature, model) outcome aggregate — pass-rate
-    // + mean cost over the graded ledger rows (the (b)-emitter data: make-real/TB harness runs + any future
-    // goal面). 🔒 Multi-tenant: operator-only — rows are NOT owner-keyed (mechanical facts keyed by signature
-    // ×model), so any-tenant access would leak cross-tenant task/perf shape; single-user turnkey is open (the
-    // sole user IS the operator). ?signature= filters to one aggregation key; ?includeAborted=true adds the
-    // infra-aborted rows (infra-health view — NEVER the training view, council blocker 3).
     if (url === "/v1/outcomes" && req.method === "GET") {
         if (deps.config.requirePrincipal) {
             const principal = gatedPrincipal(req, deps.config);
@@ -34,7 +19,7 @@ async function handleObservabilityBody(req, res, url, ctx, miss) {
             sendError(res, 501, "capability.outcome_ledger_required", "no queryable outcome ledger on this worker (File sink — read the JSONL dataset directly)");
             return;
         }
-        const q = new URL(req.url ?? "/", "http://localhost").searchParams; // `url` is query-stripped upstream
+        const q = new URL(req.url ?? "/", "http://localhost").searchParams;
         const sig = q.get("signature") ?? undefined;
         try {
             const rows = await deps.outcomeSink.summary({ ...(sig ? { taskSignature: sig } : {}), includeAborted: q.get("includeAborted") === "true" });
@@ -46,10 +31,8 @@ async function handleObservabilityBody(req, res, url, ctx, miss) {
         }
         return;
     }
-    // (用量统计查询面 /v1/usage/{summary,series,breakdown} 从这里上移到全局 service-credential 门之前——
-    //  usage 门自身认 traceToken,但挂在全局门之后时 traceToken-only 调用在全局门就 401=死代码。)
     if (url === "/v1/usage" && req.method === "GET") {
-        const principal = gatedPrincipal(req, deps.config); // direct-door safe: crypto-verified principal, never the spoofable header
+        const principal = gatedPrincipal(req, deps.config);
         if (!principal) {
             sendError(res, 401, "auth.principal_required", `missing principal header '${deps.config.principalHeader}'`);
             return;