@sema-agent/server 7.142.0 → 7.144.0

package/dist/plugins/task-attachment-store.js

@@ -3,7 +3,7 @@ import { ensureIndexes } from "./ensure-index.js";
 import { createHash } from "node:crypto";
 import { attachmentKindOf, PROJECT_BUNDLE_MIME } from "../project-bundle.js";
 import { mysqlDriver, pgDriver } from "./sql-driver.js";
-import { isDeadlockError } from "./sql-errors.js";
+import { isDupKeyError, retryOnDeadlock } from "./sql-errors.js";
 export const TaskAttachmentRecordSchema = z.object({
     id: z.string(),
     owner: z.string(),
@@ -183,6 +183,8 @@ export async function materializeAttachmentsInto(env, store, sessionId) {
     }
     return placements.length;
 }
+const SEED_KEY = "uq_att_seed";
+const SEED_KEY_EXPR = `CASE WHEN mime = '${PROJECT_BUNDLE_MIME}' THEN session_id END`;
 export async function ensureTiDBTaskAttachmentSchema(pool) {
     await pool.query(`CREATE TABLE IF NOT EXISTS ${TASK_ATTACHMENT_TABLE} (
     id VARCHAR(64) NOT NULL,
@@ -196,15 +198,19 @@ export async function ensureTiDBTaskAttachmentSchema(pool) {
     session_id VARCHAR(190) NULL,
     created_at_ms BIGINT NOT NULL,
     bound_at_ms BIGINT NULL,
+    -- 种子键:项目包行的会话,其余行 NULL(引擎推导,没有写者);唯一 ⇒ 一只会话一只种子
+    seed_session_id VARCHAR(190) GENERATED ALWAYS AS (${SEED_KEY_EXPR}) VIRTUAL,
     PRIMARY KEY (id),
     KEY idx_att_session (session_id),
-    KEY idx_att_unbound (created_at_ms)
+    KEY idx_att_unbound (created_at_ms),
+    UNIQUE KEY ${SEED_KEY} (seed_session_id)
   ) COLLATE utf8mb4_bin`);
     await ensureIndexes((text, params) => pool.query(text, params), "mysql", TASK_ATTACHMENT_INDEXES);
 }
 export const TASK_ATTACHMENT_INDEXES = [
     { table: `${TASK_ATTACHMENT_TABLE}`, name: "idx_att_session", columns: ["session_id"] },
     { table: `${TASK_ATTACHMENT_TABLE}`, name: "idx_att_unbound", columns: ["created_at_ms"] },
+    { table: `${TASK_ATTACHMENT_TABLE}`, name: SEED_KEY, columns: ["seed_session_id"], unique: true },
 ];
 export async function ensurePgTaskAttachmentSchema(q) {
     await q(`CREATE TABLE IF NOT EXISTS ${TASK_ATTACHMENT_TABLE} (
@@ -218,66 +224,50 @@ export async function ensurePgTaskAttachmentSchema(q) {
     session_id VARCHAR(190) COLLATE "C",
     created_at_ms BIGINT NOT NULL,
     bound_at_ms BIGINT,
+    -- 种子键(同 MySQL 侧注)
+    seed_session_id VARCHAR(190) COLLATE "C" GENERATED ALWAYS AS (${SEED_KEY_EXPR}) STORED,
     PRIMARY KEY (id)
   )`);
     await ensureIndexes(q, "pg", TASK_ATTACHMENT_INDEXES);
 }
-const SEED_BIND_DEADLOCK_RETRIES = 4;
 async function bindOnSql(db, owner, ids, sessionId, boundAtMs) {
     const list = [...new Set(ids)];
     if (list.length === 0)
         return { bound: [], refused: [] };
     const mysql = db.dialect === "mysql";
     const q = (mysqlSql, pgSql) => (mysql ? mysqlSql : pgSql);
-    const kinds = await db.query(q(`SELECT id, mime FROM ${TASK_ATTACHMENT_TABLE} WHERE owner = ? AND id IN (${list.map(() => "?").join(",")})`, `SELECT id, mime FROM ${TASK_ATTACHMENT_TABLE} WHERE owner = $1 AND id = ANY($2::varchar[])`), mysql ? [owner, ...list] : [owner, list]);
-    const kindOf = new Map(kinds.rows.map((r) => [String(r.id), attachmentKindOf(String(r.mime))]));
-    const verdicts = new Map();
-    const plain = list.filter((id) => kindOf.get(id) === "attachment");
-    if (plain.length > 0) {
-        const inList = plain.map(() => "?").join(",");
-        const held = await retryingDeadlock(db.dialect, async () => {
-            await db.query(q(`UPDATE ${TASK_ATTACHMENT_TABLE} SET bound_at_ms = CASE WHEN session_id IS NULL THEN ? ELSE bound_at_ms END, session_id = ? WHERE owner = ? AND id IN (${inList}) AND (session_id IS NULL OR session_id = ?)`, `UPDATE ${TASK_ATTACHMENT_TABLE} SET bound_at_ms = CASE WHEN session_id IS NULL THEN $2::bigint ELSE bound_at_ms END, session_id = $1::varchar WHERE owner = $3 AND id = ANY($4::varchar[]) AND (session_id IS NULL OR session_id = $1::varchar)`), mysql ? [boundAtMs, sessionId, owner, ...plain, sessionId] : [sessionId, boundAtMs, owner, plain]);
-            return db.query(q(`SELECT id, session_id FROM ${TASK_ATTACHMENT_TABLE} WHERE owner = ? AND id IN (${inList})`, `SELECT id, session_id FROM ${TASK_ATTACHMENT_TABLE} WHERE owner = $1 AND id = ANY($2::varchar[])`), mysql ? [owner, ...plain] : [owner, plain]);
-        });
-        for (const r of held.rows) {
-            if (r.session_id === null || r.session_id === undefined)
-                continue;
-            verdicts.set(String(r.id), String(r.session_id) === sessionId ? "bound" : "bound_elsewhere");
-        }
-    }
+    const ownRows = (columns, of) => db.query(q(`SELECT ${columns} FROM ${TASK_ATTACHMENT_TABLE} WHERE owner = ? AND id IN (${of.map(() => "?").join(",")})`, `SELECT ${columns} FROM ${TASK_ATTACHMENT_TABLE} WHERE owner = $1 AND id = ANY($2::varchar[])`), mysql ? [owner, ...of] : [owner, of]);
+    const kindOf = new Map((await ownRows("id, mime", list)).rows.map((r) => [String(r.id), attachmentKindOf(String(r.mime))]));
+    const claim = (of) => retryOnDeadlock(db.dialect, () => inTransaction(db, (conn) => conn.query(q(`UPDATE ${TASK_ATTACHMENT_TABLE} SET bound_at_ms = CASE WHEN session_id IS NULL THEN ? ELSE bound_at_ms END, session_id = ? WHERE owner = ? AND id IN (${of.map(() => "?").join(",")}) AND (session_id IS NULL OR session_id = ?)`, `UPDATE ${TASK_ATTACHMENT_TABLE} SET bound_at_ms = CASE WHEN session_id IS NULL THEN $2::bigint ELSE bound_at_ms END, session_id = $1::varchar WHERE owner = $3 AND id = ANY($4::varchar[]) AND (session_id IS NULL OR session_id = $1::varchar)`), mysql ? [boundAtMs, sessionId, owner, ...of, sessionId] : [sessionId, boundAtMs, owner, of])));
+    const attachments = list.filter((id) => kindOf.get(id) === "attachment");
+    if (attachments.length > 0)
+        await claim(attachments);
+    const seedFixed = new Set();
     for (const id of list) {
         if (kindOf.get(id) !== "project_bundle")
             continue;
-        const verdict = await retryingDeadlock(db.dialect, () => inTransaction(db, (conn) => bindProjectBundleOnSql(conn, mysql, owner, id, sessionId, boundAtMs)));
-        if (verdict !== undefined)
-            verdicts.set(id, verdict);
+        try {
+            await claim([id]);
+        }
+        catch (err) {
+            if (!isSeedKeyConflict(db.dialect, err))
+                throw err;
+            seedFixed.add(id);
+        }
     }
+    const holderOf = new Map((await ownRows("id, session_id", list)).rows.map((r) => [String(r.id), r.session_id === null || r.session_id === undefined ? undefined : String(r.session_id)]));
     const bound = [];
     const refused = [];
     for (const id of list) {
-        const v = verdicts.get(id);
-        if (v === "bound")
+        if (seedFixed.has(id))
+            refused.push({ kind: "bundle_seed_fixed", id });
+        else if (holderOf.get(id) === sessionId)
             bound.push(id);
-        else if (v !== undefined)
-            refused.push({ kind: v, id });
+        else if (holderOf.get(id) !== undefined)
+            refused.push({ kind: "bound_elsewhere", id });
     }
     return { bound, refused };
 }
-async function bindProjectBundleOnSql(conn, mysql, owner, id, sessionId, boundAtMs) {
-    const q = (mysqlSql, pgSql) => (mysql ? mysqlSql : pgSql);
-    const anchor = await conn.query(q(`SELECT session_id FROM ${TASK_ATTACHMENT_TABLE} WHERE mime = ? AND (session_id IS NULL OR session_id = ?) ORDER BY id FOR UPDATE`, `SELECT session_id FROM ${TASK_ATTACHMENT_TABLE} WHERE mime = $1 AND (session_id IS NULL OR session_id = $2::varchar) ORDER BY id FOR UPDATE`), [PROJECT_BUNDLE_MIME, sessionId]);
-    const own = await conn.query(q(`SELECT session_id FROM ${TASK_ATTACHMENT_TABLE} WHERE id = ? AND owner = ? FOR UPDATE`, `SELECT session_id FROM ${TASK_ATTACHMENT_TABLE} WHERE id = $1 AND owner = $2 FOR UPDATE`), [id, owner]);
-    const [row] = own.rows;
-    if (row === undefined)
-        return undefined;
-    const holder = row.session_id;
-    if (holder !== null && holder !== undefined)
-        return String(holder) === sessionId ? "bound" : "bound_elsewhere";
-    if (anchor.rows.some((r) => r.session_id !== null && r.session_id !== undefined))
-        return "bundle_seed_fixed";
-    await conn.query(q(`UPDATE ${TASK_ATTACHMENT_TABLE} SET bound_at_ms = ?, session_id = ? WHERE id = ? AND owner = ? AND session_id IS NULL`, `UPDATE ${TASK_ATTACHMENT_TABLE} SET bound_at_ms = $1::bigint, session_id = $2::varchar WHERE id = $3 AND owner = $4 AND session_id IS NULL`), [boundAtMs, sessionId, id, owner]);
-    return "bound";
-}
 async function inTransaction(db, work) {
     const conn = await db.connect();
     try {
@@ -294,17 +284,12 @@ async function inTransaction(db, work) {
         conn.release();
     }
 }
-async function retryingDeadlock(dialect, attempt) {
-    for (let tries = 0;; tries++) {
-        try {
-            return await attempt();
-        }
-        catch (err) {
-            if (tries < SEED_BIND_DEADLOCK_RETRIES && isDeadlockError(dialect, err))
-                continue;
-            throw err;
-        }
-    }
+function isSeedKeyConflict(dialect, err) {
+    if (!isDupKeyError(dialect, err) || err === null || typeof err !== "object")
+        return false;
+    if (dialect === "pg")
+        return Reflect.get(err, "constraint") === SEED_KEY;
+    return new RegExp(`\\b${SEED_KEY}\\b`).test(String(Reflect.get(err, "sqlMessage") ?? Reflect.get(err, "message") ?? ""));
 }
 export class TiDBTaskAttachmentStore {
     pool;

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

@@ -17,7 +17,6 @@ import type { SessionWorkspace } from "../session-workspace.js";
 import type { RetentionDeclaration } from "@sema-agent/core";
 import type { SessionSummary } from "./store-contracts.js";
 import { type ClientSessionRowWrite, type ReplaySessionRowWrite, type ReplaySessionRowWriteOutcome, type SessionRowPatch, type SessionRowWriteOutcome } from "../session-row.js";
-import { type OrphanOwnerLog } from "../delegated-session-owner.js";
 import { type PlacementAcquireOpts } from "./session-placement.js";
 import { type StagingHandle } from "../session-sync-kernel.js";
 import { type ForkTarget, type ForkToOutcome } from "./session-fork.js";
@@ -40,8 +39,6 @@ export declare class TiDBSessionStore implements SessionStore {
     readonly durability: "durable";
     /** In-flight acquisitions keyed by id, so concurrent acquire(sameId) in one process share one. */
     private readonly pending;
-    /** 委派子代孤行那一行 warn 的去处(`delegated-session-owner.ts`;装配给部署的 logger,缺席 ⇒ 缺省 logger,不静默)。 */
-    private readonly log;
     /**
      * 执行席 —— 根会话行上这一位住客的那一格的唯一读口与 place / markMirror 两只写口(规则在 `src/execution-placement.ts`;
      * 实现与语句的唯一属主 = `execution-placement-sql.ts`,两孪生同一只实现,本店只交自己的池)。
@@ -50,7 +47,6 @@ export declare class TiDBSessionStore implements SessionStore {
     /** 本店的池包成的 SqlDriver:执行席与会话行格写原语的事务都经它借连接(连接初始化钉住事务读语义,`sql-driver.ts`)。 */
     private readonly db;
     constructor(pool: Pool, opts?: {
-        readonly log?: OrphanOwnerLog;
         readonly retention?: RetentionDeclaration;
     });
     acquire(sessionId?: string, opts?: PlacementAcquireOpts): Promise<AcquiredSession>;
@@ -58,18 +54,10 @@ export declare class TiDBSessionStore implements SessionStore {
     /** Idempotently create a session_meta row with an owner (core `SessionStore.register`). Existing owner is never overwritten. */
     register(sessionId: string, owner: string | null): Promise<void>;
     /**
-     * acquire 的建行(唯一一处):普通会话 ⇒ 无主(按 id 首建的既有读法);placed 会话 ⇒ 属主按委派继承律在**这一笔**里写入
-     * ([ref]:根会话的属主,根行不在取父,都不在 ⇒ 孤行哨兵 + warn;属主 = 判断时见证到的,读来源 → 判 → INSERT —— 读法与顺序只住在
-     * `delegated-session-owner.ts` 的 `createPlacedSessionRow`,本店只交既有读写口,PG 孪生同调)。
+     * acquire 的建行(唯一一处):普通会话 ⇒ 无主(按 id 首建的既有读法);placed 会话 ⇒ 属主 = `placement.owner` 原样,与元组同一条 INSERT 落库
+     * (core 7.62.0 [ref] 盒义务 7:委派树的属主是引擎判的,店只记、不判、不推断;唯一读法 `placedSessionOwnerOf`,值不是主体名也不是 null ⇒ 响亮拒、不留行。PG 孪生同调)。
      */
     private createOnAcquire;
-    /**
-     * [ref] 委派继承律的**认领口**:这只会话的那一位住客(判断时读到的化身)仍是无主的 placed 行 ⇒ 写 `owner`,返回是否写成
-     * (句 = `CLAIM_OWNERLESS_PLACED_SQL`,只 CAS 子行自己,与停驻挂点 / M23 同一只;规则在 `delegated-session-owner.ts`)。普通会话行不在射程(placed 判别位)。
-     */
-    claimOwnerless(sessionId: string, incarnation: string, owner: string): Promise<boolean>;
-    /** 若干来源行的会话面(属主 + 化身)一次读回(委派继承律的来源读;本店没有的 id 不在表里;活住客的投影 `sessionFaceFromRow`,空化身 ⇒ 响亮拒)。 */
-    private sourceFaces;
     /** The one session_meta INSERT. Existing owner is never overwritten.
      *  [ref]:`placement` 在场时与行同一条 INSERT 落六列;ON DUPLICATE 臂是 no-op ⇒ 已存在的行的元组
      *  **永不被重写**(first-write 不可变,义务 5 的写侧半场)。

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

@@ -10,11 +10,9 @@ import { carriedRowCells, headFromRow, incarnationFromCell, mintSessionIncarnati
 import { sessionRowTagKey } from "../session-row.js";
 import { writeSessionRowCellsSql } from "./session-row-sql.js";
 import { contentForkRelation, fastForwardSharedContentDiverged } from "../session-sync-content.js";
-import { CLAIM_OWNERLESS_PLACED_SQL, claimOwnerlessParams, createPlacedSessionRow } from "../delegated-session-owner.js";
-import { createLogger } from "../observability/logger.js";
 import { placementCapabilityOf, LIST_PLACED_BATCH, PLACEMENT_SELECT_COLUMNS, placedRowFromRow, placementFromRow, placementInsertValues, SESSION_DURABILITY, SESSION_PLACEMENTS, } from "./session-placement.js";
 import { classifySyncRelationshipByIds, SyncConflictError, StagedCommitOwnerChangedError, stagingIdFor, STAGING_ID_MARKER, STAGING_GC_GRACE_MS, } from "../session-sync-kernel.js";
-import { assertFirstOwnerWritable, forkOwnerOf, isSessionOwnerValue } from "./session-ownership.js";
+import { assertFirstOwnerWritable, forkOwnerOf, isSessionOwnerValue, placedSessionOwnerOf } from "./session-ownership.js";
 import { selectForkRows } from "@sema-agent/core";
 import { FORK_LOG_ROW_SHAPE, ForkTargetUnsettledError, classifyForkTarget, forkByFreshId, forkPointOf } from "./session-fork.js";
 import { isMysqlDupKeyError } from "./sql-errors.js";
@@ -28,12 +26,10 @@ export class TiDBSessionStore {
     placements = SESSION_PLACEMENTS;
     durability = SESSION_DURABILITY;
     pending = new Map();
-    log;
     executionPlacement;
     db;
     constructor(pool, opts = {}) {
         this.pool = pool;
-        this.log = opts.log ?? createLogger();
         this.retention = opts.retention ?? UNMANAGED_RETENTION;
         this.db = mysqlDriver(pool);
         this.executionPlacement = createSqlExecutionPlacementSeat(this.db);
@@ -81,21 +77,7 @@ export class TiDBSessionStore {
         await this.insertMeta(sessionId, owner, undefined);
     }
     async createOnAcquire(sessionId, placement) {
-        if (placement === undefined)
-            return this.insertMeta(sessionId, null, undefined);
-        await createPlacedSessionRow(sessionId, placement, {
-            readFaces: (ids) => this.sourceFaces(ids),
-            insert: (owner) => this.insertMeta(sessionId, owner, placement),
-            readOwner: async () => (await this.headOf(sessionId))?.owner,
-        }, this.log);
-    }
-    async claimOwnerless(sessionId, incarnation, owner) {
-        const [res] = await this.pool.query(CLAIM_OWNERLESS_PLACED_SQL.mysql, [...claimOwnerlessParams(sessionId, incarnation, owner)]);
-        return res.affectedRows > 0;
-    }
-    async sourceFaces(ids) {
-        const [rows] = await this.pool.query(`SELECT session_id, owner, incarnation FROM session_meta WHERE session_id IN (${ids.map(() => "?").join(", ")})`, [...ids]);
-        return new Map(rows.map((r) => [String(r.session_id), sessionFaceFromRow(String(r.session_id), r.owner ?? null, r.incarnation)]));
+        await this.insertMeta(sessionId, placement === undefined ? null : placedSessionOwnerOf(sessionId, placement), placement);
     }
     async insertMeta(sessionId, owner, placement) {
         const now = new Date();

package/dist/plugins/tool-result-store-sql.d.ts

@@ -28,7 +28,6 @@ export declare function ensureSchema(pool: PgPool | PgPoolClient): Promise<void>
 export declare function assertToolResultProvenanceSchema(query: (sql: string) => Promise<{
     rows: Record<string, unknown>[];
 }>, dialect: SqlDialect): Promise<void>;
-/** Dual-dialect durable ToolResultStore. See the file header for the dialect-delta ledger. */
 export declare class SqlToolResultStore implements ToolResultStore {
     protected readonly db: SqlDriver;
     /** 托管留存声明 = 装配交给它的词(后端按扫车道开不开给;不给 ⇒ `"none"`)。读法与「为什么 SQL 店答 managed 而三方法的实现体在
@@ -73,14 +72,16 @@ export declare class SqlToolResultStore implements ToolResultStore {
         offset?: number;
         limit?: number;
     }): Promise<ToolResultSlice | undefined>;
-    /** TTL reap: delete results older than `cutoffMs`. Returns rows removed.
+    /** core `ToolResultStore.reap` (core 7.61.0 — the one age bound every backend reads): remove the results stored more than
+     *  `opts.maxAgeMs` before `now`. No bound ⇒ nothing removed; a bound that cannot be evaluated (`maxAgeMs` not a finite
+     *  number ≥ 0, `now` not a finite number) ⇒ refused, coded `config.retention_policy_invalid`, before any row is touched;
+     *  age alone decides (ownership is not consulted — the row and its owner columns go together). Returns rows removed.
      *  C6: a real DB error must NOT collapse into the same `0` a legitimate "nothing was old enough" returns —
-     *  those are different facts (query failed vs. query succeeded on an empty set) and folding them together
-     *  makes a stuck/broken reaper indistinguishable from a healthy quiet one. Matches every sibling reaper's
-     *  form (roster-store-sql.ts `reapOlderThan`, checkpoint-store-sql.ts `reapExpired`,
-     *  workflow-journal-store-sql.ts `reapExpired`): let the error propagate — the periodic-sweep call site
-     *  (boot/reapers.ts) already wraps this call in `.catch(() => undefined)` so the reap loop itself never dies. */
-    reapOlderThan(cutoffMs: number): Promise<number>;
+     *  those are different facts (query failed vs. query succeeded on an empty set). Let the error propagate — the
+     *  periodic-sweep call site (boot/reapers.ts) wraps this call in its throttled catch so the reap loop never dies. */
+    reap(now: number, opts?: {
+        maxAgeMs?: number;
+    }): Promise<number>;
     /**
      * E21 (§0.5 session delete) — purge offloaded tool results for one session. Selection is by the row's
      * **recorded provenance** (`owner_session_id`, the [ref] column `put` writes in the same statement as the

package/dist/plugins/tool-result-store-sql.js

@@ -55,6 +55,24 @@ export async function assertToolResultProvenanceSchema(query, dialect) {
             (await describeProbedTableDrift(query, dialect, ["tool_result"])));
     }
 }
+function toolResultAgeCutoff(now, opts) {
+    const refuse = (what, v) => {
+        throw Object.assign(new Error(`ToolResultStore.reap: ${what} must be a finite number${what === "maxAgeMs" ? " of milliseconds of 0 or more" : ""} (got ${typeof v === "string" ? JSON.stringify(v) : String(v)}) — a retention bound that cannot be evaluated is refused, never read as "no bound"`), {
+            code: "config.retention_policy_invalid",
+        });
+    };
+    if (opts !== undefined) {
+        for (const key of Object.keys(opts))
+            if (key !== "maxAgeMs")
+                refuse(`the bound "${key}" (only maxAgeMs is taken)`, opts[key]);
+    }
+    const maxAgeMs = opts?.maxAgeMs;
+    if (maxAgeMs !== undefined && (typeof maxAgeMs !== "number" || !Number.isFinite(maxAgeMs) || maxAgeMs < 0))
+        refuse("maxAgeMs", maxAgeMs);
+    if (typeof now !== "number" || !Number.isFinite(now))
+        refuse("now", now);
+    return maxAgeMs === undefined ? undefined : now - maxAgeMs;
+}
 export class SqlToolResultStore {
     db;
     retention;
@@ -126,8 +144,11 @@ export class SqlToolResultStore {
             return undefined;
         return { content: String(rows[0].slice ?? ""), offset, totalChars: Number(rows[0].total) };
     }
-    async reapOlderThan(cutoffMs) {
-        const { affected } = await this.db.query(this.q("DELETE FROM tool_result WHERE created_at < ?", "DELETE FROM tool_result WHERE created_at < $1"), [new Date(cutoffMs)]);
+    async reap(now, opts) {
+        const cutoff = toolResultAgeCutoff(now, opts);
+        if (cutoff === undefined)
+            return 0;
+        const { affected } = await this.db.query(this.q("DELETE FROM tool_result WHERE created_at < ?", "DELETE FROM tool_result WHERE created_at < $1"), [new Date(cutoff)]);
         return affected;
     }
     async deleteBySession(sessionId) {

package/dist/plugins/wiring-section-codec.d.ts

@@ -0,0 +1,32 @@
+/** 块引用的唯一键。 */
+export declare const WIRING_SECTION_REF_KEY = "$blob";
+/** 一只段体:摘要(`sha256:<64 hex>`)+ 段值本身(JSON 容器)。 */
+export interface WiringSectionBlob {
+    readonly digest: string;
+    readonly body: object;
+}
+/** {@link splitForStore} 的产物:要落账本的那一形 + 本帧引用到的段体(按摘要去重,首见为准)。 */
+export interface WiringSectionSplit {
+    readonly stored: unknown;
+    readonly blobs: readonly WiringSectionBlob[];
+}
+/** 装回失败的一段:段名 + 它的引用(引用值不是串时记 `<not-a-digest>`)。 */
+export interface UnresolvedWiringSection {
+    readonly section: string;
+    readonly digest: string;
+}
+/** {@link joinFromStore} 的结局:整帧,或至少一段装不回(永不交出缺段的帧)。 */
+export type WiringSectionJoin = {
+    readonly kind: "joined";
+    readonly data: unknown;
+} | {
+    readonly kind: "unresolved";
+    readonly missing: readonly UnresolvedWiringSection[];
+};
+/** 段体的店键:段体(一只 JSON 值)规范 JSON 的 sha256 全长。 */
+export declare function wiringSectionDigest(body: object): string;
+/** 写口:清单帧里 JSON 形是容器的段换成块引用(段体是那一段的 JSON 形,与原值不共享);别的型、或 `data` 不是对象 ⇒ 原样、零块。 */
+export declare function splitForStore(type: string, data: unknown): WiringSectionSplit;
+/** 读口:清单行里恰为单键 `$blob` 对象的顶层段换回段体;任一段在 `lookup` 里找不到 ⇒ `unresolved`(点名每一段)。 */
+export declare function joinFromStore(type: string, data: unknown, lookup: (digest: string) => object | undefined): WiringSectionJoin;
+//# sourceMappingURL=wiring-section-codec.d.ts.map

package/dist/plugins/wiring-section-codec.js

@@ -0,0 +1,55 @@
+import { createHash } from "node:crypto";
+import { canonicalJsonStringify } from "@sema-agent/core";
+export const WIRING_SECTION_REF_KEY = "$blob";
+const WIRING_MANIFEST = "wiring_manifest";
+const isRecord = (v) => typeof v === "object" && v !== null && !Array.isArray(v);
+export function wiringSectionDigest(body) {
+    return `sha256:${createHash("sha256").update(canonicalJsonStringify(body), "utf8").digest("hex")}`;
+}
+function jsonContainerOf(value) {
+    if (typeof value !== "object" || value === null)
+        return undefined;
+    const text = JSON.stringify(value);
+    if (text === undefined)
+        return undefined;
+    const body = JSON.parse(text);
+    return typeof body === "object" && body !== null ? body : undefined;
+}
+export function splitForStore(type, data) {
+    if (type !== WIRING_MANIFEST || !isRecord(data))
+        return { stored: data, blobs: [] };
+    const blobs = new Map();
+    const stored = Object.fromEntries(Object.entries(data).map(([section, value]) => {
+        const body = jsonContainerOf(value);
+        if (body === undefined)
+            return [section, value];
+        const digest = wiringSectionDigest(body);
+        if (!blobs.has(digest))
+            blobs.set(digest, body);
+        return [section, { [WIRING_SECTION_REF_KEY]: digest }];
+    }));
+    return { stored, blobs: [...blobs].map(([digest, body]) => ({ digest, body })) };
+}
+export function joinFromStore(type, data, lookup) {
+    if (type !== WIRING_MANIFEST || !isRecord(data))
+        return { kind: "joined", data };
+    let refs = 0;
+    const missing = [];
+    const entries = Object.entries(data).map(([section, value]) => {
+        if (!isRecord(value))
+            return [section, value];
+        const keys = Object.keys(value);
+        if (keys.length !== 1 || keys[0] !== WIRING_SECTION_REF_KEY)
+            return [section, value];
+        refs += 1;
+        const ref = value[WIRING_SECTION_REF_KEY];
+        const body = typeof ref === "string" ? lookup(ref) : undefined;
+        if (body === undefined)
+            missing.push({ section, digest: typeof ref === "string" ? ref : "<not-a-digest>" });
+        return [section, body ?? value];
+    });
+    if (missing.length > 0)
+        return { kind: "unresolved", missing };
+    return { kind: "joined", data: refs === 0 ? data : Object.fromEntries(entries) };
+}
+//# sourceMappingURL=wiring-section-codec.js.map

package/dist/plugins/workspace-fill.d.ts

@@ -27,7 +27,7 @@ export interface WorkspaceChannel {
     run(command: string): Promise<ChannelRun>;
     write(absPath: string, bytes: Uint8Array): Promise<ChannelWrite>;
 }
-/** 恢复点交出的工作区从哪来:`minted` = 车道刚铸出的新工作区(没有可恢复的树 —— 含恢复的归档不在:`latest` 悬空、停驻快照从未物化);`restored` = 恢复出来的(空间 `latest` / 停驻快照的树真回来了)。 */
+/** 恢复点交出的工作区从哪来:`minted` = 车道刚铸出的新工作区(没有可恢复的树 —— 含恢复点指的归档不在:`latest` 悬空、停驻快照的归档不在);`restored` = 恢复出来的(空间 `latest` / 停驻快照的树真回来了)。 */
 export type WorkspaceOrigin = "minted" | "restored";
 /** 一次填充的结局。`standing` = 这只执行环境此后每一次恢复点都会得到同一个答(适配器把它记成这只环境的拒,不再建机器)。 */
 export type FillOutcome = {

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

@@ -2,11 +2,12 @@
  * **规则条目表在本仓受理口的判** —— 一份,四张表同调(core 7.42.0 起「这个调用不用问」只有一个去处:引擎的 allow 层;条目的文法、匹配、
  * 名字、读成空的通告都归引擎,本仓不写第二套):
  *  · 请求自带技能的 `allowedTools` / `disallowedTools`(顶层 `skills[]` 与子代 `agents[].skills[]` 两处受理口,`spec-fields.ts` / `http/admission.ts`);
- *  · 请求的 `settings.permissions.allow`(整份原样投 `TaskSpec.allowedTools`,`task-settings.ts`);
+ *  · 请求的 `settings.permissions.allow`(整份按位置投 `TaskSpec.allowedTools`,`task-settings.ts`;条目也可以是设置层的 `{ rule, layer }`,本文件按它的规则原文读,层只选锚);
  *  · 运维的 `APPROVAL_GRANT`(整份投 `RunnerDeps.allowedTools`,`config.ts` 启动校验)。
  *
  * 本仓在这些表上只剩下面几问(内容形、`*`、写路径形、名字引擎怎么读就怎么算):
- *  ① **形**({@link ruleEntryListShapeOk}):字符串数组。引擎逐条迭代;一个裸字符串会被逐字符读成几条(deny 侧 = 意图静默落空)。
+ *  ① **形**({@link ruleEntryListShapeOk}):字符串数组。引擎逐条迭代;一个裸字符串会被逐字符读成几条(deny 侧 = 意图静默落空)。请求的 allow 桶的形另由桶门判
+ *     (`task-settings.ts` 的 `settingsPermissionBucketIssue`:串或带层条目),它进下面 ③ 时带层条目读成规则原文({@link toolListsOf})。
  *     本谓词不带条数帽(引擎的 `screenAllowedToolsValue` 只判形);条数帽是另一只函数 {@link allowLayerEntryCountIssue}(`MAX_ALLOW_LAYER_ENTRIES`,
  *     请求 allow 桶、技能两只清单、运维表四张表同一只、同一句)。
  *  ② (7.116.0–7.122.x 的「引擎读不到的一形」—— 工具段为空的协议名 `mcp__srv__` 四张表都拒 —— 随 core 7.48.0 [ref] 退役:引擎判官给它判词

package/dist/rule-entry-list.js

@@ -3,6 +3,7 @@ import { displayListEntry } from "./list-entry-display.js";
 import { limitRefusal } from "./limit-refusal.js";
 import { TOOL_NAME_ROSTER } from "./namespaced-rule-name.js";
 import { NOT_IN_ROSTER, entryProblem, entryProblemsFacts } from "./entry-problems.js";
+import { layeredRuleOk } from "./permission-rule-list.js";
 export const ruleEntryListShapeOk = (v) => Array.isArray(v) && v.every((x) => typeof x === "string");
 export const MAX_ALLOW_LAYER_ENTRIES = 1_000;
 const ALLOW_LAYER_OVER_CAP_TAIL = "Refused rather than truncated: a truncated list silently drops the entries past the cap. Merge entries into broader ones (mcp__<server>__*, Bash(<prefix>:*), Read(//<dir>/**)) or trim the list";
@@ -162,7 +163,10 @@ function* toolListsOf(body) {
     const settings = body["settings"];
     const permissions = isPlainRecord(settings) ? settings["permissions"] : undefined;
     if (isPlainRecord(permissions))
-        yield { layer: "settings.permissions.allow", field: "settings.permissions.allow", prefix: "", at: "settings.permissions.allow", list: permissions["allow"] };
+        yield { layer: "settings.permissions.allow", field: "settings.permissions.allow", prefix: "", at: "settings.permissions.allow", list: ruleTextsOfBucket(permissions["allow"]) };
+}
+function ruleTextsOfBucket(list) {
+    return Array.isArray(list) ? list.map((x) => (layeredRuleOk(x) ? x.rule : x)) : list;
 }
 function inertReadingOfList(l) {
     const face = TOOL_LIST_FACES[l.layer];

package/dist/rules-consent.d.ts

@@ -219,16 +219,24 @@ export type LocalImportIndeterminateCode =
 /** 兑付走本身没走完(本层抛出/中断)⇒ 这一条连走都没走到。 */
  | "walk_failed";
 /** prepare 面的一行。判别式联合:被收下的行**没有**拒因字段可读,被拒的行**必然**带拒因 ——
- *  「admitted 却带 reason」这种矛盾态在类型上不可表达。 */
+ *  「admitted 却带 reason」这种矛盾态在类型上不可表达。
+ *  收下的**收紧**(deny / ask)在 prepare 当场经直写接缝落店,行带它的结局 `outcome`(`persisted` = 这次写了 / `no-op` = 等价规则已在店);
+ *  收下的**放行**没有 `outcome` —— 它的结局在 redeem 回执里(放行要同意,收紧不等同意;见 `prepareLocalImport`)。 */
 export type LocalImportPreviewMember = {
     key: LocalImportRuleKey;
     admitted: true;
+} | {
+    key: LocalImportRuleKey;
+    admitted: true;
+    outcome: LocalImportTighteningOutcome;
 } | {
     key: LocalImportRuleKey;
     admitted: false;
     reason: LocalImportRefusalCode;
     detail: string;
 };
+/** 一条收紧在 prepare 当场落店的结局(与兑付回执的 `persisted` / `no-op` 同词同义;直写接缝 `addPersistedRule` 的 `added` / `no-op`)。 */
+export type LocalImportTighteningOutcome = "persisted" | "no-op";
 /** 兑付回执的一行。 */
 export interface LocalImportOutcomeMember {
     key: LocalImportRuleKey;
@@ -266,6 +274,14 @@ export type LocalImportPrepared = {
     ok: false;
     reason: "batch-too-large";
     bytes: number;
+}
+/** 一条收紧写不进店(直写接缝答 `failed`)⇒ 这一批的放行全部扣下(不铸记录、不铸票)。`committed` 原样是 core 的两词闭集,
+ *  wire 上与 `POST /v1/rules` 的写失败同一码同一键;此前已落的收紧留着(收紧方向),同一批重发即幂等(已落的答 `no-op`)。 */
+ | {
+    ok: false;
+    reason: "tightening-write-failed";
+    committed: RuleWriteCommitted;
+    detail: string;
 };
 /** A7 redeem 的结果。 */
 export type LocalImportRedeemed = 
@@ -456,13 +472,20 @@ export type CardRulePersisted = {
      *  🔴 不 switch、不翻译、不折叠:词表属主是 core,本仓照转。 */
     code?: string;
 };
-/** 一层用户交上来的 settings(HTTP 载荷已 zod 校验过的形)。 */
-export interface RuleImportLayerInput {
-    layer: ImportedSettingsLayer;
+/**
+ * 一层用户交上来的 settings(HTTP 载荷已 zod 校验过的形)—— 按 `layer` 的联合,与引擎的 `CcImportLayer` 同形:
+ * 用户层**没有** `root`(它的 `/x` 在它自己的配置目录读,引擎不把它带进店;交了 root 的体在边界 400),项目层与本地层带 `root`(规则的作用域根)。
+ */
+export type RuleImportLayerInput = {
+    layer: "userSettings";
+    path: string;
+    content: string;
+} | {
+    layer: Exclude<ImportedSettingsLayer, "userSettings">;
     path: string;
     root: string;
     content: string;
-}
+};
 /**
  * scope 的 **wire 形**:`global` | `project:<root>` 的判别式串([ref] v2 §6 F5「显式成文」)。
  *

package/dist/rules-consent.js

@@ -232,25 +232,14 @@ function buildLocalImportLayers(candidates) {
     const byRoot = new Map();
     for (const c of candidates) {
         const key = c.scope.kind === "global" ? "" : c.scope.root;
-        let bucket = byRoot.get(key);
-        if (bucket === undefined) {
-            bucket = { deny: [], ask: [], allow: [] };
-            byRoot.set(key, bucket);
-        }
-        bucket[c.behavior].push(c.rule);
+        const bucket = byRoot.get(key) ?? [];
+        bucket.push(c.rule);
+        byRoot.set(key, bucket);
     }
-    return [...byRoot].map(([root, lists]) => ({
-        layer: root === "" ? "userSettings" : "projectSettings",
-        path: root === "" ? LOCAL_IMPORT_LAYER_PATH : `${LOCAL_IMPORT_LAYER_PATH}:${root}`,
-        root: root === "" ? "/" : root,
-        readFile: async () => JSON.stringify({
-            permissions: {
-                ...(lists.deny.length > 0 ? { deny: lists.deny } : {}),
-                ...(lists.ask.length > 0 ? { ask: lists.ask } : {}),
-                ...(lists.allow.length > 0 ? { allow: lists.allow } : {}),
-            },
-        }),
-    }));
+    return [...byRoot].map(([root, allow]) => {
+        const readFile = async () => JSON.stringify({ permissions: { allow } });
+        return root === "" ? { layer: "userSettings", path: LOCAL_IMPORT_LAYER_PATH, readFile } : { layer: "projectSettings", path: `${LOCAL_IMPORT_LAYER_PATH}:${root}`, root, readFile };
+    });
 }
 function buildLocalImportMembers(members) {
     return members.map((m) => {
@@ -367,12 +356,10 @@ export function createRuleConsentLane(stores, opts) {
             return { ok: true, kind: "single", rule: redeemed.rule, rev: redeemed.rev, alreadyRedeemed: redeemed.alreadyRedeemed };
         },
         async prepareImport(principal, layers) {
-            const ccLayers = layers.map((l) => ({
-                layer: l.layer,
-                path: l.path,
-                root: l.root,
-                readFile: async () => l.content,
-            }));
+            const ccLayers = layers.map((l) => {
+                const readFile = async () => l.content;
+                return l.layer === "userSettings" ? { layer: l.layer, path: l.path, readFile } : { layer: l.layer, path: l.path, root: l.root, readFile };
+            });
             const { preview, approvalId } = await prepareCcImport({ layers: ccLayers, principal, deps });
             if (approvalId === undefined) {
                 return { ok: true, preview };
@@ -494,16 +481,41 @@ export function createRuleConsentLane(stores, opts) {
                     continue;
                 }
                 seen.add(dedupKey);
+                admitted.push({ at: members.length, row: screened });
                 members.push({ key, admitted: true });
-                admitted.push(screened);
             }
-            if (admitted.length === 0)
+            const allows = [];
+            for (const { at, row: c } of admitted) {
+                const key = members[at].key;
+                const behavior = c.behavior;
+                if (!isDirectWritableRuleBehavior(behavior)) {
+                    allows.push({ ...c, behavior });
+                    continue;
+                }
+                const added = await addPersistedRule({ behavior, rule: c.rule, scope: c.scope, principal, provider: stores.provider });
+                switch (added.status) {
+                    case "added":
+                        members[at] = { key, admitted: true, outcome: "persisted" };
+                        break;
+                    case "no-op":
+                        members[at] = { key, admitted: true, outcome: "no-op" };
+                        break;
+                    case "failed":
+                        localImportLogger.warn("local_import_tightening_write_failed", { behavior, scope: key.scope, committed: added.committed, note: "a deny / ask of this batch did not land — the batch's allows are withheld (no import record, no ticket); sending the same batch again is idempotent" });
+                        return { ok: false, reason: "tightening-write-failed", committed: added.committed, detail: added.error };
+                    default: {
+                        const unknown = added;
+                        throw new Error(`unknown addPersistedRule outcome: ${JSON.stringify(unknown)}`);
+                    }
+                }
+            }
+            if (allows.length === 0)
                 return { ok: true, preview: { members } };
-            const { preview, approvalId } = await prepareCcImport({ layers: buildLocalImportLayers(admitted), principal, deps });
+            const { preview, approvalId } = await prepareCcImport({ layers: buildLocalImportLayers(allows), principal, deps });
             const engineKeys = new Set(preview.candidates.map((c) => `${c.behavior}${LOCAL_IMPORT_KEY_SEP}${serializeRuleScope(c.scope)}${LOCAL_IMPORT_KEY_SEP}${c.rule}`));
             for (let i = 0; i < members.length; i++) {
                 const m = members[i];
-                if (m === undefined || !m.admitted)
+                if (m === undefined || !m.admitted || "outcome" in m)
                     continue;
                 if (engineKeys.has(`${m.key.behavior}${LOCAL_IMPORT_KEY_SEP}${m.key.scope}${LOCAL_IMPORT_KEY_SEP}${m.key.rule}`))
                     continue;