@sema-agent/server 7.51.0 → 7.52.1

package/dist/device-ws-hub.js

@@ -735,9 +735,15 @@ export function createDeviceWsHub(options) {
             if (draining || closed)
                 return refuseUpgrade(socket, 503);
             const remoteKey = req.socket.remoteAddress ?? "unknown";
-            if (preAuthCount >= maxPreAuthConnections || (preAuthByRemote.get(remoteKey) ?? 0) >= maxPreAuthConnectionsPerRemote) {
-                metrics?.inc("device_preauth_refused_total");
-                logger?.warn("device_preauth_cap_hit", { remoteKey, preAuthCount, cap: maxPreAuthConnections });
+            const perRemoteCount = preAuthByRemote.get(remoteKey) ?? 0;
+            const globalHit = preAuthCount >= maxPreAuthConnections;
+            const perRemoteHit = maxPreAuthConnectionsPerRemote !== "off" && perRemoteCount >= maxPreAuthConnectionsPerRemote;
+            if (globalHit || perRemoteHit) {
+                const arm = globalHit ? (perRemoteHit ? "both" : "global") : "per_remote";
+                metrics?.inc("device_preauth_refused_total", { arm });
+                logger?.warn("device_preauth_cap_hit", {
+                    remoteKey, arm, preAuthCount, cap: maxPreAuthConnections, perRemoteCount, perRemoteCap: maxPreAuthConnectionsPerRemote,
+                });
                 return refuseUpgrade(socket, 503);
             }
             preAuthCount += 1;

package/dist/device-ws-protocol.d.ts

@@ -357,11 +357,11 @@ export type DeviceFrameParse = {
     detail: string;
 };
 /**
- * **规范** base64(codex 对抗轮 R1-F6,判真)。
+ * **规范** base64(codex 交叉轮 R1-F6,判真)。
  *
  * 🔴 为什么不能只判「是个字符串」再交给 `Buffer.from(v, "base64")`:Node 的解码是**宽松**的 ——
  * `"!!!!"` 解出一个**空** Buffer 而不抛,`"aG@k="` 悄悄丢掉非法字符照样解出两个字节。于是一条被
- * 传输层损坏(或被恶意构造)的流片会以「合法的空/短数据」进入交付路径,水位照常推进、chunkAck
+ * 传输层损坏(或被不可信构造)的流片会以「合法的空/短数据」进入交付路径,水位照常推进、chunkAck
  * 照常回给设备 —— 设备释放了它手上唯一的正本,调用方拿到的是**静默损坏**的输出。
  * 在协议边界判规范形 + 回编码自比,这条路就没了。跨仓同判据:cli 侧编码器必须产规范形。
  */

package/dist/env-facts.d.ts

@@ -76,7 +76,7 @@ export declare function ensureScratchpadDir(localDataRoot: string, sessionId: st
  *  fs-write gate exemptDirs + additionalDirectories 根围栏)。「没到货引擎忽略 = 无害 additive」。
  *
  *  信任边界:这是 exemptDirs **放宽**输入,验收 fail-closed(任何拒收形回落自算,不 fault 任务):
- *   - 多租户(requirePrincipal)一律拒——共享 worker 盘上租户自选豁免目录=越权面;
+ *   - 多租户(requirePrincipal)一律拒——共享 worker 盘上租户自选豁免目录=超范围面;
  *   - 仅 host-semantics lane——远程沙箱 lane 的 worker 本机路径对 hands 是谎言(honest-facts 同轴);
  *   - 绝对路径 + ≤{@link MAX_PATH}(core 渲染上限同源,超限=core 只能给模型假路径)+ canonical
  *     深度 ≥3(裸 /、/tmp、/home 一整块系统目录不能当豁免域;穿越形按 resolve 归一后判);

package/dist/execution-lane-caps.d.ts

@@ -1,7 +1,7 @@
 /**
  * 执行车道**闭集**与 per-lane 能力表(design device-executor-lane-v2 §4.1 收敛件,车A-1)。
  *
- * ## 病根:lane 词表是开放字符串上的十几处独立判别式
+ * ## 根本问题:lane 词表是开放字符串上的十几处独立判别式
  *
  * `config.remoteExec?.provider` 的静态型是 `string | undefined` 的判别联合,但消费面从来不是一处
  * switch —— 而是散在十几个文件里的**独立等式/集合/否定**:`cwdHonored` 比 `=== "host"`、

package/dist/fleet/fleet-bus.d.ts

@@ -102,7 +102,7 @@ export interface FleetTaskRow {
     transcriptId?: string;
     /** [1839]①/(a) 案:**终态行帧的残局键**——cli 实测裸 durable-run 完成时终态 task 帧键集只有
      *  [id,name,status,tokens,elapsedMs,description],idle 观察者(web 首屏形)从行卡拿不到终局。
-     *  (b) 案(为顶层 run 造 bg_notification)被否:那族语义=观察者眼里的**子代**,伪造事件族比丰富行帧
+     *  (b) 案(为顶层 run 造 bg_notification)被否:那族语义=观察者眼里的**子代**,自造事件族比丰富行帧
      *  更伤([1840]§二)。四键全部 ADDITIVE / tolerate-absent、**只在终态帧出现**:
      *  - `stoppedBy`:core open enum verbatim(与 BgNotification 同姿势);顶层 run 仅 cancel 路径有源
      *    (= "user",与 markStopSource 同源值),其余终态诚实缺席。
@@ -180,7 +180,10 @@ export interface FleetWorkflowRow {
     /** MF-Fleet additive(cli [1726] 二①):**已启动**(非排队中)的 agent 数 —— CC 2.1.220 `⚠ Large workflow`
      *  规模告警的分母。判别用 core 导出的 `deriveAgentDisplayStatus`(`startedAt` 未置 ⇒ 显示态 `queued`),
      *  **不自己重写谓词**:两端各写一遍必然漂移(本仓刚在治理面镜像上吃过同款)。
-     *  ADDITIVE / tolerate-absent:缺席时消费方可退回 `doneCount + failedCount` 这个**诚实下界**(告警偏早)。 */
+     *  ADDITIVE / tolerate-absent:缺席时消费方可退回 `doneCount + failedCount` 这个**诚实下界**(告警偏早)。
+     *  2.1.250 复核(S-11,语料=cc-decoded/cli250.js):告警函数 220↔250 逐字同形——agents 轴比的是
+     *  `scheduledAgents`,`started` 是 token/agent **投影的分母**(`started>0 ? totalTokens/started : 70k`);
+     *  阈值 25/1.5e6/70k 与 `CLAUDE_CODE_WORKFLOW_SIZE_WARNING_*` 覆盖名两版一致。 */
     startedCount?: number;
     elapsedMs?: number;
     tokens?: number;

package/dist/fleet/fleet-reconciler.d.ts

@@ -64,7 +64,7 @@ export declare const FLEET_RECONCILE_INTERVAL_MS = 60000;
 /** 每周期的**点读上限**。超出的行留到下一周期(顺序稳定 = bus 的插入序),不把一次扫描变成全表点读风暴。 */
 export declare const FLEET_RECONCILE_MAX_ROWS = 200;
 /** 一个周期的 durable 读**时间预算**。超时 = 放弃这一轮(记 F 类 fail-open),行留在面板上。
- *  与 `FLEET_SNAPSHOT_TERMINAL_READ_BUDGET_MS` 同值同理由:慢查询不该把整条腿钉死。 */
+ *  与 `FLEET_SNAPSHOT_TERMINAL_READ_BUDGET_MS` 同值同理由:慢查询不该把整条腿卡住。 */
 export declare const FLEET_RECONCILE_READ_BUDGET_MS = 2000;
 /** 熔断冷却:一次读失败/超预算之后,这段时间内**不再发起任何读**。`RunStore`/`WorkflowRunStore` 契约
  *  都没有取消面(发出去的查询撤不回),挂死的后端不该被每周期继续加压。冷却一过自动重探(自愈)。 */

package/dist/fleet/fleet-terminal-window.d.ts

@@ -16,7 +16,7 @@
  * ## 为什么本模块有进程级可变状态(路由域刻意保持零状态,故不放在 `routes/fleet.ts`)
  * 三件都长在同一个事实上——**`WorkflowRunStore` 契约没有取消面**,`Promise.race` 只结束等待、撤不回
  * 已发出的查询:合流(重连风暴不按连接数放大,R1-H2)、合流窗有限(不把陈旧结果发给后来者、也不让
- * 一条永不 settle 的读把后续连接全钉死,R2-H1/R3-M2)、熔断冷却(挂死的后端不被每周期继续加压,
+ * 一条永不 settle 的读把后续连接全卡住,R2-H1/R3-M2)、熔断冷却(挂死的后端不被每周期继续加压,
  * R3-H1)。真解是店侧查询超时/取消 —— 要动契约与四个后端,已作移交项。
  *
  * ## scope

package/dist/hooks/hook-runner.d.ts

@@ -48,7 +48,14 @@ export declare function hookMatcherMatches(matcher: string | undefined, value: s
  *  求值:名部走 permission matcher(交替/正则同 matcher 字段),括号内 arg-模式(`*` 通配)匹配工具输入的
  *  主字符串(Bash=command,文件工具=file_path/path)。CC 行为逐条目:不匹配 → 跳过该条目(记日志);
  *  非工具事件(payload 无 tool_name)→ "cannot be evaluated" 跳过;解析失败 → 跳过。返回:
- *  true=跑 / "not_matched" / "unevaluable"(调用方分别记账;跳过永不静默)。 */
+ *  true=跑 / "not_matched" / "unevaluable"(调用方分别记账;跳过永不静默)。
+ *
+ *  2.1.250 复核(S-11,2026-08-30;语料=sema-internal `blueprints/cc-decoded/cli250.js`):求值器与 220
+ *  逐字同构——五种工具事件之外「cannot be evaluated for non-tool event」跳过、「Skipping hook due to if
+ *  condition … not matching」跳过,两串日志逐字在场;括号内容经工具 `preparePermissionMatcher` 求值,与
+ *  本实现同向。差异登记(不改行为):①250 证据里名部=**规范化后等值比对**(`vd(toolName)!==o`),
+ *  「交替/正则」是 matcher 字段的文法——本实现名部走 hookMatcherMatches 属**超集**(alternation 也认),
+ *  如实登记不收窄;②250 的 `if` 已扩到 prompt/agent/http/mcp_tool 条目(本 runner 只翻 command,不涉)。 */
 export declare function hookIfMatches(cond: string, payload: unknown): true | "not_matched" | "unevaluable";
 /** createTaskHooks 的装配上下文(payload 的 CC-verbatim 字段来源)。 */
 export interface HookRunnerContext {

package/dist/http/active-run-conflict.d.ts

@@ -73,7 +73,7 @@ export interface PendingGateMaterial {
      *    ③ **材料读取失败**:整只 `pendingGate` 都不在(那时本键连位置都没有)。
      *  ⇒ 读作「不知道这道门叫什么」,**不是**「这道门没有身份」,更**不是**「这一定是条老行」。
      *
-     *  🔴 **它命名的是「本次 409 实际读到的那一行」,不是「activeTaskId 这条 run 的门」**(codex 对抗复审
+     *  🔴 **它命名的是「本次 409 实际读到的那一行」,不是「activeTaskId 这条 run 的门」**(codex 交叉复审
      *  R1-[high] 验真后如实登记):同 session 可以并存两条 pending checkpoint(表上**没有** per-session
      *  pending 唯一约束),而 `findPendingTokenBySession` 是**无序 `LIMIT 1`** —— 这个条件是本仓自己成文的
      *  已知事实(见 `src/http/server.ts` mintFreshRun 腿 409 那段的逐字论证:「两条 pending 并存时旧
@@ -147,7 +147,7 @@ export interface ActiveRunConflictDoneResult {
     /**
      * #316(c):与 409 body 同键同语义(见 {@link ActiveRunConflictBody.stale})。
      *
-     * 🔴 **跨仓欠账,如实登记**(codex 对抗复审 R1-[medium] 验真后的真形):sema-sdk 的
+     * 🔴 **跨仓欠账,如实登记**(codex 交叉复审 R1-[medium] 验真后的真形):sema-sdk 的
      * `spec/openapi.yaml` 里 `ActiveRunConflictDoneResult` 是 `additionalProperties: false` 的**封闭**
      * schema,今天只声明 `status/errorCode/errorMessage/activeTaskId/activeTaskStatus/pendingGate` 六键。
      * ⚠️ 亲验后的关键修正:这**不是本键引入的新问题** —— `msSinceLastActivity`(#245 S1)早就在这条

package/dist/http/principal-gate.d.ts

@@ -13,7 +13,7 @@ export declare function systemFor(req: IncomingMessage, config: ServiceConfig):
 export declare function bearerPresentedButUnverified(req: IncomingMessage, config: ServiceConfig): boolean;
 export declare function gatedPrincipal(req: IncomingMessage, config: ServiceConfig): string | undefined;
 /** The EXPLICIT operator gate (IMAGE-API-DESIGN.md §P2.4a MUST-FIX) — NOT the bare `isOperator` (whose empty-list
- *  "true-for-all" is a world-writable RCE door the instant OPERATOR_PRINCIPALS is empty). Requires a non-empty
+ *  "true-for-all" is an unrestricted-write exec door the instant OPERATOR_PRINCIPALS is empty). Requires a non-empty
  *  operator set AND a present principal IN it. The same form the preempt/resume endpoints already use.
  *  🔴 SINGLE mint point (E1): a byte-identical twin `explicitOperator` used to live below (image-visibility lane)
  *  and two more hand-inlined copies sat in approvals-assistant — a future hardening of this judgment would have

package/dist/http/route-ctx.d.ts

@@ -51,7 +51,9 @@ export interface RouteHelpers {
     usageWindowDenied(req: IncomingMessage, res: ServerResponse): Promise<boolean>;
     safeDecode(seg: string): string | null;
     isFleetWide(req: IncomingMessage): boolean;
-    runOwnerOk(req: IncomingMessage, res: ServerResponse, owner: string | null): boolean;
+    /** 属主门。`notFoundForm` 选 not-yours 臂的 404 拼法:缺省 `"run"`(not_found.run 长文,#262);session
+     *  资源面传 `"session"`(not_found.session + "session not found")与其 unknown 臂同码同串(G52 [5778])。 */
+    runOwnerOk(req: IncomingMessage, res: ServerResponse, owner: string | null, notFoundForm?: "run" | "session"): boolean;
     sessionOwnerScope(req: IncomingMessage): {
         fleetWide: boolean;
         gateOwner: string | null;
@@ -156,18 +158,38 @@ export interface RouteLegs {
      *
      *  `onTypedFailure` = 「typed 拒绝**别写响应**,交回给我」。默认(缺席)行为不变:`HttpError` 走
      *  `sendError` 连 `extra` 一起回显。DESIGN-269 车2 的 A2A 腿必须传它 —— 那些 `extra`(尤其
-     *  `scenario_unknown` 的**全部场景名**)对壳是指路材料,对一个外部 peer 是内部词表泄漏。 */
-    prepareSpec(req: IncomingMessage, res: ServerResponse, body?: TaskRequestBody, onTypedFailure?: (err: import("../security.js").HttpError) => void): Promise<PreparedTaskSubmission | null>;
+     *  `scenario_unknown` 的**全部场景名**)对壳是指路材料,对一个外部 peer 是内部词表外泄。 */
+    prepareSpec(req: IncomingMessage, res: ServerResponse, body?: TaskRequestBody, onTypedFailure?: (err: import("../security.js").HttpError) => void, 
+    /** S-46 件C:**腿身份**(不是能力表态)。`liveStream: true` 只由 `POST /v1/tasks/stream` 的装配点按
+     *  URL 传 —— 那是全树唯一挂 HITL 活流投递面的腿,逐腿 `interactionPosture` 判据的第一条合取项。
+     *  缺席 ⇒ 无人腿(bg / A2A / resume),行为字节不变。 */
+    legFacts?: {
+        liveStream?: boolean;
+    }): Promise<PreparedTaskSubmission | null>;
     /** 同步腿的终局记账(计费/配额/指标),tasks 域用。 */
     finalizeTaskResult(result: TaskResult, principal: string | undefined, objective: string, sessionId: string | undefined): void;
     /** approvals 决策腿:session → pending checkpoint → markResuming CAS → 驱动续跑。
      *  `settledBy` = **这次结算的出处**(core `ApprovalSettledBy`),必填:本腿有两个调用方(HTTP
      *  `/decide` = 人;内部 D-D SLA deny-sweep = 窗到期),而函数内部分辨不出谁在叫它 —— 必填参数把
      *  「漏报出处」变成编译错,不是一条下游把「没人答」渲染成「有人拒」的静默假出处。 */
-    resumeCheckpoint(sessionId: string, decision: "approve" | "deny", reason: string | undefined, settledBy: ApprovalSettledBy, req?: IncomingMessage, answer?: QuestionAnswer, binding?: DecideBinding, onResumeCommitted?: (overrideSessionId?: string) => Promise<void>, 
+    resumeCheckpoint(sessionId: string, decision: "approve" | "deny", reason: string | undefined, settledBy: ApprovalSettledBy, req?: IncomingMessage, answer?: QuestionAnswer, binding?: DecideBinding, 
+    /** S-02 codex R4(验真后修):remember 豁免的 grant 挂点。**工具名不再由路由自己读**(那是与本函数
+     *  载入行分歧的第三次 scope-less 读,三读分歧下会给他人工具落豁免=提权)——由本函数把**已属主校验的
+     *  载入 cp** 的工具名(`validatedToolName`,非 tool_approval / AskUserQuestion / legacy null ⇒ `null`
+     *  = 无可记)一并回传,路由只对这个逐字落店。`overrideSessionId` = parked 腿的 root/host 会话 grant 锚。 */
+    onResumeCommitted?: (grant: {
+        overrideSessionId?: string;
+        validatedToolName: string | null;
+    }) => Promise<void>, 
     /** #316:透传给 {@link DriveResumeArgs.acceptEarly}(200 受理语义)。HTTP `/decide` 腿传 `true`;
      *  内部 D-D SLA deny-sweep 不传 —— 它没有在等响应的人,提前受理对它零收益而少一条同步失败面。 */
-    acceptEarly?: boolean): Promise<{
+    acceptEarly?: boolean, 
+    /** S-02:调用方已验身份的裁定 —— stale 臂铸 `currentPending` 指路键前在被读回的行上重跑 decide 门
+     *  同一属主判(缺席 ⇒ 恒不造键;判据属主=server.ts 铸键点注)。 */
+    decider?: {
+        principal?: string;
+        explicitOperator: boolean;
+    }): Promise<{
         status: number;
         body: object;
     }>;

package/dist/http/routes/admin-memory-optout.d.ts

@@ -0,0 +1,48 @@
+/**
+ * design/383 §3.1 / S-50 §1.3(S-49 S-2)—— per-principal **memory-capture opt-out 授权表**的 operator 四口:
+ *
+ *   · `GET    /v1/admin/memory-optout`             → `{ deploymentDefault: Row|null, overrides: Row[] }`
+ *   · `PUT    /v1/admin/memory-optout`             body `{allow, note?}` → 部署缺省行 upsert(哨兵 `principal=''`)
+ *   · `PUT    /v1/admin/memory-optout/:principal`  body `{allow, note?}` → per-principal 覆盖行 upsert
+ *   · `DELETE /v1/admin/memory-optout/:principal`  → 撤覆盖(回落部署缺省);`{ deleted: boolean }` 诚实答
+ *
+ * Row = `{ principal, allow, updatedAtMs, updatedBy, note? }`(审计行内,S-50 §1.3;`updatedBy` = 调用方 operator
+ * principal,server 铸,body 不收)。
+ *
+ * ── 稿偏离两条(如实记)────────────────────────────────────────────────────────────────────────────
+ * ① S-50 §1.1/§1.3 写的是 `orgDefault` + `(org_id, principal)`。亲读本仓(2026-08-30 侦察):server **没有 org 身份维**
+ *    (租户维 = 单 principal;`org` 只是记忆 scope 目录里的词),给表/wire 铸一根没人能填的 `org_id` 是编数据。一台
+ *    worker = 一个租户面 ⇒ 「org 级缺省」落成**部署级缺省**,wire 键名随实体改叫 `deploymentDefault`。折叠律不变。
+ * ② S-50 §1.3 把部署缺省写成 `PUT …/memory-optout/default`。codex R1-[medium] 验真:`default` 是一个**合法 principal
+ *    拼写**,字面路径 `/default` 与 `%64efault`(解码后同为 `default`)在第一版里分派到**两个不同的行**(哨兵行 vs
+ *    一条名叫 default 的覆盖行)—— 命名空间碰撞,而且 DELETE 侧还不对称。修法不是「解码后再保留一个词」(那只是把
+ *    碰撞改成一条不可寻址的 principal),而是**让缺省行住在集合根**:`PUT /v1/admin/memory-optout`(集合本身的
+ *    「缺省」属性),`:principal` 面从此没有任何保留词,任何合法 principal(包括字面 `default`)都可寻址。
+ *
+ * ── 族属与门序 ────────────────────────────────────────────────────────────────────────────────────
+ * 与 `/v1/admin/drain` · `/v1/admin/config/refresh` · `/v1/admin/memory/consolidation` 逐字同族(operator lane:
+ * 同一条 `explicitOperatorOk` 门;billable=false;刻意不吃 drain / roster-pending 两道 503)。门序照 operator
+ * 面既有口径:身份(401)→ 授权(403)→ **能力(501)** → 验型(400)。授权在能力之前:一个够不着任何东西
+ * 的调用方不该从「这台有没有授权表」上读出部署形态。
+ * 🔴 四口都在 `isCredentialGatedRewrite`(server.ts)门内(codex R1-[high] 验真后补):授权的**唯一**输入是
+ * principal 头 ∧ 一次调用的爆炸半径跨租户(改缺省行 = 改整台部署每个 principal 的 verdict;读面 = 全部授权行 +
+ * operator 手写的 note)—— 无 service 凭证且未开 `ALLOW_UNAUTHED_WRITES` 的 worker 上那个头**可自造**,与
+ * `/v1/memory/erase` / `POST /v1/memory/export` 同一条论证。
+ *
+ * ── 为什么缺席形是 **501 `capability.*`** 而不是 404(与 consolidation 阀门刻意分家)──────────────────
+ * consolidation 的 404 说的是「旋钮没开」(运维表态,动作=开旋钮)。本面的缺席是「**这家店在本部署上不存在**」
+ * —— local 车道刻意不给授权表一个会遗忘的 in-memory twin(接口注),动作=换部署形态(接 SQL 后端)。那正是
+ * 本仓 501 `capability.*` 族的定义(`capability.memory_engine_required` / `capability.outcome_ledger_required`
+ * 同族)。能力位 `memoryOptOutGrant`(`GET /v1/capabilities`)读同一个事实 + operator 名单非空。
+ *
+ * ── 撤销窗(S-50 §1.4)──────────────────────────────────────────────────────────────────────────
+ * 写后**零缓存**:resolver 腿(`RuntimeCaps.allowMemoryOptOut`)每次 prepare 直读同一张表 ⇒ 下一次带声明的
+ * prepare 即读到新 verdict(撤权后新声明具名拒;已声明会话 record wins,core 判,server 零码)。
+ */
+import type { IncomingMessage, ServerResponse } from "node:http";
+import type { RouteCtx } from "../route-ctx.js";
+export declare const ADMIN_MEMORY_OPTOUT_PATH = "/v1/admin/memory-optout";
+/** 带参口(`:principal`)⇒ 名册门走 `ROUTE_LABEL_PATTERNS`(server.ts),不是 LITERALS。 */
+export declare const ADMIN_MEMORY_OPTOUT_OVERRIDE_RE: RegExp;
+export declare function handleMemoryOptOut(req: IncomingMessage, res: ServerResponse, url: string, ctx: RouteCtx): Promise<boolean>;
+//# sourceMappingURL=admin-memory-optout.d.ts.map

package/dist/http/routes/admin-memory-optout.js

@@ -0,0 +1,75 @@
+import { z } from "zod";
+import { sendJson, sendError } from "../send.js";
+import { gatedPrincipal, explicitOperatorOk } from "../principal-gate.js";
+import { memoryOptOutPrincipalShapeProblem } from "../../plugins/memory-optout-grant-store-sql.js";
+export const ADMIN_MEMORY_OPTOUT_PATH = "/v1/admin/memory-optout";
+export const ADMIN_MEMORY_OPTOUT_OVERRIDE_RE = /^\/v1\/admin\/memory-optout\/([^/]+)$/;
+const PutBodySchema = z.object({ allow: z.boolean(), note: z.string().min(1).max(500).optional() }).strict();
+export async function handleMemoryOptOut(req, res, url, ctx) {
+    const miss = { fell: false };
+    await handleBody(req, res, url, ctx, miss);
+    return !miss.fell;
+}
+function decideVerb(method, path, safeDecode) {
+    if (path === ADMIN_MEMORY_OPTOUT_PATH) {
+        if (method === "GET")
+            return { kind: "list" };
+        if (method === "PUT")
+            return { kind: "putDefault" };
+        return undefined;
+    }
+    const m = ADMIN_MEMORY_OPTOUT_OVERRIDE_RE.exec(path);
+    if (m === null)
+        return undefined;
+    if (method !== "PUT" && method !== "DELETE")
+        return undefined;
+    const principal = safeDecode(m[1]);
+    if (principal === null)
+        return "malformed";
+    return method === "PUT" ? { kind: "putOverride", principal } : { kind: "deleteOverride", principal };
+}
+async function handleBody(req, res, url, ctx, miss) {
+    const { deps } = ctx;
+    const path = url.split("?")[0] ?? url;
+    const verb = decideVerb(req.method, path, ctx.helpers.safeDecode);
+    if (verb === undefined) {
+        miss.fell = true;
+        return;
+    }
+    const principal = gatedPrincipal(req, deps.config);
+    if (deps.config.requirePrincipal && !principal) {
+        sendError(res, 401, "auth.principal_required", `missing principal header '${deps.config.principalHeader}'`);
+        return;
+    }
+    if (!explicitOperatorOk(principal, deps.config.operatorPrincipals)) {
+        sendError(res, 403, "auth.operator_only", "memory opt-out grant administration is operator-only: the caller principal is not in OPERATOR_PRINCIPALS (an empty list means NO one is an operator — configure it to enable these endpoints)");
+        return;
+    }
+    const operator = principal;
+    const store = deps.memoryOptOutGrant;
+    if (store === undefined) {
+        sendError(res, 501, "capability.memory_optout_grant_required", "this deployment has no memory opt-out grant table: the per-principal memory-capture opt-out authorization store lives on a SQL store backend (DB_BACKEND=mysql|pg) and the local backend deliberately keeps no forgetting twin — wire a SQL backend to administer opt-out grants");
+        return;
+    }
+    if (verb === "malformed" || ((verb.kind === "putOverride" || verb.kind === "deleteOverride") && memoryOptOutPrincipalShapeProblem(verb.principal) !== undefined)) {
+        sendError(res, 400, "request.path_malformed", "invalid memory opt-out grant principal — the path segment must percent-decode to a non-empty principal of at most 190 chars with no leading/trailing whitespace or control characters (the deployment default row is addressed by PUT on the collection root, not by a path segment)");
+        return;
+    }
+    if (verb.kind === "list") {
+        sendJson(res, 200, await store.list());
+        return;
+    }
+    if (verb.kind === "deleteOverride") {
+        sendJson(res, 200, { principal: verb.principal, deleted: await store.deleteOverride(verb.principal) });
+        return;
+    }
+    const parsed = PutBodySchema.safeParse(await ctx.helpers.readJson(req));
+    if (!parsed.success) {
+        sendError(res, 400, "request.body_shape", "invalid memory opt-out grant body — expected exactly { allow: boolean, note?: string (1..500 chars) }; unknown keys are refused (a mistyped `allow` must not silently become a no-op)");
+        return;
+    }
+    const input = { allow: parsed.data.allow, updatedBy: operator, ...(parsed.data.note !== undefined ? { note: parsed.data.note } : {}) };
+    const row = verb.kind === "putDefault" ? await store.putDefault(input) : await store.putOverride(verb.principal, input);
+    sendJson(res, 200, row);
+}
+//# sourceMappingURL=admin-memory-optout.js.map

package/dist/http/routes/agents-roster.d.ts

@@ -16,7 +16,7 @@
  *
  * ## 三条边界(逐条对着失败形写)
  *  · **principal 门 + 反枚举**:身份判在店可用性判**之前**(否则「这台有没有装店」会先于 401 泄出去,
- *    与 `GET /v1/sessions` 的同款注释);principal 调用方**钉死自己的 scope**(`?scope=` 对它无效),
+ *    与 `GET /v1/sessions` 的同款注释);principal 调用方**锁定自己的 scope**(`?scope=` 对它无效),
  *    于是别的租户的行不是「403」也不是「空 200 但 total 多 1」——它在这个名册里**根本不存在**,
  *    没有任何可判别面(`total` 同样是属主口径:一个多出来的计数就是存在性 oracle)。
  *  · **投影白名单**(照 `routes/fleet.ts` `stripT` 的姿势):逐键**显式拼**,并用

package/dist/http/routes/approvals-assistant.js

@@ -38,6 +38,8 @@ async function decideIdempotentReplay(cs, args) {
     const boundCallId = binding.boundCallId;
     if (boundCallId === undefined)
         return undefined;
+    if (binding.checkpointToken !== undefined)
+        return undefined;
     if (typeof cs.findDecidedApprovalsForBinding !== "function")
         return undefined;
     const rows = await cs.findDecidedApprovalsForBinding(sessionId, boundCallId);
@@ -463,30 +465,28 @@ async function handleApprovalsAssistantBody(req, res, url, ctx, miss) {
                     return;
                 }
             }
-            let rememberToolName = null;
-            if (remember) {
-                const tok = await cs.findPendingTokenBySession(sessionId);
-                const cp0 = tok ? await cs.get(tok) : null;
-                const pa0 = cp0?.pendingAction;
-                const tn = pa0 && pa0.kind === "tool_approval" ? pa0.toolName : null;
-                rememberToolName = tn && tn !== "AskUserQuestion" ? tn : null;
-            }
             let rememberApplied = false;
-            const grantOnCommit = remember && deps.approvalExemptionStore && rememberToolName
-                ? async (overrideSessionId) => {
-                    const grantSessionId = overrideSessionId ?? sessionId;
-                    try {
-                        const canonical = rememberToolName;
-                        await deps.approvalExemptionStore.grant(grantSessionId, canonical, deciderPrincipal ?? null);
-                        rememberApplied = true;
-                        deps.logger?.info?.("approval_exemption_granted", { sessionId: grantSessionId, toolName: canonical, grantedBy: deciderPrincipal ?? null });
-                    }
-                    catch (e) {
-                        deps.logger?.warn?.("approval_exemption_grant_failed", { sessionId: grantSessionId, toolName: rememberToolName, error: String(e).slice(0, 200) });
-                    }
+            let pendingGrant;
+            const grantOnCommit = remember && deps.approvalExemptionStore
+                ? async (grant) => {
+                    const canonical = grant.validatedToolName;
+                    if (!canonical)
+                        return;
+                    pendingGrant = { sessionId: grant.overrideSessionId ?? sessionId, toolName: canonical };
                 }
                 : undefined;
-            const out = await resumeCheckpoint(sessionId, decision, body.reason ?? undefined, "human", req, answer, binding, grantOnCommit, true);
+            const out = await resumeCheckpoint(sessionId, decision, body.reason ?? undefined, "human", req, answer, binding, grantOnCommit, true, { principal: deciderPrincipal, explicitOperator });
+            const outErrorCode = out.body.errorCode;
+            if (pendingGrant !== undefined && out.status === 200 && outErrorCode !== "cancelled" && deps.approvalExemptionStore) {
+                try {
+                    await deps.approvalExemptionStore.grant(pendingGrant.sessionId, pendingGrant.toolName, deciderPrincipal ?? null);
+                    rememberApplied = true;
+                    deps.logger?.info?.("approval_exemption_granted", { sessionId: pendingGrant.sessionId, toolName: pendingGrant.toolName, grantedBy: deciderPrincipal ?? null });
+                }
+                catch (e) {
+                    deps.logger?.warn?.("approval_exemption_grant_failed", { sessionId: pendingGrant.sessionId, toolName: pendingGrant.toolName, error: String(e).slice(0, 200) });
+                }
+            }
             const replay = await decideIdempotentReplay(cs, {
                 sessionId,
                 out,

package/dist/http/routes/capabilities.js

@@ -9,6 +9,7 @@ import { mcpInjectionHonored } from "../../task-mcp.js";
 import { sendJson, sendError } from "../send.js";
 import { resolveStreamApprovalGate } from "../../tool-approval.js";
 import { projectMemoryEngineCapability } from "../../memory-posture.js";
+import { workflowModelAllowlistFor } from "../../task-workflow.js";
 import { centerEntitlementSourceWired } from "../../runtime-caps-resolver.js";
 import { gatedPrincipal } from "../principal-gate.js";
 function routePairingOf(deps, name, m) {
@@ -55,24 +56,21 @@ async function handleCapabilitiesBody(req, res, url, ctx, miss) {
             fleet: deps.fleetBus
                 ? { stream: true, sessionScope: true, observe: true, resume: "snapshot", bgNotifyFailClosed: true, steerPriority: "advisory", hookFailureNotice: true }
                 : false,
-            workspace: (() => {
-                const wfs = deps.fileSnapshotStore;
-                return wfs && typeof wfs.listKeys === "function" && typeof wfs.exportManifest === "function" && typeof wfs.getBlob === "function" && Boolean(deps.sessionStorage?.ownerOf)
-                    ? { browse: true, archive: true, maxFileBytes: deps.config.workspaceFileMaxBytes ?? 8 * 1024 * 1024 }
-                    : false;
-            })(),
+            workspace: false,
             leader: Boolean(deps.leaderEndpoint),
             images: Boolean(deps.imageIndex),
             memory: false,
             memoryWrite: false,
             memoryEngine: projectMemoryEngineCapability(deps.memoryPosture),
             sessionBackgroundable: Boolean(deps.runStore),
+            runMemoryCaptureOptOut: Boolean(deps.runStore),
             sharedMemory: Boolean(deps.sharedMemoryStore && deps.orgMemoryDirectory),
             adoption: Boolean(deps.backend?.adoptionLog) && deps.config.operatorPrincipals.length > 0,
             memoryBundle: Boolean(deps.memoryBundleExport && deps.memoryBundleImport) && deps.config.operatorPrincipals.length > 0,
             memoryCompliance: Boolean(deps.memoryCompliance) && deps.config.operatorPrincipals.length > 0,
             memoryOrigin: Boolean(deps.memoryOriginFace) && deps.config.operatorPrincipals.length > 0,
             memoryConsolidationDriver: Boolean(deps.memoryConsolidation) && deps.config.operatorPrincipals.length > 0,
+            memoryOptOutGrant: Boolean(deps.memoryOptOutGrant) && deps.config.operatorPrincipals.length > 0,
             outcomeLedger: Boolean(deps.outcomeSink?.summary) && (deps.config.requirePrincipal !== true || deps.config.operatorPrincipals.length > 0),
             permissionRules: Boolean(deps.ruleConsent) && gatedPrincipal(req, deps.config) !== undefined,
             permissionRulesRevoke: Boolean(deps.ruleConsent),
@@ -135,15 +133,28 @@ async function handleCapabilitiesBody(req, res, url, ctx, miss) {
             resumeAt: Boolean(deps.resumeAnchorStore && deps.sessionStorage?.getLeafId),
             promptSuggestions: true,
             sessionPolicy: Boolean(deps.sessionPolicyStore),
-            rewindFiles: Boolean(deps.fileSnapshotStore),
-            rewindFilesTo: Boolean(deps.fileSnapshotStore && deps.resumeAnchorStore && deps.sessionStorage?.getLeafId),
+            rewindFiles: Boolean(deps.fileHistoryStore),
+            restoreFiles: Boolean(deps.fileHistoryStore),
+            rewindFilesTo: Boolean(deps.fileHistoryStore && deps.resumeAnchorStore && deps.sessionStorage?.getLeafId),
             scheduler: Boolean(deps.config.schedulerEnabled && deps.config.requirePrincipal !== true && deps.config.remoteExec?.provider === "host"),
-            sessionSync: Boolean(deps.backend && deps.sessionStorage?.exportEntries && deps.sessionStorage?.beginImportStaging && deps.fileSnapshotStore),
+            sessionSync: Boolean(deps.backend && deps.sessionStorage?.exportEntries && deps.sessionStorage?.beginImportStaging && deps.fileHistoryStore),
             sendUserFile: Boolean(deps.sendUserFile && deps.config.sendUserFile?.publicEndpoint),
             s3PublicEndpoint: deps.config.sendUserFile?.publicEndpoint ?? null,
             sendUserFileLedger: Boolean(deps.sendFileLedger),
             workflows: deps.workflowsCapable ?? Boolean(deps.workflowRunStore),
             workflowsList: Boolean(deps.workflowRunStore),
+            workflowModels: (() => {
+                const allow = deps.workflowModelAllowlist
+                    ?? workflowModelAllowlistFor({
+                        selfOrchestrationModels: deps.config.selfOrchestrationModels ?? [],
+                        requirePrincipal: deps.config.requirePrincipal,
+                        models: deps.config.models ?? {},
+                    })
+                    ?? [];
+                const bare = deps.config.models ?? {};
+                const live = expandTiers(bare, deps.config.tiers ?? {}) ?? bare;
+                return allow.filter((n) => Object.hasOwn(live, n));
+            })(),
             manualCompact: Boolean(deps.runStore),
         });
         return;

package/dist/http/routes/diagnostics.d.ts

@@ -91,7 +91,7 @@ export declare function assertStaticWiringConsistent(facts: StaticWiringFacts, l
  * 走认证(全局门),不进本臂。
  *
  * 判源=TCP 对端地址(`req.socket.remoteAddress`),**非任何头**——XFF 类头在无反代的 turnkey 形上本就
- * 是伪造面;有反代的部署必然配 token(反代后 remoteAddress 恒 loopback,门自然放行,语义仍对:该形的
+ * 是自造面;有反代的部署必然配 token(反代后 remoteAddress 恒 loopback,门自然放行,语义仍对:该形的
  * 边界由反代+token 承担)。`remoteAddress` 缺席(socket 已断等边缘)⇒ 判拒(fail-closed,安全轴方向)。
  */
 export declare function zeroCredentialLoopbackDenied(remoteAddress: string | undefined, config: {

package/dist/http/routes/leader.d.ts

@@ -2,7 +2,7 @@
  * design/158 A9 域模块 —— v2 leader 端点(design/50)。
  *
  * 路由:`POST /v1/leader`(异步,形同 `/v1/runs`)· `GET /v1/leader/:id`。整域由 `deps.leaderEndpoint`
- * 的存在与否开关;身份层与 `/v1/runs` 同款(BL-4:此前整条路绕过 authorize/requirePrincipal 且不记 owner,
+ * 的存在与否开关;身份层与 `/v1/runs` 同款(BL-4:此前整条路跳过 authorize/requirePrincipal 且不记 owner,
  * 任何持服务令牌者能提交/读任意租户的 leader run),owner 用 crypto 验证过的 `gatedPrincipal`。本域零可变状态。
  */
 import type { IncomingMessage, ServerResponse } from "node:http";

package/dist/http/routes/memory-bundle.d.ts

@@ -27,7 +27,7 @@
  *  · 记忆引擎整个没接线(`MEMORY_ENGINE=off` / 多租 file 底座等暗态);
  *  · 引擎接了但后端没有 bundle 复合面(pg/tidb 孪生)—— 这一支在**挂载期**就判掉了
  *    (`createMemoryBundleFaces` 返回 undefined ⇒ 两口整个不挂),能力位 `memoryBundle` 因此与「路由真能用」
- *    严格同真。🔴 首版把它当运行期事实(照常挂载、让 core 每次抛 409/422),被 codex 对抗复审驳倒并改此形:
+ *    严格同真。🔴 首版把它当运行期事实(照常挂载、让 core 每次抛 409/422),被 codex 交叉复审驳倒并改此形:
  *    面在不在是一次**属性检查**、boot 期判得出、且是**永久**缺席 ⇒ 照常挂着就是一个恒假的 yes,
  *    壳会据此给用户开出一条走不通的迁移流程。
  * ⚠️ 与**运行期**拒别混:后端**有**复合面但托管链 chain-degraded 时,core 照样抛

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

@@ -1,5 +1,6 @@
 import { z } from "zod";
 import { sendJson, sendError } from "../send.js";
+import { buildOriginFencedBundle, readOriginAware } from "../../memory-origin-fence.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";
@@ -93,7 +94,7 @@ async function handleMemoryBundleBody(req, res, url, ctx, miss) {
         }
         try {
             const bundle = await engineExport(parsed.data.scopes);
-            sendJson(res, 200, bundle);
+            sendJson(res, 200, buildOriginFencedBundle(bundle, readOriginAware(new URL(req.url ?? "", "http://x").searchParams)));
         }
         catch (err) {
             if (!sentClassifiedFailure(res, ctx, "export", err))

package/dist/http/routes/memory-compliance.d.ts

@@ -73,19 +73,19 @@
  *
  * ── 改写门(`isCredentialGatedRewrite`):**两口都进** ──────────────────────────────────────────
  * 该门自 #277 起的判据是「持久改写 **或** 授权唯一输入是 principal 头、且**没有属主门兜底**的治理面」:
- *  · `POST /v1/memory/erase` 落在**前**一项上,而且是最深的一种:它把条目从本店**删掉**。伪造一个在册
+ *  · `POST /v1/memory/erase` 落在**前**一项上,而且是最深的一种:它把条目从本店**删掉**。自造一个在册
  *    operator 头即可对任一租户执行一次不可撤销的删除 —— 无凭证部署上缺的正是「上游会验这个头」这个前提。
  *  · `GET …/:entryId/provenance` 落在**后**一项上。🔴 这一条**推翻了 design/316 §3 的原始裁定**
- *    (稿子把它豁免在门外,理由是「爆炸半径=一条」);codex 对抗复审 [high] 指出该理由站不住,亲验后采信:
+ *    (稿子把它豁免在门外,理由是「爆炸半径=一条」);codex 交叉复审 [high] 指出该理由站不住,亲验后采信:
  *      ⑴ 稿子援引来类比的两条豁免读(`GET /v1/adoption/:id` / `GET /v1/rules`)在门外的**真正**原因是
  *         它们各有**属主门**兜底,不是「读得少」;本口的授权判据就只有 `explicitOperatorOk`,过了就直接答;
- *      ⑵ 无凭证部署上那个头**可伪造**,于是「一条」这个上界实际退化成「知道 id 就能读」——拿一个不可猜的
+ *      ⑵ 无凭证部署上那个头**可自造**,于是「一条」这个上界实际退化成「知道 id 就能读」——拿一个不可猜的
  *         id 当唯一的授权,是本仓在别处明令不接受的形;
  *      ⑶ 一条账里有:绑定的 scope+slug、贡献会话 id 与污染理由、仓内 ingest 路径与内容哈希、托管链事件。
  *    先例逐字同源:`POST /v1/memory/export` 当初也「按原措辞本不该进」,同一条论证把它收了进来
  *    ——「把它留在门外只为守住一句措辞,是把措辞看得比它要保护的东西更重」。
  *  🔴 判据里**刻意不写**「本口 side-effect-free」:那不是这道门的判据。该门拦的是「授权的唯一输入是
- *     一个可伪造的头」这件事 —— 用「没有副作用」当豁免理由,正是 #277 那次把 `POST /v1/memory/export`
+ *     一个可自造的头」这件事 —— 用「没有副作用」当豁免理由,正是 #277 那次把 `POST /v1/memory/export`
  *     (纯读、跨租户全库)漏在门外的那句话。
  *  ⚠️ 代价与补偿如实成文:无凭证部署上两口都答 503 `auth.service_token_required`。补偿是**既有旋钮、
  *     零新增** —— 配 `SERVICE_AUTH_TOKEN`(正路),或本地开发显式 `ALLOW_UNAUTHED_WRITES=true`

package/dist/http/routes/memory-origin.d.ts

@@ -43,8 +43,8 @@
  *  · 而这份账**新长一个键**时,静默上 wire 恰恰是危险的那一侧(它是托管面,不是事实陈述面)。
  * ⇒ 显式白名单 + **编译期差集门**(`test/wire-whitelist-exhaustiveness.test.ts` 的 `KnownExcluded`
  *   = `entryText`,逐字写理由):core 加一个键 ⇒ TS2344 ⇒ 由人处置,而不是悄悄上 wire 或悄悄漏掉。
- * 🔴 白名单是**深**的,不是只做一层(codex 对抗复审 [high] 抓的第一版病):嵌套的 `origin` 也逐键投影
- *   —— 一层白名单 + 一个整只透传的嵌套对象,等于给这条排除留了一个后门,全文见 {@link buildOriginWire}。
+ * 🔴 白名单是**深**的,不是只做一层(codex 交叉复审 [high] 抓的第一版病):嵌套的 `origin` 也逐键投影
+ *   —— 一层白名单 + 一个整只透传的嵌套对象,等于给这条排除留了一个旁路,全文见 {@link buildOriginWire}。
  * 🔴 **剥了不等于不说**:投影补一个 `custodyBytes`(托管字节数)。这是 #196 absence-reports-not-silent-green
  *   在本口的落法 —— operator 判「这个 pending 行还揣着一条记忆吗」只需要这一位;悄悄把整个托管概念从
  *   审计面上抹掉,会让一个**必须由人处置**的崩溃恢复席看上去不存在。
@@ -57,12 +57,12 @@
  *
  * ── 改写门(`isCredentialGatedRewrite`):**三口全进** ──────────────────────────────────────────
  * 该门自 #277 起的判据是「持久改写 **或** 授权唯一输入是 principal 头的跨租户治理读」:
- *  · `POST …/clear` 落在**前**一项:它把一条条目的外源披露**永久摘掉**(墓碑 + 同 id 重录),伪造一个
+ *  · `POST …/clear` 落在**前**一项:它把一条条目的外源披露**永久摘掉**(墓碑 + 同 id 重录),自造一个
  *    在册 operator 头即可让任意租户的一条外来记忆看上去是本店自产的 —— 而记忆是模型每次挂载都读的面;
  *  · `GET …/external` 落在**后**一项,而且是这一族里爆炸半径最大的读:一次调用取回**任意 scope**的
  *    条目 + 每条的完整出处账(贡献会话 id、污染理由、仓内 ingest 路径与内容哈希、托管链事件)。判据与
  *    `POST /v1/memory/export`(#277 收进门的那条纯读)逐字同构:它没有属主门兜底,operator 头过了就直接答。
- *  · `GET …/clearances` —— 🔴 **本车第一版把它留在门外,codex 对抗复审 [high] 推翻,亲验后采信**。
+ *  · `GET …/clearances` —— 🔴 **本车第一版把它留在门外,codex 交叉复审 [high] 推翻,亲验后采信**。
  *    那一版的理由是「投影后不含条目正文,爆炸半径差一个量级」,而这个理由**用错了基准**:本门的判据
  *    从来不是「含不含正文」,而是「授权的**唯一**输入是 principal 头」∧「没有属主门兜底」。按那条判据,
  *    一口**整部署**的清标账(每个租户的 scope+slug、entryId、rev、operator 手写的自由文本 `reason`、

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

@@ -1,6 +1,7 @@
 import { z } from "zod";
 import { ControlPlaneCorruptError } from "@sema-agent/core";
 import { sendJson, sendError } from "../send.js";
+import { buildOriginFence, readOriginAware } from "../../memory-origin-fence.js";
 import { gatedPrincipal, explicitOperatorOk } from "../principal-gate.js";
 export const MEMORY_ORIGIN_EXTERNAL_PATH = "/v1/memory/origin/external";
 export const MEMORY_ORIGIN_CLEARANCES_PATH = "/v1/memory/origin/clearances";
@@ -141,7 +142,8 @@ async function handleMemoryOriginBody(req, res, url, ctx, miss) {
             return;
         }
         try {
-            sendJson(res, 200, { scopes, entries: await faces.listExternal(scopes) });
+            const fence = buildOriginFence(await faces.listExternal(scopes), readOriginAware(new URL(req.url ?? "", "http://x").searchParams));
+            sendJson(res, 200, { scopes, entries: fence.entries, ...(fence.withheldOriginTagged !== undefined ? { withheldOriginTagged: fence.withheldOriginTagged } : {}) });
         }
         catch (err) {
             if (!sentClassifiedFailure(res, ctx, "external", err))