@sema-agent/server 7.43.0 → 7.44.0

package/dist/http/routes/retention-ops.js

@@ -1,24 +1,11 @@
 import { sendJson, sendError } from "../send.js";
 import { gatedPrincipal, explicitOperatorOk } from "../principal-gate.js";
 import { RETENTION_AUDIT_DEFAULT_LIMIT, RETENTION_AUDIT_MAX_LIMIT } from "../../plugins/retention-lane-store-sql.js";
-/** hold 路径。**`*` 不是 `+`**:空段 = 无主桶(见文件头「域的两个边界」)。 */
 const HOLD_RE = /^\/v1\/ops\/retention\/holds\/([^/]*)$/;
 const AUDIT_PATH = "/v1/ops/retention/audit";
-/** `retention_hold.domain` / `retention_audit.domain` 的列宽(车1 的 DDL:`VARCHAR(190)`)。 */
 const DOMAIN_MAX_CHARS = 190;
-/** hold 备注的上界。`note` 列是 TEXT(不会截断),但一个无界的 operator 输入不该原样进一张**追加式**
- *  的治理表 —— 4000 字符足够写清案号与出处,再长的属于工单系统。 */
 const NOTE_MAX_CHARS = 4000;
-/** operator 面的**唯一**授权文案(三条路由同受众、同理由 ⇒ 同一句;分成三句只会让 freeze 表长三倍
- *  而消费端读到的判据一模一样)。 */
 const OPERATOR_ONLY_MESSAGE = "managed-retention governance is an operator-only deployment action";
-/**
- * 审计游标 = `{id}` 的不透明 base64url。
- *
- * 🔴 排序键是**自增 `id` 单列**,不是 roster 那样的二元组:`id` 本身全序且唯一,二元组存在的全部理由
- * (同毫秒兄弟行无 tiebreak ⇒ 漏页/重页)在这张表上结构性不存在。游标形仍照 roster 逐字同姿势
- * (base64url JSON / 判别式解码 / 400 带**类名** detail)—— 消费端跨端点的游标处理代码因此同形。
- */
 function encodeCursor(c) {
     return Buffer.from(JSON.stringify(c)).toString("base64url");
 }
@@ -28,8 +15,6 @@ function decodeCursor(raw) {
         parsed = JSON.parse(Buffer.from(raw, "base64url").toString());
     }
     catch (err) {
-        // 只带错误的**类名**,不回显 payload 片段(与 agents-roster 的同款纪律:被误粘进查询串的凭据
-        // 不该经由错误文案再走一圈)。
         return { ok: false, why: `not decodable base64url JSON (${err instanceof Error ? err.name : "unknown error"})` };
     }
     if (typeof parsed !== "object" || parsed === null)
@@ -53,8 +38,7 @@ async function handleRetentionBody(req, res, url, ctx, miss) {
         miss.fell = true;
         return;
     }
-    // 门序 = operator 面的既有口径(routes/adoption.ts 逐字):身份 → 授权 → 能力 → 验型。
-    const principal = gatedPrincipal(req, deps.config); // 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;
@@ -65,8 +49,6 @@ async function handleRetentionBody(req, res, url, ctx, miss) {
     }
     const store = deps.backend?.retentionLane?.();
     if (!store) {
-        // ⚠️ 文案里用**单引号**写 `retention:'none'`:文案冻结门的字面提取器不认带反斜杠转义的双引号串
-        //    (`"([^"\n\\]*)"`),一个 `\"` 会让这条站点对那道门隐形 —— 那不是"过了门",是绕过门。
         sendError(res, 501, "capability.retention_store_required", "managed retention requires a SQL store backend (DB_BACKEND=mysql|pg) — the local/file backend declares retention:'none' and holds nothing to govern");
         return;
     }
@@ -76,12 +58,9 @@ async function handleRetentionBody(req, res, url, ctx, miss) {
     }
     await handleAuditRead(req, res, store);
 }
-/** 放置(PUT)/ 解除(DELETE)—— 两支共用一条 upsert(见文件头的唯一纪律)。 */
 async function handleHold(req, res, ctx, store, rawDomain, principal) {
     const domain = ctx.helpers.safeDecode(rawDomain);
     if (domain === null) {
-        // 复用既有的 `request.id_invalid`(sessions/attachments/adoption 同族),不为一条新路由铸第二个
-        // 同义码 —— 附录 A 判据②:只有消费端真会分支时才铸新码。
         sendError(res, 400, "request.id_invalid", "invalid retention domain segment");
         return;
     }
@@ -94,7 +73,6 @@ async function handleHold(req, res, ctx, store, rawDomain, principal) {
     const held = req.method === "PUT";
     let note;
     if (held) {
-        // 体是**可选**的(`PUT …/holds/acme` 不带体是合法的最小放置)。空体走 `{}`。
         let raw;
         try {
             raw = await ctx.helpers.readJson(req);
@@ -115,7 +93,6 @@ async function handleHold(req, res, ctx, store, rawDomain, principal) {
                     return;
                 }
                 if (n.length > NOTE_MAX_CHARS) {
-                    // 铸行之前拒:静默截断会把一条**被改写过的**审计事实写进一张追加式的表。
                     sendError(res, 400, "request.field_invalid", "the retention hold note is longer than this face accepts", {
                         detail: `note is ${n.length} characters; the limit is ${NOTE_MAX_CHARS}`,
                     });
@@ -126,12 +103,7 @@ async function handleHold(req, res, ctx, store, rawDomain, principal) {
         }
     }
     const nowMs = Date.now();
-    const placedBy = principal ?? "operator"; // 单用户 turnkey 部署没有 principal 这个概念(见 explicitOperatorOk)
-    // 🔴 状态变更与治理审计行走**同一个事务**(codex 对抗复审 R1-[high],验真后修)。两次独立提交下,
-    // 第二步失败会留下一次**无审计的状态变更** —— DELETE 那一支尤其重:冻结已解除、sweep 从下一拍起就能
-    // 删这个域的数据,而账上没有任何 `hold_released` 行说明是谁在什么时候解的。
-    // `mode`/`policyDays` 记的是**这一刻的部署事实**:一条 hold 行不带策略档,事后没人说得清"当时是在
-    // 什么留存策略下冻结的"。`fencingToken` 诚实留空 —— 它只属于 sweep 轮次,operator 动作不在任何一轮里。
+    const placedBy = principal ?? "operator";
     await store.setHoldAudited({
         domain,
         held,
@@ -151,7 +123,6 @@ async function handleHold(req, res, ctx, store, rawDomain, principal) {
     });
     sendJson(res, 200, held ? { domain, held: true, placedBy, placedAtMs: nowMs } : { domain, held: false });
 }
-/** 审计读面(keyset 分页;窗与游标语义见文件头)。 */
 async function handleAuditRead(req, res, store) {
     const q = new URL(req.url ?? "", "http://x").searchParams;
     const limitRaw = q.get("limit");
@@ -163,8 +134,6 @@ async function handleAuditRead(req, res, store) {
     const beforeRaw = q.get("before");
     const decoded = beforeRaw === null ? undefined : decodeCursor(beforeRaw);
     if (decoded !== undefined && !decoded.ok) {
-        // 文案冻结在 wire 上(api-error-text-freeze 的一行);`detail` 是 additive 的**为什么**,
-        // 供调用方自诊(它描述的是调用方自己传进来的串,零跨租户信息)。
         sendError(res, 400, "request.query_invalid", "before must be the opaque `nextBefore` cursor from a previous page of this endpoint", { detail: decoded.why });
         return;
     }
@@ -173,7 +142,6 @@ async function handleAuditRead(req, res, store) {
         sendError(res, 400, "request.query_invalid", `domain must be at most ${DOMAIN_MAX_CHARS} characters`);
         return;
     }
-    // 多取一行用来判「还有没有下一页」——不进结果。`hasMore` 因此是**事实**而不是"limit 满了就猜有"。
     const scanned = await store.listAudit({
         ...(domainRaw !== null ? { domain: domainRaw } : {}),
         limit: Math.min(limit + 1, RETENTION_AUDIT_MAX_LIMIT + 1),

package/dist/http/routes/rules.js

@@ -2,25 +2,15 @@ import { z } from "zod";
 import { sendJson, sendError } from "../send.js";
 import { gatedPrincipal, explicitOperatorOk } from "../principal-gate.js";
 import { createLogger } from "../../observability/logger.js";
-// 等待秒数的单一真源在车道:它同时被「放回认领时判这张票还撑不撑得过这段窗」用到(见那侧头注)。
-// scope 的 wire 形也在车道(列举列 / 查询参数 / 删除体 / 游标四处同一份表示,见那侧头注)。
 import { RULE_IMPORT_RETRY_AFTER_SEC, MAX_RULE_SCOPE_CHARS, parseRuleScope, serializeRuleScope } from "../../rules-consent.js";
 const logger = createLogger();
 export const RULES_CC_IMPORT_PREPARE_PATH = "/v1/rules/cc-import/prepare";
 export const RULES_CC_IMPORT_REDEEM_PATH = "/v1/rules/cc-import/redeem";
-/** 撤销面两口共用的字面路径(GET 列举 / DELETE 撤销)。 */
 export const RULES_PATH = "/v1/rules";
-/** 一页的上下限。50 = 一屏治理列表;200 = 一次响应的上界(一条规则行带 `adds[]`,不是一个标量)。
- *  与 `GET /v1/sessions` 的 keyset 姿势同族(sessions-list.ts:137 的 `Math.min(100, …)`),数值按本面
- *  的行宽另定 —— 抄一个数比抄一条理由更容易漂。 */
 const RULES_PAGE_DEFAULT = 50;
 const RULES_PAGE_MAX = 200;
-/** 一层 settings 的上限。一份 CC settings 是人手写的 JSON,不是数据集;16 KiB 宽到装得下几百条 allow,
- *  窄到一次请求不能拿它当上传通道。层数同理(core v1 只读三层,给 3 就够,多给等于给一个放大面)。 */
 const MAX_LAYER_CONTENT_CHARS = 16_384;
 const MAX_LAYERS = 3;
-/** 🔴 边界必 schema(宪法 [2704])。`.strict()`:多给一个键 = 400,不是静默忽略 —— 一个把 `content`
- *  拼错成 `contents` 的客户端应该当场知道,而不是拿到一份「零候选」的预览去纳闷。 */
 const CcImportPrepareBodySchema = z
     .object({
     layers: z
@@ -28,12 +18,6 @@ const CcImportPrepareBodySchema = z
         .object({
         layer: z.enum(["userSettings", "projectSettings", "localSettings"]),
         path: z.string().min(1).max(1024),
-        /** 项目层规则的作用域根。**用户自己的**目录标签(它只影响这条规则将来在哪些 cwd 下生效),
-         *  故不做**真实性**校验——server 上没有那棵树可对照,假装校验过才是谎。
-         *  🔴 但**非空**是硬的(codex 交叉复审 round5 [high] 一,验真后修):`root: ""` 会被 core 直接
-         *  变成 `{kind:"project", root:""}`,而空前缀在 `pathWithinRoot` 下**包含每一个 cwd** —— 一条
-         *  项目内规则就此悄悄升成全局规则;更糟的是本仓的读面对空 root 是整桶拒,于是一次「成功」的
-         *  导入会让这位租户**之后每一次**规则读写都失败。 */
         root: z.string().min(1).max(1024),
         content: z.string().max(MAX_LAYER_CONTENT_CHARS),
     })
@@ -43,13 +27,6 @@ const CcImportPrepareBodySchema = z
 })
     .strict();
 const CcImportRedeemBodySchema = z.object({ ticket: z.string().min(1).max(190) }).strict();
-/** `DELETE /v1/rules` 的体。`.strict()` 同族理由:把 `scope` 拼错成 `scopes` 的客户端应该当场知道,
- *  而不是拿到一个「删掉了 global 那条」的意外结果。`principal` = operator 越权域(缺席 = 删自己的)。
- *  长度上限与 principal 入口上限同源(`PRINCIPAL_MAX_LENGTH = 190`,security.ts);`rule` 的 1024 覆盖
- *  core 的 `MAX_RULE_TEXT_CHARS`(512,铸侧真上界)且留足余量。
- *  🔴 `scope` 的上限**不再是本文件自己挑的数**(A-054.24):改由铸侧的尺派生 —— 见
- *  {@link MAX_RULE_SCOPE_CHARS} 顶注(此前独立写死 1088,而铸侧能落到 4096+,于是超限 root 的规则
- *  「列得出、删不掉」)。撤销口的收窄若严于铸侧,等于造一条**不可撤的常驻放行规则**,方向是错的一侧。 */
 const RuleRevokeBodySchema = z
     .object({
     rule: z.string().min(1).max(1024),
@@ -63,13 +40,6 @@ const RulesCursorSchema = z
 function encodeRulesCursor(c) {
     return Buffer.from(JSON.stringify(c)).toString("base64url");
 }
-/**
- * 读不出形 ⇒ `{ok:false, why}`,由调用方拒(400)。两条纪律:
- *  · **刻意不**「读不出就当第一页」(sessions-list 的旧姿势):那条腿的游标只影响顺序,这条腿的游标
- *    一旦被静默丢弃,客户端会以为自己列完了整份清单。
- *  · 失败**带着原因出来**而不是塌成一个 `undefined`:调用点把 `why` 写进服务端日志。一个只回默认值的
- *    catch 是本仓在册的静默降级形(#191 门② SHAPE C)——这里不需要那种便利,原因本来就有用。
- */
 function decodeRulesCursor(raw) {
     try {
         const parsed = RulesCursorSchema.safeParse(JSON.parse(Buffer.from(raw, "base64url").toString()));
@@ -79,10 +49,6 @@ function decodeRulesCursor(raw) {
         return { ok: false, why: err instanceof Error ? err.message : String(err) };
     }
 }
-/** 排序键 —— 与 `RuleConsentLane.listRules` 的 (scope, rule) 二元排序**等价**(两处若各写一份必然漂,
- *  而漂的表现是分页静默漏行)。分隔符必须**小于**任何可能出现的字符,否则串比较与元组比较会在
- *  「一个 scope 是另一个的前缀」处分岔(`project:/a` vs `project:/ab`)。用空格是错的 ——
- *  `Bash(echo hi)` 里就有一个;\u0000 是码点最小的字符,而且规则文本与路径里都不可能出现它。 */
 const rowKey = (r) => `${r.scope}\u0000${r.rule}`;
 export async function handleRules(req, res, url, ctx) {
     const miss = { fell: false };
@@ -94,22 +60,14 @@ async function handleRulesBody(req, res, url, ctx, miss) {
     const { readJson, rateLimited } = ctx.helpers;
     const isPrepare = req.method === "POST" && url === RULES_CC_IMPORT_PREPARE_PATH;
     const isRedeem = req.method === "POST" && url === RULES_CC_IMPORT_REDEEM_PATH;
-    // 🔴 判路写**字面量**而不是引 `RULES_PATH`(与 server.ts 的 `ROUTE_LABEL_LITERALS` 那条注同族理由):
-    // 路由名册门与文案接线门的枚举器扫的是 `url === "…"` 的**源码文本**,引常量会让这两口对两道门隐形
-    // ——那不是「过了门」,是绕过门。常量仍导出给测试/SDK 侧当单一真源用。
     const isList = req.method === "GET" && url === "/v1/rules";
     const isRevoke = req.method === "DELETE" && url === "/v1/rules";
     if (!isPrepare && !isRedeem && !isList && !isRevoke) {
         miss.fell = true;
         return;
     }
-    // 🔴 `prepare` 每次调用**都会**落一条 pending 审批记录 + 一张票 —— 它是本域唯一一条「一次请求 = 一行」
-    // 的写面,没有限流就是一条行洪口。与 `POST /v1/tasks/:id/asks/:askId/decision` 同姿势(限流在最前)。
-    // 撤销面两口同罩:`DELETE` 是写(每次铸一个 dot + 一条墓碑),`GET` 是整桶读 —— 两者都不该无限打。
     if (rateLimited(req, res))
         return;
-    // 鉴权**先于**可用性(501-before-auth 先例的反面同理):这四口没有可被探测的部署事实,但
-    // principal 是本域的全部授权基础,先立住它再谈别的。
     const principal = gatedPrincipal(req, deps.config);
     if (principal === undefined) {
         sendError(res, 401, "auth.unauthorized", "unauthorized");
@@ -120,8 +78,6 @@ async function handleRulesBody(req, res, url, ctx, miss) {
         sendError(res, 501, "capability.rule_store_required", "this deployment has no permission-rule store wired");
         return;
     }
-    // ── 撤销面两口(#203 §2)──────────────────────────────────────────────────────────────────────
-    // 放在读体之前:`GET` 没有体,`readJson` 对它是一次白等。
     if (isList) {
         await handleRuleList(req, res, principal, lane, deps.config.operatorPrincipals);
         return;
@@ -146,9 +102,6 @@ async function handleRulesBody(req, res, url, ctx, miss) {
         }
         const prepared = await lane.prepareImport(principal, parsed.data.layers);
         if (!prepared.ok) {
-            // 413(不是 400):族语义就是「体/条目超上限」,与附件/图片同码同状态(附录 A 已成文)。
-            // 帽的位置与理由(为什么单层字节帽不够、为什么帽在**铸票之前**)见 `rules-consent.ts` 的
-            // `MAX_IMPORT_CANDIDATES`。
             sendError(res, 413, "request.payload_too_large", "too many allow entries across the submitted settings layers");
             return;
         }
@@ -163,31 +116,16 @@ async function handleRulesBody(req, res, url, ctx, miss) {
     const redeemed = await lane.redeemImport(principal, parsed.data.ticket);
     if (!redeemed.ok) {
         logger.info("rule import ticket refused", { reason: redeemed.reason, detail: redeemed.detail, retryable: redeemed.retryable === true });
-        // 🔴 codex 交叉复审 round2 [medium](验真后修):**可重试**那一支不能折进 404。
-        // 为什么这不破坏零存在性 oracle:走到这一支的调用方**已经赢下了一次 principal 绑定的认领** ——
-        // 也就是说他已经证明了这张票是他自己的、没过期、没用过。对他说「稍后再试」泄不出任何**别人**的
-        // 存在性(伪造 / 别人的 / 过期 / 已用过 四类仍然同形 404,一个字都没变)。反过来把它折成 404 才是
-        // 真损失:round1 修好的「认领已放回、这张票还能用」在 wire 上被抹掉,客户端按常规 404 处置一丢了之。
         if (redeemed.retryable === true) {
-            res.setHeader("retry-after", String(RULE_IMPORT_RETRY_AFTER_SEC)); // 体里有等待提示 ⇒ 标准头同值(同 503 族先例)
+            res.setHeader("retry-after", String(RULE_IMPORT_RETRY_AFTER_SEC));
             sendError(res, 503, "state.rule_import_retry", "the rule import could not be completed right now; the ticket is still usable — retry", { retryAfterSec: RULE_IMPORT_RETRY_AFTER_SEC });
             return;
         }
-        // 同形 404(顶注):四类成因**不上 wire**,只进服务端日志。
         sendError(res, 404, "not_found.rule_ticket", "no such import ticket");
         return;
     }
     sendJson(res, 200, { result: redeemed.result });
 }
-/**
- * 解析**目标 principal**(自有域 vs operator 越权域)。
- *
- * 🔴 判据链是硬的:①没给 = 自己(最常见的路,零授权提问);②给了但等于自己 = 还是自己(一个把
- * principal 显式写出来的客户端不该因此被要求当 operator);③给了别人 = **必须** `explicitOperatorOk`。
- * 第三条用的是 `explicitOperatorOk` 而不是 `isOperator`:后者在 `OPERATOR_PRINCIPALS` 为空时「人人
- * 都是 operator」,那在跨租户读规则这条轴上是一道世界可写的门(principal-gate.ts 的头注逐字)。
- * **绝不**从 service token 推断:一个共享的部署凭证不是一个人,而这条口的授权对象是人。
- */
 function resolveTargetPrincipal(requested, caller, operatorPrincipals) {
     if (requested === undefined || requested === caller)
         return { ok: true, principal: caller };
@@ -195,19 +133,14 @@ function resolveTargetPrincipal(requested, caller, operatorPrincipals) {
         return { ok: false };
     return { ok: true, principal: requested };
 }
-/** `GET /v1/rules` —— 列出一位 principal 名下**活着**的规则。 */
 async function handleRuleList(req, res, caller, lane, operatorPrincipals) {
-    // `url` 在派发前已被剥掉 query,查询参数只能从 `req.url` 重新取(与 `/v1/outcomes` 同姿势)。
     const q = new URL(req.url ?? "/", "http://localhost").searchParams;
     const target = resolveTargetPrincipal(q.get("principal") ?? undefined, caller, operatorPrincipals);
     if (!target.ok) {
         sendError(res, 403, "auth.operator_only", "reading another principal's rules is an operator-only action");
         return;
     }
-    // limit:非数/越界一律夹取(与 sessions-list 同姿势——一个分页参数写错不该让治理面整个打不开)。
     const limit = Math.min(RULES_PAGE_MAX, Math.max(1, Number(q.get("limit") ?? RULES_PAGE_DEFAULT) || RULES_PAGE_DEFAULT));
-    // scope 过滤:**给了就必须读得出形**。读不出不当「没过滤」——那会把一次「只看这个项目」的请求
-    // 悄悄变成一次全量列举,而客户端会照单全收当成该项目的清单。
     const scopeRaw = q.get("scope");
     const scopeFilter = scopeRaw === null ? undefined : parseRuleScope(scopeRaw);
     if (scopeRaw !== null && scopeFilter === undefined) {
@@ -222,15 +155,9 @@ async function handleRuleList(req, res, caller, lane, operatorPrincipals) {
         return;
     }
     const cursor = decoded?.ok === true ? decoded.cursor : undefined;
-    // 过滤键用**规范形**(`serializeRuleScope` 的产物),不是客户端交上来的原串:行上的 scope 是规范的,
-    // 拿一个等价但拼法不同的原串去比会静默过滤成空表。空串 = 未过滤(游标里也用这一个表示)。
     const filterKey = scopeFilter === undefined ? "" : serializeRuleScope(scopeFilter);
     const listing = await lane.listRules(target.principal);
     if (cursor !== undefined && (cursor.rev !== listing.rev || cursor.principal !== target.principal || cursor.scope !== filterKey)) {
-        // 游标绑 (rev, principal, scope)(见 {@link RulesCursor} 头注)。**拒**而不是从头给:静默重置会让
-        // 客户端把第二页当成「接着上一页」,治理面上于是出现一份既漏行又重行的清单,而没有任何人知道。
-        // 三项合并成一句文案是刻意的:对客户端来说处置完全相同(丢掉游标从头列),而把「你换了 principal」
-        // 单独成句会让一个 operator 从别人桶的 rev 上读出信息。
         sendError(res, 400, "request.query_invalid", "the rules cursor was minted at a different revision — restart the listing", { rev: listing.rev });
         return;
     }
@@ -242,7 +169,6 @@ async function handleRuleList(req, res, caller, lane, operatorPrincipals) {
         : undefined;
     sendJson(res, 200, { rules: page, rev: listing.rev, ...(nextCursor !== undefined ? { nextCursor } : {}) });
 }
-/** `DELETE /v1/rules` —— 按内容(rule, scope)撤销。 */
 async function handleRuleRevoke(res, rawBody, caller, lane, operatorPrincipals) {
     const parsed = RuleRevokeBodySchema.safeParse(rawBody);
     if (!parsed.success) {
@@ -256,38 +182,20 @@ async function handleRuleRevoke(res, rawBody, caller, lane, operatorPrincipals)
     }
     const target = resolveTargetPrincipal(parsed.data.principal, caller, operatorPrincipals);
     if (!target.ok) {
-        // 与读那一半**同码同姿势**:方向(收紧)决定了这条越权域存在,身份判据不因方向而放松。
         sendError(res, 403, "auth.operator_only", "revoking another principal's rules is an operator-only action");
         return;
     }
     const outcome = await lane.removeRule({ principal: target.principal, rule: parsed.data.rule, scope });
     switch (outcome.status) {
         case "removed":
-            // 🔴 `stillLive` **必须上 wire**(design/203 v2 §6 F3)。它为真的意思是「墓碑落了,但这次调用
-            // 期间又落了一次新的批准,规则按 add-wins 仍然活着」——把它折进 200 不说,客户端会把一次
-            // **没有完成**的撤销读成完成,而那正是治理面最不能出错的地方。
             sendJson(res, 200, { status: "removed", rev: outcome.rev, stillLive: outcome.stillLive });
             return;
         case "no-op": {
-            // 幂等:重复删 / 本来就没有,一律 200 `no-op`。**不是 404** —— 一个「这条规则存在过吗」的
-            // 404 就是一台存在性 oracle(operator 越权域下更是跨租户的那种),而删除对「有没有过」
-            // 本来就不该作 oracle。客户端要判「我删到东西了吗」,读 `status` 即可。
-            //
-            // 🔴 `stillLive` 这一支**也要有**(codex 对抗复审 R1-F2,验真后修)。core 的原语在初始快照里
-            // 找不到匹配 dot 时**立刻**回 no-op —— 它不做 removed 那支的读回。于是「快照之后、应答之前落了
-            // 一次批准」的窗口里,规则**是活的**而端点说 no-op,客户端合理地读成「已经没有这条规则了」。
-            // 那与 F3 修好的 removed+stillLive 是**同一个**危害,只是走了另一支。
-            // 处置 = server 自己补一次读回,把**观察到的**事实如实上 wire;两支 200 的键集因此同形,消费端
-            // 一套分支读得通。读回失败不改判(no-op 本身是 core 裁定的)⇒ 保守报 `stillLive:false`?**不**:
-            // 那是编一个结论。读不出来就让它抛,由本域的全局错误臂报 500 —— 一个说不清结果的撤销不该回 200。
-            // 让 core 的原语自己报这一位是更根治的形,已作为上游请托登记(server 不改上游语义,[2862])。
             const stillLive = (await lane.listRules(target.principal)).rows.some((r) => r.rule === parsed.data.rule && r.scope === serializeRuleScope(scope));
             sendJson(res, 200, { status: "no-op", rev: outcome.rev, stillLive });
             return;
         }
         case "failed":
-            // core 对 `failed` 的承诺是「读回确认什么都没写」或「读回本身也失败了,结局不定」——两种都是
-            // **重试可改判**的,所以 503 而不是 500。理由与 `state.rule_import_retry` 同族。
             logger.info("rule revoke failed", { error: outcome.error });
             sendError(res, 503, "state.rule_remove_failed", "the rule could not be revoked right now — retry, then reconcile with GET /v1/rules");
             return;