@sema-agent/server 7.139.0 → 7.141.0

package/dist/permission-mode-admission.d.ts

@@ -0,0 +1,68 @@
+/**
+ * **一个调用方交来的权限模式词,本部署收不收、收成什么** —— 唯一的受理判官(规则一处、三只属主各一处、序一处)。
+ *
+ * ## 一条规则,三只属主,本模块只排序
+ *  ① 本任务 settings 的 kill-switch 折叠(`task-settings.ts` `foldDisableAutoMode`:`disableAutoMode` 在 ⇒ `auto` 折 `default`);
+ *  ② 运维 `AUTONOMY` 的入口地板钳(`runtime-governance.ts` `entryPermissionMode` × `autonomyModeFloor`:`plan` 地板下比它松的词折成 `plan`);
+ *  ③ 托管姿态的写围栏拒(`hosted-posture.ts` `permissionModeWriteFaceRefusal`:开写面的词在托管形上 422 `request.host_posture_refused`)。
+ * ①② 是**入口一步**({@link entryStep}:改词、不拒),③ 是**托管一步**(只拒、不改词)。顺序承重的只有「② 在 ③ 之前」(地板把 bypass 钳成 plan 之后就不开写面,不拒);
+ * ① 只动 `auto`、③ 只看开写面的词,两者互不相交。
+ *
+ * ## 两口的调用形(同一组函数、同一个序;同一个词 × 同一份部署事实 × 同一份任务 settings ⇒ 同一个结果,钉 `test/run-permission-mode-admission.test.ts` 的两口表)
+ *  · 在飞 run 的切档口(`http/routes/run-permission-mode.ts`:`POST /v1/runs/:id/permission-mode` 的 `mode`,本任务 settings 读存储体)调整只判官 {@link admitPermissionModeWord}。
+ *  · 提交口(`POST /v1/tasks|/v1/tasks/stream|/v1/runs` 的词 = 顶层 `permissionMode` ?? bundle `settings.permissions.defaultMode`)把两步落在**上一版就在的两处**:
+ *    入口一步在受理门盖章({@link stampSubmissionEntryMode},`http/admission.ts`:值形门之后、装配之前 —— 首跑装配与 `buildCheckpointCtx` 读的都是盖过章的体);
+ *    托管一步是装配期那一处判(`boot/resolve-spec.ts`,对盖过章的词调同一只 ③;提交腿与续跑重放腿同经)。不把整只判官提前到受理门:那会让托管拒抢在
+ *    属主 / 会话 / 执行上下文与装配期其余值判之前答(拒序变了 —— 钉同一文件的拒序组)。续跑重放不再过 ②:地板是**入口**事实,热改只影响之后提交的任务。
+ *
+ * ## 为什么切档口必须经这只判官(而不是靠引擎的 deny 位)
+ * 引擎在根腿上只认两只模式拒位(`RuntimeCaps.bypassPermissions` / `RuntimeCaps.autoMode`,本仓由 center 与本地 kill-switch 写);上面三问
+ * 都不是引擎位 —— 根腿没有天花板座,托管姿态与任务 settings 都是逐提交的事实。切档口若不经这只判官,提交口在受理时拒过 / 折过的词
+ * 就能在 run 跑起来之后原样切进去。
+ *
+ * ## 答
+ *  · `refused` —— ③ 拒:状态 422、码 `request.host_posture_refused`、句子是属主的那一句;两口同码同句。
+ *  · `admitted` —— `requested`(调用方说的词,缺席 = 没说)、`admitted`(交给引擎的词)、`entry`(② 那一次求值的读数,盖章与地板通告只读它)、
+ *    `foldedBy`(本判官把词改了的那一站;没改 ⇒ 缺席。① ② 都改了 ⇒ `entry_floor`:落定的词是地板给的)。
+ */
+import type { PermissionMode } from "@sema-agent/core";
+import { type Autonomy, type EntryPermissionMode } from "./runtime-governance.js";
+import { HOST_POSTURE_REFUSED_CODE, type TaskWriteFaceInput } from "./hosted-posture.js";
+import { type ParsedTaskSettings } from "./task-settings.js";
+/** 本判官改词的站(闭集;wire 上切档回执的 `admission.foldedBy`)。引擎自己的折因词(`operator_deny` / `face_absent` / `inherited_ceiling`)在引擎回执里,不进这张表。 */
+export declare const PERMISSION_MODE_ADMISSION_FOLDS: readonly ["entry_floor", "disable_auto_mode"];
+export type PermissionModeAdmissionFold = (typeof PERMISSION_MODE_ADMISSION_FOLDS)[number];
+/** 判官读的事实:部署(活 config:`AUTONOMY` 地板 + 托管射程与天花板旋钮)与本任务的 settings(提交口 = 提交体的,切档口 = 存储体的)。 */
+export interface PermissionModeAdmissionFacts {
+    readonly deployment: TaskWriteFaceInput & {
+        readonly autonomy?: Autonomy | undefined;
+    };
+    readonly settings: ParsedTaskSettings | undefined;
+}
+export type PermissionModeAdmission = {
+    readonly kind: "refused";
+    readonly status: 422;
+    readonly code: typeof HOST_POSTURE_REFUSED_CODE;
+    readonly message: string;
+} | {
+    readonly kind: "admitted";
+    readonly requested: PermissionMode | undefined;
+    readonly admitted: PermissionMode | undefined;
+    readonly entry: EntryPermissionMode;
+    readonly foldedBy?: PermissionModeAdmissionFold;
+};
+/** 整只判官(入口一步 → 托管一步)—— 在飞 run 的切档口调它。 */
+export declare function admitPermissionModeWord(word: PermissionMode | undefined, facts: PermissionModeAdmissionFacts): PermissionModeAdmission;
+/**
+ * 提交口的入口一步(`http/admission.ts` 唯一调用;直调装配腿的测试夹具也调它 —— 少了这一步的体是部署上到不了的体):
+ * 体上的词(顶层 `permissionMode` ?? bundle `settings.permissions.defaultMode`)过 {@link entryStep},本任务的 settings = 体上那一份;
+ * 入口词盖进体(`task-settings.ts` `stampEntryPermissionMode`:地板在场时写顶层 `permissionMode`,缺席原物)。不拒 —— 托管一步在装配期判(见顶注「两口的调用形」)。
+ */
+export declare function stampSubmissionEntryMode<B extends {
+    permissionMode?: unknown;
+    settings?: unknown;
+}>(body: B, deployment: PermissionModeAdmissionFacts["deployment"]): {
+    readonly body: B;
+    readonly entry: EntryPermissionMode;
+};
+//# sourceMappingURL=permission-mode-admission.d.ts.map

package/dist/permission-mode-admission.js

@@ -0,0 +1,23 @@
+import { autonomyModeFloor, entryPermissionMode } from "./runtime-governance.js";
+import { HOST_POSTURE_REFUSED_CODE, permissionModeWriteFaceRefusal } from "./hosted-posture.js";
+import { foldDisableAutoMode, parseTaskSettings, requestedPermissionMode, stampEntryPermissionMode } from "./task-settings.js";
+export const PERMISSION_MODE_ADMISSION_FOLDS = ["entry_floor", "disable_auto_mode"];
+function entryStep(word, facts) {
+    const folded = foldDisableAutoMode(word, facts.settings);
+    const entry = entryPermissionMode(folded, autonomyModeFloor(facts.deployment.autonomy));
+    const foldedBy = entry.clamped ? "entry_floor" : folded !== word ? "disable_auto_mode" : undefined;
+    return { entry, ...(foldedBy !== undefined ? { foldedBy } : {}) };
+}
+export function admitPermissionModeWord(word, facts) {
+    const { entry, foldedBy } = entryStep(word, facts);
+    const why = permissionModeWriteFaceRefusal(entry.effective, facts.deployment);
+    if (why !== undefined)
+        return { kind: "refused", status: 422, code: HOST_POSTURE_REFUSED_CODE, message: why };
+    return { kind: "admitted", requested: word, admitted: entry.effective, entry, ...(foldedBy !== undefined ? { foldedBy } : {}) };
+}
+export function stampSubmissionEntryMode(body, deployment) {
+    const settings = parseTaskSettings(body.settings).settings;
+    const { entry } = entryStep(requestedPermissionMode(body, settings), { deployment, settings });
+    return { body: stampEntryPermissionMode(body, entry), entry };
+}
+//# sourceMappingURL=permission-mode-admission.js.map

package/dist/permission-rule-list.d.ts

@@ -1,6 +1,6 @@
 /**
  * **规则表的唯一编译口** —— 一张工具名规则表(`ask` / `deny` 之一)编成一只 `ToolPolicy`。读者:请求腿的 `settings.permissions.{ask,deny}`
- * 两桶(`task-settings.ts` 的 `deriveSettingsPolicy`)。
+ * 两桶(`task-settings.ts` 的 `deriveSettingsPolicy`,每桶按根至多编两集,见文件尾 {@link ruleRootOf})。设置层条目的形与层 → 根表也住这里(文件尾一节)。
  *
  * 🔴 core 7.42.0 起策略只说 deny / ask:allow 规则有且只有引擎 allow 层的两个席位 —— 请求的 `settings.permissions.allow` 整份投
  * `TaskSpec.allowedTools`(`task-settings.ts` 的 `applyTaskSettings`),运维的 `APPROVAL_GRANT` 投 `RunnerDeps.allowedTools`
@@ -9,6 +9,7 @@
  * 为什么住在一只叶模块里(不留在 `task-settings.ts`):本模块只 import core 与契约包 settings-schema(纯叶),读者引它不成环。
  */
 import { type PathRuleBases, type PermissionRule, type PermissionRulePolicyOptions, type ToolPolicy } from "@sema-agent/core";
+import { type SettingsSource } from "@sema-agent/settings-schema";
 /** 一张表里规则条数的上限 —— 请求腿 wire 门(`task-settings.ts` 的 deny / ask 两桶判形)读的也是这一个名字:core 的缺省帽是 256,
  *  不对齐的话第 257 条起编译当场抛,等于服务端自己收下的东西自己反悔。 */
 export declare const MAX_PERMISSION_RULES_PER_LIST = 1000;
@@ -21,13 +22,13 @@ export declare const MAX_PERMISSION_RULES_PER_LIST = 1000;
  * 交一只名册解析器会多出一种读法:目录没有的名字成 `unsupported.tool_unknown` —— 本仓自铸的工具(`repo_read_file(path:…)`)上一条编得出、真判的规则会在受理口被拒。
  */
 export declare function buildRuleListJudgeOptions(pathBases: PathRuleBases | undefined): Pick<PermissionRulePolicyOptions, "caps" | "pathBases">;
-/** A name-keyed rule-list ToolPolicy: a tool named by `names` gets `behavior` (`ask` tightens to an approval gate;
+/** A name-keyed rule-list ToolPolicy: a tool named by `rules` gets `behavior` (`ask` tightens to an approval gate;
  *  `deny` hard-blocks); every other tool is out of scope (`defaultAction: "allow"` = this policy has no opinion about
  *  anything it does not name — core 7.42.0: it states nothing and clears nothing). Composed deny-wins with the rest of
  *  the fold, so both only ever tighten.
  *
- *  `source` = 这张表**写在哪**(请求腿 `settings.permissions.<桶>`)。它盖进每条规则(core 的 deny / ask
- *  句里点名它:`flagged by permission rule "mcp__figma__*" (settings.permissions.ask)`),编不出来时的错误句也点名它;只是出处,
+ *  `source` = 这条规则**写在哪**(请求腿 `settings.permissions.<桶>`,带层条目再加层:`settings.permissions.ask, layer userSettings`)。它盖进每条规则(core 的 deny / ask
+ *  句里点名它:`flagged by permission rule "mcp__figma__*" (settings.permissions.ask)`),编不出来时的错误句点名桶;只是出处,
  *  不带任何优先级(层序在各自的折叠里)。
  *
  * 🔴 [ref] / core [ref] —— 本函数曾是 `new Set(askNames).has(req.toolName)` 的**逐字**比对,那是
@@ -74,6 +75,54 @@ export declare function buildRuleListJudgeOptions(pathBases: PathRuleBases | und
  *     排除在外),dist 亲读在案。审计归因改由 `matchedAskRule` + `source` 承担,后者比前者强:它还让 core 的 auto-mode 分类器
  *     **拒绝**替人清掉这条 ask(「运维写下的『每次问我』不是分类器的犹豫」),方向是收紧。
  */
-/** `behavior` = 这张表的态度 —— 型直接是 core 的 `PermissionRule["behavior"]`(不手抄:core 加 / 减一种态度,这里与它同步、读者 tsc 上见到)。 */
-export declare function createRuleListPolicy(names: readonly string[], behavior: PermissionRule["behavior"], source: string, pathBases: PathRuleBases | undefined): ToolPolicy;
+/** `behavior` = 这张表的态度 —— 型直接是 core 的 `PermissionRule["behavior"]`(不手抄:core 加 / 减一种态度,这里与它同步、读者 tsc 上见到)。
+ *  `rules` = 这一集的规则,**每条自带出处**({@link SourcedRule}:请求自己写的纯串 = 桶坐标;带层条目 = 桶坐标 + 层,{@link ruleSourceOf});
+ *  `table` = 这一集出自哪只桶(只进编不出时的兜底句;逐条坐标由先跑的受理判 `rulePolicyBucketsRefusal` 给)。 */
+export declare function createRuleListPolicy(rules: readonly SourcedRule[], behavior: PermissionRule["behavior"], table: string, pathBases: PathRuleBases | undefined): ToolPolicy;
+/**
+ * deny / ask 桶的一个条目:**纯串** = 请求自己写的规则(今天的形,读在任务根);**带层条目** `{ rule, layer }` = 端从某个设置层读来的规则,`layer` 是
+ * 契约包 `SETTINGS_SOURCES` 的来源词(= 参照实现的设置来源词)。层只决定这条规则的 `/` 读在哪个根({@link layerRuleRoot}),**不决定准入档**
+ * (准入只由凭据推,`http/caller-trust.ts`):调用方自报任何层,挪动的只是它自己那条收紧读在哪,与它自己写 `//abs` 等价。
+ *
+ * 为什么是「条目带层」而不是一只新键:本版之前的每一个读者(回滚、滚动发布中的旧副本)对一只没见过的键是**静默忽略**(续跑重放走宽容层),
+ * 带层的收紧会整批消失;对一个不是串的条目则在桶门上 `bad_entry` —— 新提交 400、续跑 409,响亮拒。条数帽也因此仍是「一桶一张表」。
+ */
+export type RuleListEntry = string | LayeredRule;
+/** 带层条目(恰两键;受理判 {@link ruleListEntryOk})。 */
+export interface LayeredRule {
+    readonly rule: string;
+    readonly layer: SettingsSource;
+}
+/** 一条进编译口的规则与它的出处串(core 规则行逐条带 `source`,问 / 拒句点名它)。 */
+export interface SourcedRule {
+    readonly rule: string;
+    readonly source: string;
+}
+/** 一个条目合不合 deny / ask 桶的条目律:非空串;或恰 `rule`(非空串)+ `layer`(`SETTINGS_SOURCES` 里的词)两键的纯对象。别的形一律不合(多键、空串、未知层、数组、原型对象)。 */
+export declare function ruleListEntryOk(x: unknown): x is RuleListEntry;
+/** 条目的规则原文(纯串即它自己)。 */
+export declare function ruleTextOf(entry: RuleListEntry): string;
+/** 条目进编译口的出处串:纯串 = 桶坐标(今天的字面);带层 = 桶坐标 + 层(`settings.permissions.deny, layer userSettings`)。 */
+export declare function ruleSourceOf(table: string, entry: RuleListEntry): string;
+/** 规则的 `/` 读在哪个根(闭集,也是一桶里各集的编译序与判序):`task` = 任务根;`configuration` = 执行环境的配置根(`execution-config-root.ts`)。 */
+export declare const RULE_ROOTS: readonly ["task", "configuration"];
+export type RuleRoot = (typeof RULE_ROOTS)[number];
+/**
+ * 一个设置层的 `/` 读在哪个根 —— 参照实现(CC 2.1.309)的表照录(`cli309.js:258818` `zBt` → `:252700` `D8o` / `swn`:user 层 ⇒ 配置目录 `Le()`〔`:251921`〕;
+ * project / local / policy ⇒ 工作目录;flag ⇒ flag 文件的目录,内联 ⇒ 工作目录)。本服务的两处取舍:`flagSettings` 读任务根(flag 文件的目录是端那台机的事实,本服务手里没有;
+ * 要固定位置写 `//abs`);`foreignProjectSettings`(仓库里写给别的工具的项目文件)与项目层同根。契约包加一个来源词 ⇒ 这里编译红。
+ */
+export declare function layerRuleRoot(layer: SettingsSource): RuleRoot;
+/**
+ * 一个条目编进哪一集:**只有 `/` 随层变** —— 带层条目的层根是配置根 ∧ 这条规则要 `root`(core 的必需基分类 `ruleBasesNeeded`)⇒ `configuration`;
+ * 其余一律 `task`(纯串、别的层、`~/` / 相对形、`//abs` 与 subpath 这类分类为空的规则 —— 后者在 Windows 族上仍随声明的根选盘,必须留在今天那一集)。
+ * 文法读不出的串 ⇒ `task`(受理判在前面就拒它,这里不另说一句)。
+ *
+ * 为什么按根分集、不按层分集:共根各层给出逐字相同的锚,合一集判决不变;而一只声明了 `root` 却没声明 `cwd` 的集把相对形读在声明的根上(core
+ * `policyAnchors`)—— 「一层一集」在任务根读不出的腿(未登记工作目录的 host 腿、每一条沙箱腿)上会把 user 层的相对规则读到配置根下。配置根那一集只装要
+ * `root` 的规则,`cwd` 永远不被问。
+ */
+export declare function ruleRootOf(entry: RuleListEntry, behavior: PermissionRule["behavior"]): RuleRoot;
+/** 一桶的条目按根分集(受理判与编译读同一只:判的就是要编的那一集);集内保持原序。 */
+export declare function ruleSetsOf(entries: readonly RuleListEntry[], behavior: PermissionRule["behavior"]): Readonly<Record<RuleRoot, readonly RuleListEntry[]>>;
 //# sourceMappingURL=permission-rule-list.d.ts.map

package/dist/permission-rule-list.js

@@ -1,5 +1,5 @@
-import { createPermissionRulePolicy } from "@sema-agent/core";
-import { stripControlAndBidi } from "@sema-agent/settings-schema";
+import { createPermissionRulePolicy, parseRuleText, ruleBasesNeeded } from "@sema-agent/core";
+import { SETTINGS_SOURCES, stripControlAndBidi } from "@sema-agent/settings-schema";
 export const MAX_PERMISSION_RULES_PER_LIST = 1_000;
 export function buildRuleListJudgeOptions(pathBases) {
     return {
@@ -7,13 +7,60 @@ export function buildRuleListJudgeOptions(pathBases) {
         ...(pathBases !== undefined ? { pathBases } : {}),
     };
 }
-export function createRuleListPolicy(names, behavior, source, pathBases) {
+export function createRuleListPolicy(rules, behavior, table, pathBases) {
     try {
-        return createPermissionRulePolicy(names.map((name) => ({ rule: name, behavior, source })), { defaultAction: "allow", ...buildRuleListJudgeOptions(pathBases) });
+        return createPermissionRulePolicy(rules.map(({ rule, source }) => ({ rule, behavior, source })), { defaultAction: "allow", ...buildRuleListJudgeOptions(pathBases) });
     }
     catch (e) {
         const coreMsg = stripControlAndBidi(e instanceof Error ? e.message : String(e));
-        throw new Error(`${source.replace("settings.", "")} has rule(s) core cannot compile — ${coreMsg}`, { cause: e });
+        throw new Error(`${table.replace("settings.", "")} has rule(s) core cannot compile — ${coreMsg}`, { cause: e });
     }
 }
+const SETTINGS_SOURCE_SET = new Set(SETTINGS_SOURCES);
+export function ruleListEntryOk(x) {
+    if (typeof x === "string")
+        return x.length > 0;
+    if (x === null || typeof x !== "object" || Array.isArray(x) || Object.getPrototypeOf(x) !== Object.prototype)
+        return false;
+    const keys = Object.keys(x);
+    if (keys.length !== 2 || !Object.hasOwn(x, "rule") || !Object.hasOwn(x, "layer"))
+        return false;
+    const { rule, layer } = x;
+    return typeof rule === "string" && rule.length > 0 && typeof layer === "string" && SETTINGS_SOURCE_SET.has(layer);
+}
+export function ruleTextOf(entry) {
+    return typeof entry === "string" ? entry : entry.rule;
+}
+export function ruleSourceOf(table, entry) {
+    return typeof entry === "string" ? table : `${table}, layer ${entry.layer}`;
+}
+export const RULE_ROOTS = ["task", "configuration"];
+export function layerRuleRoot(layer) {
+    switch (layer) {
+        case "userSettings":
+            return "configuration";
+        case "projectSettings":
+        case "localSettings":
+        case "flagSettings":
+        case "policySettings":
+        case "foreignProjectSettings":
+            return "task";
+        default: {
+            const unhandled = layer;
+            return unhandled;
+        }
+    }
+}
+export function ruleRootOf(entry, behavior) {
+    if (typeof entry === "string" || layerRuleRoot(entry.layer) === "task")
+        return "task";
+    const parsed = parseRuleText(entry.rule, behavior);
+    return "rule" in parsed && ruleBasesNeeded(parsed.rule).includes("root") ? "configuration" : "task";
+}
+export function ruleSetsOf(entries, behavior) {
+    const sets = { task: [], configuration: [] };
+    for (const entry of entries)
+        sets[ruleRootOf(entry, behavior)].push(entry);
+    return sets;
+}
 //# sourceMappingURL=permission-rule-list.js.map

package/dist/plugins/adoption-log-sql.js

@@ -86,8 +86,8 @@ export class SqlAdoptionLogStore {
     constructor(db) {
         this.db = db;
     }
-    q(tidb, pg) {
-        return this.db.dialect === "tidb" ? tidb : pg;
+    q(mysql, pg) {
+        return this.db.dialect === "mysql" ? mysql : pg;
     }
     get reader() {
         return this.db;
@@ -191,7 +191,7 @@ export class SqlAdoptionLogStore {
         try {
             lockName = qualifyAdoptionLockName(await this.resolveLockKeyspace(conn), name);
             for (let i = 0; i < attempts && !held; i += 1) {
-                const res = await conn.query(this.q("SELECT GET_LOCK(?, 0) AS got", "SELECT pg_try_advisory_lock($1, $2) AS got"), this.db.dialect === "tidb" ? [lockName] : [PG_ADOPTION_LOCK_CLASS, pgLockObjectKey(lockName)]);
+                const res = await conn.query(this.q("SELECT GET_LOCK(?, 0) AS got", "SELECT pg_try_advisory_lock($1, $2) AS got"), this.db.dialect === "mysql" ? [lockName] : [PG_ADOPTION_LOCK_CLASS, pgLockObjectKey(lockName)]);
                 const got = res.rows[0]?.got;
                 held = got === 1 || got === true || got === "1";
                 if (!held)
@@ -204,7 +204,7 @@ export class SqlAdoptionLogStore {
         finally {
             if (held) {
                 try {
-                    await conn.query(this.q("SELECT RELEASE_LOCK(?) AS released", "SELECT pg_advisory_unlock($1, $2) AS released"), this.db.dialect === "tidb" ? [lockName] : [PG_ADOPTION_LOCK_CLASS, pgLockObjectKey(lockName)]);
+                    await conn.query(this.q("SELECT RELEASE_LOCK(?) AS released", "SELECT pg_advisory_unlock($1, $2) AS released"), this.db.dialect === "mysql" ? [lockName] : [PG_ADOPTION_LOCK_CLASS, pgLockObjectKey(lockName)]);
                 }
                 catch (releaseErr) {
                     console.warn("[adoption-log] releasing the adoption arc lock failed (it auto-frees when the connection closes):", releaseErr);

package/dist/plugins/approval-ask-store-sql.js

@@ -386,7 +386,7 @@ function patchColumns(patch, json) {
     return out;
 }
 function ph(dialect, n) {
-    return dialect === "tidb" ? "?" : `$${n}`;
+    return dialect === "mysql" ? "?" : `$${n}`;
 }
 function pendingClaimWhere(dialect, firstParam) {
     return `ask_id = ${ph(dialect, firstParam)} AND batch_id = ${ph(dialect, firstParam + 1)} AND state = 'STREAM_PENDING'`;
@@ -394,15 +394,15 @@ function pendingClaimWhere(dialect, firstParam) {
 function decideOwnerWhere(dialect, owner, param) {
     if (owner === null)
         return { sql: "owner IS NULL", params: [] };
-    return dialect === "tidb" ? { sql: "CAST(owner AS BINARY) = CAST(? AS BINARY)", params: [owner] } : { sql: `owner = ${ph(dialect, param)}`, params: [owner] };
+    return dialect === "mysql" ? { sql: "CAST(owner AS BINARY) = CAST(? AS BINARY)", params: [owner] } : { sql: `owner = ${ph(dialect, param)}`, params: [owner] };
 }
 export class SqlApprovalAskStore {
     db;
     constructor(db) {
         this.db = db;
     }
-    q(tidb, pg) {
-        return this.db.dialect === "tidb" ? tidb : pg;
+    q(mysql, pg) {
+        return this.db.dialect === "mysql" ? mysql : pg;
     }
     json(value) {
         return dialectJsonEncoder(this.db.dialect)(value);
@@ -411,7 +411,7 @@ export class SqlApprovalAskStore {
         return isDupKeyError(this.db.dialect, e);
     }
     async getAskOn(conn, askId) {
-        const { rows } = await conn.query(this.q(`SELECT ${askCols("tidb")} FROM ${APPROVAL_ASK_TABLE} WHERE ask_id = ?`, `SELECT ${askCols("pg")} FROM ${APPROVAL_ASK_TABLE} WHERE ask_id = $1`), [askId]);
+        const { rows } = await conn.query(this.q(`SELECT ${askCols("mysql")} FROM ${APPROVAL_ASK_TABLE} WHERE ask_id = ?`, `SELECT ${askCols("pg")} FROM ${APPROVAL_ASK_TABLE} WHERE ask_id = $1`), [askId]);
         return rows[0] ? mapAskRow(rows[0]) : null;
     }
     async getBatchOn(conn, batchId) {
@@ -704,40 +704,40 @@ export class SqlApprovalAskStore {
         }
     }
     async listByState(state, limit) {
-        const { rows } = await this.db.query(this.q(`SELECT ${askCols("tidb")} FROM ${APPROVAL_ASK_TABLE} WHERE state = ? ORDER BY updated_at_ms ASC, created_at_ms ASC LIMIT ?`, `SELECT ${askCols("pg")} FROM ${APPROVAL_ASK_TABLE} WHERE state = $1 ORDER BY updated_at_ms ASC, created_at_ms ASC LIMIT $2`), [state, limit]);
+        const { rows } = await this.db.query(this.q(`SELECT ${askCols("mysql")} FROM ${APPROVAL_ASK_TABLE} WHERE state = ? ORDER BY updated_at_ms ASC, created_at_ms ASC LIMIT ?`, `SELECT ${askCols("pg")} FROM ${APPROVAL_ASK_TABLE} WHERE state = $1 ORDER BY updated_at_ms ASC, created_at_ms ASC LIMIT $2`), [state, limit]);
         return rows.map(mapAskRow);
     }
     async listPendingByTask(taskId, signal) {
         if (signal?.aborted === true)
             throw abortedReadError("listPendingByTask");
-        const { rows } = await withReadSignal(this.db.query(this.q(`SELECT ${askCols("tidb")} FROM ${APPROVAL_ASK_TABLE} WHERE task_id = ? AND state = 'STREAM_PENDING' ORDER BY created_at_ms ASC`, `SELECT ${askCols("pg")} FROM ${APPROVAL_ASK_TABLE} WHERE task_id = $1 AND state = 'STREAM_PENDING' ORDER BY created_at_ms ASC`), [taskId]), signal, "listPendingByTask");
+        const { rows } = await withReadSignal(this.db.query(this.q(`SELECT ${askCols("mysql")} FROM ${APPROVAL_ASK_TABLE} WHERE task_id = ? AND state = 'STREAM_PENDING' ORDER BY created_at_ms ASC`, `SELECT ${askCols("pg")} FROM ${APPROVAL_ASK_TABLE} WHERE task_id = $1 AND state = 'STREAM_PENDING' ORDER BY created_at_ms ASC`), [taskId]), signal, "listPendingByTask");
         return rows.map(mapAskRow);
     }
     async listPendingBySession(sessionId, owner, signal) {
         if (signal?.aborted === true)
             throw abortedReadError("listPendingBySession");
         const { rows } = await withReadSignal(this.db.query(owner === null
-            ? this.q(`SELECT ${askCols("tidb")} FROM ${APPROVAL_ASK_TABLE} WHERE session_id = ? AND state = 'STREAM_PENDING' AND owner IS NULL ORDER BY created_at_ms ASC`, `SELECT ${askCols("pg")} FROM ${APPROVAL_ASK_TABLE} WHERE session_id = $1 AND state = 'STREAM_PENDING' AND owner IS NULL ORDER BY created_at_ms ASC`)
-            : this.q(`SELECT ${askCols("tidb")} FROM ${APPROVAL_ASK_TABLE} WHERE session_id = ? AND state = 'STREAM_PENDING' AND owner = ? ORDER BY created_at_ms ASC`, `SELECT ${askCols("pg")} FROM ${APPROVAL_ASK_TABLE} WHERE session_id = $1 AND state = 'STREAM_PENDING' AND owner = $2 ORDER BY created_at_ms ASC`), owner === null ? [sessionId] : [sessionId, owner]), signal, "listPendingBySession");
+            ? this.q(`SELECT ${askCols("mysql")} FROM ${APPROVAL_ASK_TABLE} WHERE session_id = ? AND state = 'STREAM_PENDING' AND owner IS NULL ORDER BY created_at_ms ASC`, `SELECT ${askCols("pg")} FROM ${APPROVAL_ASK_TABLE} WHERE session_id = $1 AND state = 'STREAM_PENDING' AND owner IS NULL ORDER BY created_at_ms ASC`)
+            : this.q(`SELECT ${askCols("mysql")} FROM ${APPROVAL_ASK_TABLE} WHERE session_id = ? AND state = 'STREAM_PENDING' AND owner = ? ORDER BY created_at_ms ASC`, `SELECT ${askCols("pg")} FROM ${APPROVAL_ASK_TABLE} WHERE session_id = $1 AND state = 'STREAM_PENDING' AND owner = $2 ORDER BY created_at_ms ASC`), owner === null ? [sessionId] : [sessionId, owner]), signal, "listPendingBySession");
         return rows.map(mapAskRow);
     }
     async listByCall(call) {
-        const { rows } = await this.db.query(this.q(`SELECT ${askCols("tidb")} FROM ${APPROVAL_ASK_TABLE} WHERE task_id = ? AND leg_key = ? AND tool_call_id = ? AND source_task_id = ? ORDER BY created_at_ms ASC, ask_id ASC`, `SELECT ${askCols("pg")} FROM ${APPROVAL_ASK_TABLE} WHERE task_id = $1 AND leg_key = $2 AND tool_call_id = $3 AND source_task_id = $4 ORDER BY created_at_ms ASC, ask_id ASC`), [call.taskId, call.legKey, call.toolCallId, call.sourceTaskId]);
+        const { rows } = await this.db.query(this.q(`SELECT ${askCols("mysql")} FROM ${APPROVAL_ASK_TABLE} WHERE task_id = ? AND leg_key = ? AND tool_call_id = ? AND source_task_id = ? ORDER BY created_at_ms ASC, ask_id ASC`, `SELECT ${askCols("pg")} FROM ${APPROVAL_ASK_TABLE} WHERE task_id = $1 AND leg_key = $2 AND tool_call_id = $3 AND source_task_id = $4 ORDER BY created_at_ms ASC, ask_id ASC`), [call.taskId, call.legKey, call.toolCallId, call.sourceTaskId]);
         return rows.map(mapAskRow).filter((r) => askRowOnCall(r, call));
     }
     async listParkingBySession(sessionId) {
-        const { rows } = await this.db.query(this.q(`SELECT ${askCols("tidb")} FROM ${APPROVAL_ASK_TABLE} WHERE session_id = ? AND state = 'PARKING' ORDER BY created_at_ms ASC, ask_id ASC`, `SELECT ${askCols("pg")} FROM ${APPROVAL_ASK_TABLE} WHERE session_id = $1 AND state = 'PARKING' ORDER BY created_at_ms ASC, ask_id ASC`), [sessionId]);
+        const { rows } = await this.db.query(this.q(`SELECT ${askCols("mysql")} FROM ${APPROVAL_ASK_TABLE} WHERE session_id = ? AND state = 'PARKING' ORDER BY created_at_ms ASC, ask_id ASC`, `SELECT ${askCols("pg")} FROM ${APPROVAL_ASK_TABLE} WHERE session_id = $1 AND state = 'PARKING' ORDER BY created_at_ms ASC, ask_id ASC`), [sessionId]);
         return rows.map(mapAskRow).filter((r) => r.sessionId === sessionId);
     }
     async getAsk(askId) {
-        const { rows } = await this.db.query(this.q(`SELECT ${askCols("tidb")} FROM ${APPROVAL_ASK_TABLE} WHERE ask_id = ?`, `SELECT ${askCols("pg")} FROM ${APPROVAL_ASK_TABLE} WHERE ask_id = $1`), [
+        const { rows } = await this.db.query(this.q(`SELECT ${askCols("mysql")} FROM ${APPROVAL_ASK_TABLE} WHERE ask_id = ?`, `SELECT ${askCols("pg")} FROM ${APPROVAL_ASK_TABLE} WHERE ask_id = $1`), [
             askId,
         ]);
         return rows[0] ? mapAskRow(rows[0]) : null;
     }
     async getByIdempotencyKey(taskId, key) {
         assertIdempotencyKeyShape(key);
-        const { rows } = await this.db.query(this.q(`SELECT ${askCols("tidb")} FROM ${APPROVAL_ASK_TABLE} WHERE task_id = ? AND idempotency_key = ?`, `SELECT ${askCols("pg")} FROM ${APPROVAL_ASK_TABLE} WHERE task_id = $1 AND idempotency_key = $2`), [taskId, key]);
+        const { rows } = await this.db.query(this.q(`SELECT ${askCols("mysql")} FROM ${APPROVAL_ASK_TABLE} WHERE task_id = ? AND idempotency_key = ?`, `SELECT ${askCols("pg")} FROM ${APPROVAL_ASK_TABLE} WHERE task_id = $1 AND idempotency_key = $2`), [taskId, key]);
         return rows[0] ? mapAskRow(rows[0]) : null;
     }
     async deferReconcile(askId, expectedState, expectedRev, nowMs) {
@@ -772,7 +772,7 @@ export class SqlApprovalAskStore {
         const ANCHOR_COLUMNS = ["task_id", "session_id", "source_task_id"];
         let keepSql = "";
         let keepParams = [];
-        if (keep.length > 0 && dialect === "tidb") {
+        if (keep.length > 0 && dialect === "mysql") {
             const list = keep.map(() => "?").join(", ");
             keepSql = ANCHOR_COLUMNS.map((c) => ` AND ${c} NOT IN (${list})`).join("");
             keepParams = ANCHOR_COLUMNS.flatMap(() => keep);

package/dist/plugins/approval-nonce-store.js

@@ -10,15 +10,15 @@ export class SqlApprovalNonceStore {
     constructor(db) {
         this.db = db;
     }
-    q(tidb, pg) {
-        return this.db.dialect === "tidb" ? tidb : pg;
+    q(mysql, pg) {
+        return this.db.dialect === "mysql" ? mysql : pg;
     }
     async nowMs() {
         return sqlDbNowMs(this.db, APPROVAL_NONCE_TABLE);
     }
     async consume(sessionId, nonce, expiresAtMs) {
         try {
-            await this.db.query(this.q(`INSERT INTO ${APPROVAL_NONCE_TABLE} (session_id, nonce, consumed_at_ms, expires_at_ms) VALUES (?,?,${SQL_DB_NOW_MS.tidb},?)`, `INSERT INTO ${APPROVAL_NONCE_TABLE} (session_id, nonce, consumed_at_ms, expires_at_ms) VALUES ($1,$2,${SQL_DB_NOW_MS.pg},$3)`), [sessionId, nonce, expiresAtMs]);
+            await this.db.query(this.q(`INSERT INTO ${APPROVAL_NONCE_TABLE} (session_id, nonce, consumed_at_ms, expires_at_ms) VALUES (?,?,${SQL_DB_NOW_MS.mysql},?)`, `INSERT INTO ${APPROVAL_NONCE_TABLE} (session_id, nonce, consumed_at_ms, expires_at_ms) VALUES ($1,$2,${SQL_DB_NOW_MS.pg},$3)`), [sessionId, nonce, expiresAtMs]);
             return true;
         }
         catch (err) {
@@ -28,7 +28,7 @@ export class SqlApprovalNonceStore {
         }
     }
     async reapExpired() {
-        const res = await this.db.query(this.q(`DELETE FROM ${APPROVAL_NONCE_TABLE} WHERE expires_at_ms <= ${SQL_DB_NOW_MS.tidb}`, `DELETE FROM ${APPROVAL_NONCE_TABLE} WHERE expires_at_ms <= ${SQL_DB_NOW_MS.pg}`), []);
+        const res = await this.db.query(this.q(`DELETE FROM ${APPROVAL_NONCE_TABLE} WHERE expires_at_ms <= ${SQL_DB_NOW_MS.mysql}`, `DELETE FROM ${APPROVAL_NONCE_TABLE} WHERE expires_at_ms <= ${SQL_DB_NOW_MS.pg}`), []);
         return res.affected;
     }
 }

package/dist/plugins/blob-backend.d.ts

@@ -1,6 +1,6 @@
 import type { Pool as MysqlPool } from "mysql2/promise";
 import type { Pool as PgPool } from "pg";
-import { type SqlEngineFacts, type SqlEngineReading, type SqlWallSource, type SqlWallsReading } from "./sql-driver.js";
+import { type SqlEngineFacts, type SqlEngineReading, type SqlWallSource, type SqlWallsReading, type SqlDialect } from "./sql-driver.js";
 import { type Logger } from "../observability/logger.js";
 /**
  * 文本协议的 blob 膨胀律 —— mysql2 `query()` 把 Buffer 参数写成 `X'<hex>'`,一字节两个字符,所以承载一个 blob 的语句至少是它的 2 倍。
@@ -115,7 +115,7 @@ export declare class SqlBlobBackend implements BlobBackend {
     private readonly db;
     /** Where a stale connection's replacement is logged ({@link connectJudged}); the boot assembly passes the service logger. */
     private readonly log;
-    constructor(dialect: "tidb" | "pg", pool: MysqlPool | PgPool, maxBytes?: number, table?: string, log?: Pick<Logger, "warn">);
+    constructor(dialect: SqlDialect, pool: MysqlPool | PgPool, maxBytes?: number, table?: string, log?: Pick<Logger, "warn">);
     /** The created_at-refreshing content-addressed upsert — VERBATIM the tidb/pg stores' `putBlobRow`. Refreshes
      *  created_at even on a dedup hit so a re-used/just-written blob is "touched=now" and GC-grace-protected.
      *  (a): an over-cap blob is REJECTED (typed {@link BlobTooLargeError}) BEFORE the driver ever sees the bytes —
@@ -140,7 +140,7 @@ export declare class SqlBlobBackend implements BlobBackend {
 /** SHARED index op(workspace 浏览面 #3,[ref]②)—— per-blob 字节数,读 SQL INDEX 的 `byte_len`
  *  列(sqlHasBlobs 同款单 IN 查询;MinIO 后端的 bytes-NULL 索引行同样带 byte_len,两后端同源)。
  *  tree/file 面的 size 投影与「超限先拒后拉」都靠它——绝不为拿大小去 getBlob 整块字节。 */
-export declare function sqlBlobSizes(dialect: "tidb" | "pg", pool: MysqlPool | PgPool, hashes: string[]): Promise<Map<string, number>>;
+export declare function sqlBlobSizes(dialect: SqlDialect, pool: MysqlPool | PgPool, hashes: string[]): Promise<Map<string, number>>;
 export interface MinioBlobBackendConfig {
     endpoint: string;
     bucket: string;
@@ -198,7 +198,7 @@ export declare class MinioBlobBackend implements BlobBackend {
     /** Blob-domain index table ([ref] 域隔离,SqlBlobBackend.table 同款;默认 = E19 纪元的 snapshot_blob)。 */
     private readonly indexTable;
     constructor(cfg: MinioBlobBackendConfig, index?: {
-        dialect: "tidb" | "pg";
+        dialect: SqlDialect;
         pool: MysqlPool | PgPool;
         table?: string;
     });

package/dist/plugins/blob-backend.js

@@ -76,7 +76,7 @@ export class SqlBlobBackend {
         this.pool = pool;
         this.explicitCapBytes = maxBytes;
         this.table = table;
-        this.db = dialect === "tidb" ? mysqlDriver(pool) : pgDriver(pool);
+        this.db = dialect === "mysql" ? mysqlDriver(pool) : pgDriver(pool);
         this.log = log ?? createLogger();
     }
     async putBlob(hash, bytes) {
@@ -90,7 +90,7 @@ export class SqlBlobBackend {
         if (judged.refusal !== undefined)
             throw new BlobTooLargeError(bytes.byteLength, judged.refusal.cap);
         try {
-            await judged.conn.query(this.dialect === "tidb"
+            await judged.conn.query(this.dialect === "mysql"
                 ? `INSERT INTO ${this.table} (blob_hash, byte_len, bytes, created_at) VALUES (?,?,?,?) ON DUPLICATE KEY UPDATE created_at = VALUES(created_at)`
                 : `INSERT INTO ${this.table} (blob_hash, byte_len, bytes, created_at) VALUES ($1,$2,$3,$4) ON CONFLICT (blob_hash) DO UPDATE SET created_at = EXCLUDED.created_at`, [hash, bytes.byteLength, Buffer.from(bytes), new Date()]);
         }
@@ -99,7 +99,7 @@ export class SqlBlobBackend {
         }
     }
     async getBlob(hash) {
-        if (this.dialect === "tidb") {
+        if (this.dialect === "mysql") {
             const [rows] = await this.pool.query(`SELECT bytes FROM ${this.table} WHERE blob_hash = ?`, [hash]);
             return rows[0]?.bytes != null ? new Uint8Array(rows[0].bytes) : undefined;
         }
@@ -118,7 +118,7 @@ async function sqlHasBlobs(dialect, pool, hashes, table = "snapshot_blob") {
     if (hashes.length === 0)
         return new Set();
     const distinct = [...new Set(hashes)];
-    if (dialect === "tidb") {
+    if (dialect === "mysql") {
         const ph = distinct.map(() => "?").join(",");
         const [rows] = await pool.query(`SELECT blob_hash FROM ${table} WHERE blob_hash IN (${ph})`, distinct);
         return new Set(rows.map((r) => String(r.blob_hash)));
@@ -135,7 +135,7 @@ export async function sqlBlobSizes(dialect, pool, hashes) {
     const out = new Map();
     for (let i = 0; i < distinct.length; i += CHUNK) {
         const part = distinct.slice(i, i + CHUNK);
-        if (dialect === "tidb") {
+        if (dialect === "mysql") {
             const ph = part.map(() => "?").join(",");
             const [rows] = await pool.query(`SELECT blob_hash, byte_len FROM snapshot_blob WHERE blob_hash IN (${ph})`, part);
             for (const r of rows)
@@ -155,7 +155,7 @@ async function sqlDeleteIndexRowsPastGrace(dialect, pool, hashes, table = "snaps
         return [];
     const distinct = [...new Set(hashes)];
     const cutoff = new Date(Date.now() - BLOB_GC_GRACE_MS);
-    if (dialect === "tidb") {
+    if (dialect === "mysql") {
         const ph = distinct.map(() => "?").join(",");
         const grace = await pool
             .query(`SELECT blob_hash FROM ${table} WHERE created_at < ? AND blob_hash IN (${ph})`, [cutoff, ...distinct])
@@ -216,7 +216,7 @@ export class MinioBlobBackend {
             throw new Error(`MinioBlobBackend.putBlob ${hash}: HTTP ${res.status} ${detail.slice(0, 200)}`);
         }
         if (this.indexPool && this.indexDialect) {
-            if (this.indexDialect === "tidb") {
+            if (this.indexDialect === "mysql") {
                 await this.indexPool.query(`INSERT INTO ${this.indexTable} (blob_hash, byte_len, bytes, created_at) VALUES (?,?,NULL,?) ON DUPLICATE KEY UPDATE created_at = VALUES(created_at)`, [hash, bytes.byteLength, new Date()]);
             }
             else {

package/dist/plugins/breaker-state-sql.js

@@ -24,8 +24,8 @@ export class SqlBreakerState {
         this.db = db;
         this.onWriteFail = onWriteFail;
     }
-    q(tidb, pg) {
-        return this.db.dialect === "tidb" ? tidb : pg;
+    q(mysql, pg) {
+        return this.db.dialect === "mysql" ? mysql : pg;
     }
     get(key) {
         return this.cache.get(key);

package/dist/plugins/caching-session-store.d.ts

@@ -142,6 +142,12 @@ export declare class CachingSessionStore implements SessionStore {
      * 只读快照而非 getter:声明是店的构造期常量(会变的声明本身就是缺陷)。
      */
     readonly placements?: SessionStore["placements"];
+    /**
+     * 内层店的**会话耐久声明**(core `SessionStore.durability`,说的是未 placed 的会话)转发 —— 与 {@link retention} / {@link placements} 同一族教训:
+     * 生产默认把真店包进本类,core 的接线清单(`wiring_manifest.session.store`)与停驻自检读的就是包装层;不转发 = 一只声明了 `durable` 的店在默认部署上
+     * 读成 `process_local`(core 对缺席的 fail-closed 读法),没有任何一处报错。只读快照;缺席则不设。
+     */
+    readonly durability?: SessionStore["durability"];
     /** [ref]:placed 分区的两只读面(reap 分区腿 / 准入探针)——同款转发理由:reaper 与准入判据拿到的
      *  是包装层,不转发 = 分区腿静默不可用、暖命中的 claim 关门静默失效。缺席则不设(诚实降级)。 */
     readonly listPlaced?: (kind: "subagent", opts?: {

package/dist/plugins/caching-session-store.js

@@ -33,6 +33,7 @@ export class CachingSessionStore {
     replaceEntries;
     retention;
     placements;
+    durability;
     listPlaced;
     placementOf;
     constructor(inner, opts) {
@@ -43,6 +44,8 @@ export class CachingSessionStore {
         const declared = inner.retention;
         if (declared !== undefined)
             this.retention = declared;
+        if (inner.durability !== undefined)
+            this.durability = inner.durability;
         if (inner.placements !== undefined)
             this.placements = inner.placements;
         if (typeof inner.listPlaced === "function")

package/dist/plugins/checkpoint-index-columns.js

@@ -33,7 +33,7 @@ export function buildCheckpointIndexCells(cp) {
     };
 }
 export const APPROVAL_CARD_COLUMN_MAX_BYTES = {
-    tidb: 65_535,
+    mysql: 65_535,
     pg: Number.POSITIVE_INFINITY,
 };
 export function judgeCheckpointIndexCells(cp, dialect) {
@@ -83,7 +83,7 @@ function renderFacetCase(compared) {
     return `CASE ${CHECKPOINT_FACET_CASES.map((c) => `WHEN ${compared(c.column)} IN (${c.words.map(literal).join(", ")}) THEN ${literal(c.facet)}`).join(" ")} END`;
 }
 export const CHECKPOINT_FACET_SQL = Object.freeze({
-    tidb: renderFacetCase((column) => `CAST(${column} AS BINARY)`),
+    mysql: renderFacetCase((column) => `CAST(${column} AS BINARY)`),
     pg: renderFacetCase((column) => column),
 });
 export const CHECKPOINT_SWEEP_ORDER_SQL = "CASE WHEN approval_card IS NULL THEN 1 ELSE 0 END ASC, deadline ASC, token ASC";