@sema-agent/server 7.103.2 → 7.105.0

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

@@ -5,6 +5,7 @@ import { jsonColumnText } from "./sql-json-column.js";
 import { escapeLike } from "./sql-escape.js";
 import { BASELINE_IO_DEADLINE_MS, decodeInstructionSource, encodeInstructionSource } from "../instruction-source-notice.js";
 import { MANAGED_RETENTION } from "./retention-store-sql.js";
+import { carriedIncarnation, mintSessionIncarnation, sessionFaceFromRow } from "../session-incarnation.js";
 import { contentForkRelation, fastForwardSharedContentDiverged } from "../session-sync-content.js";
 import { assertPlacementAdmission, LIST_PLACED_BATCH, PLACEMENT_SELECT_COLUMNS, placedRowFromRow, placementFromRow, placementInsertValues, SQL_SESSION_PLACEMENTS, } from "./session-placement.js";
 import { classifySyncRelationshipByIds, SyncConflictError, stagingIdFor, STAGING_ID_MARKER, STAGING_GC_GRACE_MS, } from "../session-sync-kernel.js";
@@ -52,9 +53,9 @@ export class TiDBSessionStore {
     }
     async register(sessionId, owner, placement) {
         const now = new Date();
-        await this.pool.query("INSERT INTO session_meta (session_id, owner, created_at, updated_at, leaf_id, leaf_seq, " +
+        await this.pool.query("INSERT INTO session_meta (session_id, owner, created_at, updated_at, leaf_id, leaf_seq, incarnation, " +
             "placement_kind, placement_scope, placement_parent_session_id, placement_root_session_id, placement_handle, placed_at) " +
-            "VALUES (?,?,?,?,NULL,0,?,?,?,?,?,?) ON DUPLICATE KEY UPDATE session_id = session_id", [sessionId, owner, now, now, ...placementInsertValues(placement, now)]);
+            "VALUES (?,?,?,?,NULL,0,?,?,?,?,?,?,?) ON DUPLICATE KEY UPDATE session_id = session_id", [sessionId, owner, now, now, mintSessionIncarnation(), ...placementInsertValues(placement, now)]);
     }
     async placementOf(sessionId) {
         const [rows] = await this.pool.query(`SELECT ${PLACEMENT_SELECT_COLUMNS} FROM session_meta WHERE session_id = ?`, [sessionId]);
@@ -82,6 +83,12 @@ export class TiDBSessionStore {
             return undefined;
         return rows[0].owner ?? null;
     }
+    async sessionFaceOf(sessionId) {
+        const [rows] = await this.pool.query("SELECT owner, incarnation FROM session_meta WHERE session_id = ?", [sessionId]);
+        if (rows.length === 0)
+            return undefined;
+        return sessionFaceFromRow(sessionId, rows[0].owner ?? null, rows[0].incarnation);
+    }
     async touch(sessionId) {
         await this.pool.query("UPDATE session_meta SET updated_at = ? WHERE session_id = ?", [
             new Date(),
@@ -213,7 +220,7 @@ export class TiDBSessionStore {
                 const payload = String(r.payload);
                 await conn.query("INSERT INTO session_event (session_id, seq, entry_id, parent_id, type, payload, ts) VALUES (?,?,?,?,?,?,?)", [newId, seq, r.entry_id, r.parent_id ?? null, r.type, payload, r.ts]);
             }
-            await conn.query("INSERT INTO session_meta (session_id, owner, created_at, updated_at, leaf_id, leaf_seq) VALUES (?,?,?,?,?,?)", [newId, owner, now, now, leafId, eventRows.length]);
+            await conn.query("INSERT INTO session_meta (session_id, owner, created_at, updated_at, leaf_id, leaf_seq, incarnation) VALUES (?,?,?,?,?,?,?)", [newId, owner, now, now, leafId, eventRows.length, mintSessionIncarnation()]);
             await conn.commit();
             return newId;
         }
@@ -267,7 +274,7 @@ export class TiDBSessionStore {
         const conn = await this.pool.getConnection();
         try {
             await conn.beginTransaction();
-            await this.insertValidatedLog(conn, sessionId, owner, validated);
+            await this.insertValidatedLog(conn, sessionId, owner, validated, mintSessionIncarnation());
             await conn.commit();
         }
         catch (err) {
@@ -290,14 +297,14 @@ export class TiDBSessionStore {
         const conn = await this.pool.getConnection();
         try {
             await conn.beginTransaction();
-            const [placedRows] = await conn.query("SELECT placement_kind FROM session_meta WHERE session_id = ? FOR UPDATE", [sessionId]);
+            const [placedRows] = await conn.query("SELECT placement_kind, owner, incarnation FROM session_meta WHERE session_id = ? FOR UPDATE", [sessionId]);
             if (placedRows[0]?.placement_kind != null) {
                 await conn.rollback();
                 throw new SessionError("placement_refused", `session ${sessionId} belongs to the ${String(placedRows[0].placement_kind)} placement partition — a session-sync replace cannot overwrite a delegation transcript`);
             }
             await conn.query("DELETE FROM session_event WHERE session_id = ?", [sessionId]);
             await conn.query("DELETE FROM session_meta WHERE session_id = ? AND owner <=> ? AND placement_kind IS NULL", [sessionId, owner]);
-            await this.insertValidatedLog(conn, sessionId, owner, validated);
+            await this.insertValidatedLog(conn, sessionId, owner, validated, carriedIncarnation(placedRows[0] === undefined ? undefined : { owner: placedRows[0].owner, incarnation: placedRows[0].incarnation }, owner));
             await conn.commit();
         }
         catch (err) {
@@ -314,7 +321,7 @@ export class TiDBSessionStore {
             conn.release();
         }
     }
-    async insertValidatedLog(conn, sessionId, owner, validated) {
+    async insertValidatedLog(conn, sessionId, owner, validated, incarnation) {
         let leafId = null;
         for (const e of validated)
             leafId = leafIdAfterEntry(e);
@@ -323,7 +330,7 @@ export class TiDBSessionStore {
             const e = validated[seq];
             await conn.query("INSERT INTO session_event (session_id, seq, entry_id, parent_id, type, payload, ts) VALUES (?,?,?,?,?,?,?)", [sessionId, seq, e.id, e.parentId ?? null, e.type, JSON.stringify(e), new Date(e.timestamp)]);
         }
-        await conn.query("INSERT INTO session_meta (session_id, owner, created_at, updated_at, leaf_id, leaf_seq) VALUES (?,?,?,?,?,?)", [sessionId, owner, now, now, leafId, validated.length]);
+        await conn.query("INSERT INTO session_meta (session_id, owner, created_at, updated_at, leaf_id, leaf_seq, incarnation) VALUES (?,?,?,?,?,?,?)", [sessionId, owner, now, now, leafId, validated.length, incarnation]);
     }
     beginImportStaging(realSessionId, token) {
         return new TiDBStagingHandle(this.pool, realSessionId, stagingIdFor(realSessionId, token));
@@ -450,8 +457,8 @@ class TiDBStagingHandle {
             if (lastRow[0])
                 leafId = leafIdAfterEntry(decodeSessionEventPayload(lastRow[0].payload, this.realSessionId, "last staged row"));
             const now = new Date();
-            await conn.query("INSERT INTO session_meta (session_id, owner, created_at, updated_at, leaf_id, leaf_seq) VALUES (?,?,?,?,?,?) " +
-                "ON DUPLICATE KEY UPDATE owner = VALUES(owner), updated_at = VALUES(updated_at), leaf_id = VALUES(leaf_id), leaf_seq = VALUES(leaf_seq)", [this.realSessionId, owner, now, now, leafId, srcIds.length]);
+            await conn.query("INSERT INTO session_meta (session_id, owner, created_at, updated_at, leaf_id, leaf_seq, incarnation) VALUES (?,?,?,?,?,?,?) " +
+                "ON DUPLICATE KEY UPDATE owner = VALUES(owner), updated_at = VALUES(updated_at), leaf_id = VALUES(leaf_id), leaf_seq = VALUES(leaf_seq)", [this.realSessionId, owner, now, now, leafId, srcIds.length, mintSessionIncarnation()]);
             const [afterMeta] = await conn.query("SELECT placement_kind FROM session_meta WHERE session_id = ?", [this.realSessionId]);
             if (afterMeta[0]?.placement_kind != null) {
                 await conn.rollback();

package/dist/project-identity.d.ts

@@ -1,10 +1,8 @@
-import type { TaskSpec } from "@sema-agent/core";
-/** core 的项目身份声明席(`TaskSpec.memory.projectKey`)—— 从 core 类型派生,不另写一份。 */
-export type MemoryProjectKey = NonNullable<NonNullable<TaskSpec["memory"]>["projectKey"]>;
+import type { MemoryProjectKey, MemoryProjectKeyAbsentReason } from "@sema-agent/core";
+/** core 的项目身份声明席(`TaskSpec.memory.projectKey`)—— core 包根导出的型,原样转出(本仓调用方从这里取)。 */
+export type { MemoryProjectKey };
 /** 本仓会说的缺席词。`not_git` 刻意排除:裁 D 起非 git 目录按目录键控,不是缺席(core 闭集仍收它,本仓不铸)。 */
-export type ProjectIdentityAbsentReason = Exclude<Extract<MemoryProjectKey, {
-    absent: unknown;
-}>["absent"], "not_git">;
+export type ProjectIdentityAbsentReason = Exclude<MemoryProjectKeyAbsentReason, "not_git">;
 /** 一个任务根的项目身份:canonical 项目根,或说得出理由的缺席。 */
 export type ProjectIdentity = {
     readonly root: string;

package/dist/read-face-posture.d.ts

@@ -65,4 +65,25 @@ export declare function buildReadFaceWiring(facts: ReadFacePostureFacts): {
     source: ReadFaceSource;
     note: string;
 };
+/**
+ * S-176 —— posture 派生的档位在 **boot 期推送面**的那一行(`config.ts` 经既有 `CONFIG_NOTICES` 以 info 级排空)。
+ *
+ * 为什么要有:S-167 的补偿项是「升级即放开,得让运维看得见并知道怎么钉回」,可此前唯一看得见的是**拉取**面
+ * (`GET /v1/diagnostics/wiring`)—— 只对会去拉的人成立。单机 boot 日志里零字。
+ * 为什么只在 `posture` 一词上说:另外三词都不是「没人表态、服务替它选了一个更宽的档」——`env` 是运维自己写的,
+ * `engine-default` 是本服务没铸(引擎默认接管),`center` 在 boot 这一拍还没到货(它有自己的换席通告)。
+ * 为什么是 info 不是 warn:每一台照常配置的单机每次启动都成立,是常态事实不是异常(与执行车道落点同级)。
+ *
+ * 字段与极性表的 posture 行同名(`knob` / `value` / `source`),另带指路句;三格由 {@link buildReadFaceWiring} 投影出 ——
+ * 拉取面与推送面**同一只函数**,不各算一次。`value` 是字符串:只有 `face` 在场的那一形才会走到这里。
+ */
+export declare function buildReadFacePostureNotice(facts: ReadFacePostureFacts): {
+    event: "config_knob_posture_derived";
+    fields: {
+        knob: "READ_FACE";
+        value: string;
+        source: ReadFaceSource;
+        note: string;
+    };
+} | undefined;
 //# sourceMappingURL=read-face-posture.d.ts.map

package/dist/read-face-posture.js

@@ -14,4 +14,13 @@ export function readFaceSourceNote(source) {
 export function buildReadFaceWiring(facts) {
     return { face: facts.readFace ?? null, source: facts.readFaceSource, note: readFaceSourceNote(facts.readFaceSource) };
 }
+export function buildReadFacePostureNotice(facts) {
+    if (facts.readFaceSource !== "posture")
+        return undefined;
+    const wiring = buildReadFaceWiring(facts);
+    if (wiring.face === null) {
+        throw new Error("read-face posture notice: source is `posture` but no face was minted — readFaceForPosture's invariant broke");
+    }
+    return { event: "config_knob_posture_derived", fields: { knob: "READ_FACE", value: wiring.face, source: wiring.source, note: wiring.note } };
+}
 //# sourceMappingURL=read-face-posture.js.map

package/dist/request-key-closure.js

@@ -21,7 +21,7 @@ const TASK_BODY_DECLARED_KEYS = [
     "a2aPeers", "acceptPartialRestore", "additionalDirectories", "additionalReadDirectories", "agents",
     "appendSystemPrompt", "approverPosture", "attachmentIds", "attachments", "capabilitiesNeeded", "cascade", "clientContext",
     "compaction", "compactionModel", "council", "cwd", "debate", "deferTools", "deviceId", "enableFork",
-    "excludeAllTools", "excludeTools",
+    "excludeAllTools", "excludeTools", "fileHistory",
     "finalVerification", "forwardSubagentEvents", "images", "interactiveTools", "jobId", "limits", "maxCostUsd",
     "maxTokens", "mcpServers", "memory", "memoryCapture", "memoryWrite", "model", "objective", "oneShot", "outputRetries",
     "outputSchema", "permissionMode", "projectId", "promptProfile", "reasoningEffort", "requireExistingSession",

package/dist/request-value-closure.d.ts

@@ -1,21 +1,90 @@
+/**
+ * 提交体的**值闭集门** —— `request-key-closure.ts`(键名闭集)的姊妹,同一条纪律的另一半。
+ *
+ * ## 这里解决的是哪一类病
+ *
+ * 键名对了、**值**拼错了:`memoryCapture: "OFF"`、`memory: "on"`、`memory: true`、`fileHistory: "off"`。这一族键有一个
+ * 共同的形 —— **单成员闭集的关断词**:合法值只有**一个**关断拼法(记忆族是 `"off"`;core 在 `fileHistory` /
+ * `checkpointStore` 上的拼法是 `"disabled"`),「开」的拼法**刻意不存在**(缺席就是「照常」的唯一形,声明只能单向收紧)。
+ * 于是坏值有且只有一种正确处置:**响亮拒**。按 truthiness 读成任一态都是灾难的一半 ——
+ * 一个敲错的隐私/收紧请求被静默丢掉(用户以为关了,其实没关),或者一个敲错的键把功能静默关掉。
+ *
+ * 🔴 **判别是「值域恰好是一个关断词」,不是「值域恰好是一个字面量」**(S-724 加 `fileHistory` 时定形):
+ * `approverPosture` 的值域也只有一个词(`"bypass"`),但它是一句**姿态声明**、闭集属主在 core、本仓刻意**零判据**
+ * (`http/wire-types.ts` 那一段逐字成文);把判别放宽成「单字面量」会把它也拖进本表 = 同一语义面第二个判官。
+ * 关断词全集 {@link OffSwitchWord} 是 core 的两种关断拼法,新增第三种拼法 = 加一个词(并逐键重判)。
+ *
+ * ## 为什么是一只判据函数,不是每处一抄
+ *
+ * 这道门必须落在**两腿**上:fresh 提交的 HTTP admission(400 `request.field_invalid`)与 **resume 重放**
+ * 共用的解析路径(`boot/resolve-spec.ts`;从这里逃出的 `HttpError` 被 `http/resume-legs.ts` 折成 409
+ * `resume_blocked_by_policy`(带 `blockedBy: e.code`)= 一个 typed 的「续跑被挡」,比静默放行诚实 —— 亲读
+ * `resume-legs.ts:776` / `:2366`,**不是**邻处旧注说的 `server.ts`,那句是切片搬家后的陈旧指路)。
+ * ⚠️ 本族**刻意不**照抄「fresh fail-loud / resume 宽容降级」那条双层姿势(`settings` / `outputStyle` /
+ * `permissionMode` 走的是它):那三处降级的是配置/名单类的**可恢复量**,而把一条收紧声明按打字错误折成缺席是
+ * **不可逆方向**的静默降级 —— 一条旧 worker 持久化的 `memoryCapture:'OFF'` 会在 resume 时静默恢复采集。
+ *
+ * 两腿各抄一份判据 + 一份文案,就是同一条 wire 语义上的**两个写者**;`memoryCapture` 从 [ref] 起正是这么长的
+ * (`http/admission.ts` 与 `boot/resolve-spec.ts` 各一份逐字手抄的 150 字文案)。S-405 给这一族添第二个键
+ * (`memory`)时把它收成**一张表、一只判据、一处文案属主**:新增一个同形键 = 加一行,而不是四处改。
+ * S-724 加第三个键 `fileHistory` 正是这么加的 —— 一行(带它自己的关断词),零处改判据。
+ * 文案的冻结职责随之从「桶扫描」搬到 `test/api-error-text-freeze.test.ts` 的常量锚格(与 `RUN_NOT_FOUND_MESSAGE` /
+ * `PERSIST_RULE_*` 两格同形、同理由)。
+ *
+ * ## 边界(与姊妹门同律)
+ *
+ *  · 只判**本表登记的键**的值形;别的值形校验归各自既有的门,本门零抢话。
+ *    唯一的跨键句:`fileHistory` 关断词与还原同体({@link FILE_HISTORY_DISABLED_NO_RESTORE}),文案属主随关断词住在这里,
+ *    只在 fresh 受理门执行(理由在那一格)。
+ *  · 只判**值**,不判键名(键名闭集是 `request-key-closure.ts` 的活)。
+ *  · 体本身非对象 ⇒ 本门不判(留给「missing 'objective' string」那道根形门,免得一个体被两句话抢答)。
+ */
+import type { TaskRequestBody } from "./http/wire-types.js";
 /** [ref] §2.1([ref]):`memoryCapture` 的拼写门文案。**wire 可见文本** —— 改一个字就是对端契约漂移
  *  (SDK/壳/文档锚它),字节冻结在 `test/api-error-text-freeze.test.ts` 的常量锚格。 */
 export declare const MEMORY_CAPTURE_SPELLING_MESSAGE = "memoryCapture must be the string 'off' when present (the session-level memory-capture opt-out declaration; absent = capture as usual \u2014 there is no 'on' spelling)";
 /** core [ref] r5 §5 W3(S-405):请求级「记忆整面关」`memory` 的拼写门文案。同上,wire 可见、字节冻结。
  *  文案刻意点明 capture 的分工 —— 两个键都在记忆轴上、形又一模一样,拿错的人要在同一条回执里读到该用哪个。 */
 export declare const MEMORY_OFF_SPELLING_MESSAGE = "memory must be the string 'off' when present (the request-level declaration that this run mounts no memory face at all; absent = memory as usual \u2014 there is no 'on' spelling; to keep memory mounted but stop this session's content from entering long-term memory, send memoryCapture: 'off' instead)";
+/** S-724(core 7.31.0 #1048):请求级「文件历史关断」`fileHistory` 的拼写门文案。同上,wire 可见、字节冻结。
+ *  唯一词是 core 的拼法 `'disabled'`(与 `checkpointStore` 同),**不是**记忆族的 `'off'` —— 句子点名它,
+ *  顺带说清同一提交里不能再要还原(那一对的拒句是下面的 {@link FILE_HISTORY_DISABLED_NO_RESTORE})。 */
+export declare const FILE_HISTORY_OFF_SPELLING_MESSAGE = "fileHistory must be the string 'disabled' when present (the request-level declaration that this run records no file history \u2014 no backup of an edited file, and no file restore in the same request; absent = the deployment's setting \u2014 there is no 'enabled' spelling)";
+/**
+ * S-724 b′(主会话裁,车PW codex r1 [high] 复现后)—— `fileHistory: "disabled"` 与还原**同体**的拒句(`request.field_conflict`)。
+ * 与 `tool-approval.ts` 的 `SETTLED_BY_DENY_ONLY` / `READ_ROOT_GRANT_ALLOW_ONLY` **同一族**:「只看体就能判的矛盾,在裁决之前响亮说」。
+ * 这一对是调用方自己写出的矛盾(关掉这条 run 的文件历史,又要从文件历史还原);core 也拒(`rewind.capture_disabled`),但它的拒
+ * 落在 prepare 的**会话分叉之后**(`prepare-acquire-reconcile` 先按 `resumeAt` 把活动分支移过去,`prepare-file-history` 才判),
+ * 且拒后不回滚 —— 拒传不回来。所以本层在任何副作用之前拒。**这不是替 core 再判一次「捕获关了能不能还原」**:判的是体里两个键
+ * 能不能共存,不看部署、不看店。
+ * 判据:{@link fileHistoryRestoreConflict}。**只在 fresh 受理门**(`http/admission.ts`);续跑腿不过这道门(RESUME 重放不过受理门,
+ * 同律 —— 且续跑腿重建时整族剥掉一次性历史动作,矛盾在盘上的体里本就留不下来)。wire 可见、字节冻结。
+ */
+export declare const FILE_HISTORY_DISABLED_NO_RESTORE = "fileHistory: 'disabled' cannot ride with a file restore (restoreFiles, rewindFilesTo, or the retired rewindFiles) \u2014 the request turns this run's file history off and asks to restore files from it in the same breath; the engine would refuse it (rewind.capture_disabled) only after the session had already been branched at resumeAt, which it does not undo, so it is refused here, before any side effect. Drop fileHistory to restore, or drop the restore to run without file history";
 /**
- * **单成员闭集键表** —— 合法值只有 `"off"`,缺席=照常,没有 `"on"`。
+ * 「关断词 ∧ 还原」这一对的判据(纯函数,只看体)。还原 = 三个键里任一个在请求:`restoreFiles: true`、非空串 `rewindFilesTo`
+ * (与 `boot/resolve-spec.ts` 的读法同:空串 / 非串按缺席)、退役拼法 `rewindFiles: true`(restore 义要一次还原;capture 义要的
+ * 正是这个词关掉的记录 —— 两义都与关断词矛盾)。调用前值形已由上面的单成员表与既有布尔门判过。
+ */
+export declare function fileHistoryRestoreConflict(body: Pick<TaskRequestBody, "fileHistory" | "restoreFiles" | "rewindFiles" | "rewindFilesTo">): boolean;
+/**
+ * **单成员闭集键表** —— 每键合法值只有它自己那一个关断词(`word`),缺席=照常,没有「开」的拼法。
  *
- * 🔴 顺序 = **裁决顺序**,且是**既存键在前**:一个两键都畸形的存量体,判决与加 `memory` 之前逐字节相同
+ * 🔴 顺序 = **裁决顺序**,且是**既存键在前**:一个多键都畸形的存量体,判决与加新键之前逐字节相同
  * (新键不许改写既有体的回执)。新增同形键一律**追加在尾部**。
  */
 declare const SINGLE_MEMBER_OFF_FIELDS: readonly [{
     readonly field: "memoryCapture";
+    readonly word: "off";
     readonly message: "memoryCapture must be the string 'off' when present (the session-level memory-capture opt-out declaration; absent = capture as usual — there is no 'on' spelling)";
 }, {
     readonly field: "memory";
+    readonly word: "off";
     readonly message: "memory must be the string 'off' when present (the request-level declaration that this run mounts no memory face at all; absent = memory as usual — there is no 'on' spelling; to keep memory mounted but stop this session's content from entering long-term memory, send memoryCapture: 'off' instead)";
+}, {
+    readonly field: "fileHistory";
+    readonly word: "disabled";
+    readonly message: "fileHistory must be the string 'disabled' when present (the request-level declaration that this run records no file history — no backup of an edited file, and no file restore in the same request; absent = the deployment's setting — there is no 'enabled' spelling)";
 }];
 /** 一次值闭集裁决的产物:出问题的键名(机读)+ 一句 wire 文案。 */
 export interface SingleMemberOffFieldIssue {
@@ -23,7 +92,7 @@ export interface SingleMemberOffFieldIssue {
     message: string;
 }
 /**
- * 单成员闭集键的值形裁决:表内任一键在场且不是字面 `"off"` ⇒ 返回拒体(调用方 400 `request.field_invalid`);
+ * 单成员闭集键的值形裁决:表内任一键在场且不是它自己那一个关断词 ⇒ 返回拒体(调用方 400 `request.field_invalid`);
  * 全部合法或全部缺席 ⇒ `null`。**两腿(fresh admission / resume 重放)共用这一只**。
  */
 export declare function singleMemberOffFieldIssue(raw: unknown): SingleMemberOffFieldIssue | null;

package/dist/request-value-closure.js

@@ -1,16 +1,24 @@
 export const MEMORY_CAPTURE_SPELLING_MESSAGE = "memoryCapture must be the string 'off' when present (the session-level memory-capture opt-out declaration; absent = capture as usual — there is no 'on' spelling)";
 export const MEMORY_OFF_SPELLING_MESSAGE = "memory must be the string 'off' when present (the request-level declaration that this run mounts no memory face at all; absent = memory as usual — there is no 'on' spelling; to keep memory mounted but stop this session's content from entering long-term memory, send memoryCapture: 'off' instead)";
+export const FILE_HISTORY_OFF_SPELLING_MESSAGE = "fileHistory must be the string 'disabled' when present (the request-level declaration that this run records no file history — no backup of an edited file, and no file restore in the same request; absent = the deployment's setting — there is no 'enabled' spelling)";
+export const FILE_HISTORY_DISABLED_NO_RESTORE = "fileHistory: 'disabled' cannot ride with a file restore (restoreFiles, rewindFilesTo, or the retired rewindFiles) — the request turns this run's file history off and asks to restore files from it in the same breath; the engine would refuse it (rewind.capture_disabled) only after the session had already been branched at resumeAt, which it does not undo, so it is refused here, before any side effect. Drop fileHistory to restore, or drop the restore to run without file history";
+export function fileHistoryRestoreConflict(body) {
+    if (body.fileHistory !== "disabled")
+        return false;
+    return body.restoreFiles === true || body.rewindFiles === true || (typeof body.rewindFilesTo === "string" && body.rewindFilesTo.length > 0);
+}
 const SINGLE_MEMBER_OFF_FIELDS = [
-    { field: "memoryCapture", message: MEMORY_CAPTURE_SPELLING_MESSAGE },
-    { field: "memory", message: MEMORY_OFF_SPELLING_MESSAGE },
+    { field: "memoryCapture", word: "off", message: MEMORY_CAPTURE_SPELLING_MESSAGE },
+    { field: "memory", word: "off", message: MEMORY_OFF_SPELLING_MESSAGE },
+    { field: "fileHistory", word: "disabled", message: FILE_HISTORY_OFF_SPELLING_MESSAGE },
 ];
 export function singleMemberOffFieldIssue(raw) {
     if (raw === null || raw === undefined || typeof raw !== "object" || Array.isArray(raw))
         return null;
     const body = raw;
-    for (const { field, message } of SINGLE_MEMBER_OFF_FIELDS) {
+    for (const { field, word, message } of SINGLE_MEMBER_OFF_FIELDS) {
         const value = body[field];
-        if (value !== undefined && value !== "off")
+        if (value !== undefined && value !== word)
             return { field, message };
     }
     return null;

package/dist/roster-bound-http-status.d.ts

@@ -0,0 +1,6 @@
+export declare const ROSTER_BOUND_HTTP_STATUS: {
+    readonly "config.tool_name_too_long": 503;
+    readonly "config.tool_contract_too_long": 503;
+    readonly "config.tool_roster_bound": 503;
+};
+//# sourceMappingURL=roster-bound-http-status.d.ts.map

package/dist/roster-bound-http-status.js

@@ -0,0 +1,6 @@
+export const ROSTER_BOUND_HTTP_STATUS = {
+    "config.tool_name_too_long": 503,
+    "config.tool_contract_too_long": 503,
+    "config.tool_roster_bound": 503,
+};
+//# sourceMappingURL=roster-bound-http-status.js.map

package/dist/rules-consent.js

@@ -736,17 +736,6 @@ export function createRuleConsentLane(stores, opts) {
                 adds: [],
             };
             const rowOf = (rows) => rows.find((r) => sameWireRuleIdentity(r, { behavior: input.behavior, rule: written.rule.rule, scope: row.scope }));
-            let before;
-            try {
-                before = await lane.listRules(input.principal);
-            }
-            catch (e) {
-                localImportLogger.warn("direct_rule_write_pre_read_failed", { behavior: input.behavior, err: e instanceof Error ? e.message : String(e) });
-                return { status: "failed", detail: `the rule store could not be read before writing: ${e instanceof Error ? e.message : String(e)}`, committed: "no" };
-            }
-            const standing = rowOf(before.rows);
-            if (standing !== undefined)
-                return { status: "no-op", rev: before.rev, stillLive: "yes", row: standing };
             const screened = screenLocalImportRow(row);
             if ("reason" in screened)
                 return { status: "rejected", reason: screened.reason, detail: screened.detail };

package/dist/run-local.js

@@ -3,12 +3,10 @@ import { DEFAULT_MODEL_REF, resolveTaskModel } from "./model-select.js";
 import { defaultModelRefusal, modelUnavailableMessage } from "./model-entry-refusal.js";
 import { buildDurableAbsenceNote, createCorruptReadSeat } from "./observability/corrupt-read-seat.js";
 import { outwardPlane } from "./terminal.js";
-import { homedir } from "node:os";
 import { join } from "node:path";
 import { realpathSync } from "node:fs";
 import { createInterface } from "node:readline/promises";
 import { fileURLToPath } from "node:url";
-import { loadRemoteExec } from "@sema-agent/settings-schema/node";
 import { Runner, uuidv7, FileStorageBackend, NodeExecutionEnv, TtlSessionStore, CenterPromptSource, FilePromptArtifactStore, FilePromptSourceStateStore, MemoryPromptArtifactStore, MemoryPromptSourceStateStore, defaultTaskRegistry } from "@sema-agent/core";
 import { singleUserAutoAcceptBaselineApplies } from "./approval.js";
 import { createBrain } from "./brain.js";
@@ -21,7 +19,9 @@ import { validatePromptsDomain, CORE_ENGINE_VERSION } from "./prompts-domain-val
 import { buildUnpricedCeilingNotice, loadConfig, logConfigDiagnostics, parseNumOrFailNonNegative } from "./config.js";
 import { buildStoreOpenRefusalTail } from "./plugins/store-open-refusal.js";
 import { acquireLocalBackendWithWait } from "./plugins/store-lock-wait.js";
-import { createConfigProvider } from "./config-provider.js";
+import { configLocalRoot, configProviderKind, createConfigProvider } from "./config-provider.js";
+import { composeExecutionLane } from "./boot/execution-lane.js";
+import { judgeConsolidationValve } from "./boot/memory-consolidation.js";
 import { applyEffective, applyCenterReadFace, resolveMcpServers, mcpForScenario, resolveA2aPeers, a2aForScenario } from "./config-center/facade.js";
 import { hostExecutionEnvFactory } from "./plugins/remote-env-host.js";
 import { executionLaneHomeDir, executionLaneOf } from "./execution-lane-caps.js";
@@ -259,20 +259,25 @@ export async function runLocal(argv, deps = {}) {
         process.env.CONFIG_PROVIDER = "local";
     process.env.SESSION_BACKEND = "memory";
     process.env.REQUIRE_PRINCIPAL = "false";
-    const root = args.root ?? process.env.CONFIG_LOCAL_DIR ?? process.env.AGENT_DATA_DIR ?? join(homedir(), ".ai-agent");
     if (args.root)
         process.env.CONFIG_LOCAL_DIR = args.root;
     const config = loadConfig();
+    const root = configLocalRoot(config);
     const logger = deps.logger ?? createLogger(config.logLevel);
     const metrics = createMetrics();
     const memoryEngineIncident = createMemoryEngineIncidentSink({ logger, metrics });
     installSecretEnvScrubRecorder({ logger, metrics });
     logConfigDiagnostics(logger);
     installOutboundDispatcher(logger);
-    const configProvider = createConfigProvider({
-        provider: config.configProvider ?? "local",
-        ...(config.configLocalDir ? { localDir: config.configLocalDir } : { localDir: root }),
-    });
+    const providerInput = { provider: config.configProvider ?? "local", localDir: root };
+    try {
+        await composeExecutionLane(config, { configSource: configProviderKind(providerInput), localRoot: root, logger, drivesFromFile: ["host"] });
+    }
+    catch (err) {
+        printErr(err instanceof Error ? err.message : String(err));
+        return 2;
+    }
+    const configProvider = createConfigProvider(providerInput);
     let effective;
     try {
         const r = await configProvider.fetchEffective(undefined);
@@ -303,25 +308,6 @@ export async function runLocal(argv, deps = {}) {
     const unpricedCeiling = buildUnpricedCeilingNotice(config.models, config);
     if (unpricedCeiling)
         logger.warn(unpricedCeiling.event, unpricedCeiling.fields);
-    try {
-        const fileRx = await loadRemoteExec(root);
-        if (fileRx?.provider === "host") {
-            config.remoteExec = {
-                provider: "host",
-                ...(fileRx.workdir ? { workspaceBase: fileRx.workdir } : {}),
-                ...(fileRx.commandTimeoutMs != null ? { commandTimeoutMs: fileRx.commandTimeoutMs } : {}),
-            };
-            logger.info("remote_exec_from_file", { provider: "host", root });
-        }
-        else if (fileRx) {
-            logger.warn("remote_exec_file_isolated_lane_unwired", { provider: fileRx.provider, note: "run-local is the host lane; isolated lanes stay env-sourced" });
-        }
-    }
-    catch (err) {
-        logger.error("remote_exec_file_invalid", { root, err: String(err) });
-        printErr(`config.d/remote-exec.json is invalid: ${String(err)}`);
-        return 2;
-    }
     try {
         assertGuardPatternsUsable(config);
     }
@@ -377,6 +363,15 @@ export async function runLocal(argv, deps = {}) {
         : undefined;
     const lspManager = hostRx && config.lspHostEnabled && config.requirePrincipal !== true ? createHostLspManager(config, (event, fields) => logger.info(event, fields)) : undefined;
     const memoryEngine = memoryEngineBackendFor(config, root, memoryEngineIncident);
+    try {
+        judgeConsolidationValve({ config, memoryEngine });
+    }
+    catch (err) {
+        printErr(err instanceof Error ? err.message : String(err));
+        void lspManager?.dispose();
+        await fileBackend.dispose();
+        return 2;
+    }
     let memorySync;
     if (config.memorySync && memoryEngine) {
         memorySync = createMemorySyncRunner({

package/dist/runs.d.ts

@@ -145,12 +145,32 @@ export declare function isSessionConflictResult(result: {
  * 🔴 **可达性如实**:本仓的 HTTP 面**今天铸不出**这条腿 —— 子代由 core 内部的 Agent 工具派生,
  * `fileHistoryLineage` 是 core prepare 的 internals(不在 `TaskSpec` 上),server 从不直接 prepare 一条带
  * lineage 的子代腿。本臂是**分诊面的完备性**(core 说 X ⇒ wire 形是 Y),不是一条今天在跑的路;将来的
- * 委派入口接线那天零改动即生效。同族其余五码今天**仍落 200-with-failed-body**,那是本批**之前**就存在的
- * 缺口(不是本批回归),已在上述对表格里逐码显式登记为债务,并由那道门看住不许陈腐。
+ * 委派入口接线那天零改动即生效。同族其余码(`rewind_files_retired` / `invalid_spec` / `conflicting_targets` /
+ * `restore_failed`)今天**仍落 200-with-failed-body**,那是各自提货批**之前**就存在的缺口(不是回归),已在上述对表格里
+ * 逐码显式登记为债务,并由那道门看住不许陈腐。
+ *
+ * S-724(core 7.31.0 #1048 / #1050):`rewind.capture_disabled` → **422**(关断词与还原同体 = 自相矛盾;本服务的请求面上
+ * 走不到它 —— fresh 受理门先 400 `request.field_conflict`(core 这一拒落在会话分叉之后、不回滚);映射是分诊面完备性)、`rewind.store_unconfigured`
+ * → **409**(部署没有历史店;`FILE_HISTORY_CAPTURE=false` 自本版不再摘店 ⇒ 可达面只剩没有后端的部署形,那里
+ * `capabilities.rewindFiles` 恒报 false —— 三问在 CHANGELOG 7.104.0)。
  */
 export declare function resumeAtHttpStatus(result: {
     terminal: TerminalCause;
 }): number | undefined;
+/**
+ * 同步提交腿的**拒因状态**(S-271 车内 codex r1 [high] 以类修):`resumeAtHttpStatus` 的逐码档,只对**零工作的拒**生效。
+ *
+ * 那张分诊表(`resume_at.*` / 治理闭集 / 名册超界闭集 / 开集 if 链)的每一格都立在同一个前提上:这个码是 prepare 期的拒,
+ * 整次提交一个 turn 都没跑、一个 token 都没烧 ⇒ 答 4xx / 5xx、**不走** `finalizeTaskResult`、不进幂等缓存(只缓存 < 400)。
+ * 可终局码证明不了这个前提:verify / cascade 的聚合结果 = **末轮**终局 + **各轮累计** stats(core `runCascade` /
+ * `runWithVerification`),前一轮真跑了 turn、真执行了工具,末轮才在 prepare 期被拒,码照样是那个 prepare 码。
+ * 真案(车内 codex r1 验真):`modelGate` 把带门类的超界工具从第一级模型的名册上摘掉,第一级跑了一只有副作用的工具,第二级
+ * 名册门拒 ⇒ 修前答 503,跳过计费,同一 Idempotency-Key 重发把第一级的工具再执行一遍。
+ * ⇒ 判据是**这次提交做没做过工作**(累计 `turns` / `tokens` 皆零),不是码:做过工作的失败无论码是什么,都是「跑了然后失败了」
+ * (200 + failed 体、计费、可重放)。入参要求带 `stats`,所以同步腿拿不到「只看码」的那一半 —— 只看码的逐码表留给
+ * `resumeAtHttpStatus` 自己(单元测试直接喂码)。
+ */
+export declare function syncRefusalHttpStatus(result: Pick<TaskResult, "terminal" | "stats">): number | undefined;
 /**
  * E18 resume-at — per-turn anchor capture, shared by runInBackground AND the resume-leg driveResume so the (single,
  * tricky) capture rule can't drift between the two stream-drain loops.

package/dist/runs.js

@@ -1,6 +1,8 @@
 import { runWithVerification, runCascade, defaultTaskRegistry, taskNotificationDedupKey, DURABLE_AGENT_HANDLE_RE } from "@sema-agent/core";
 import { failureCodeOf, sealResultForExit, outwardPlane } from "./terminal.js";
 import { GOVERNANCE_HTTP_STATUS } from "./governance-http-status.js";
+import { ROSTER_BOUND_HTTP_STATUS } from "./roster-bound-http-status.js";
+import { isSessionErrorCode, sessionErrorHttp } from "./session-error-wire.js";
 import { redactErrorMessage } from "./observability/run-terminal.js";
 import { withPrincipal } from "./observability/principal-context.js";
 import { redactSecrets } from "./trace/redact.js";
@@ -74,12 +76,24 @@ export function resumeAtHttpStatus(result) {
     if (Object.hasOwn(GOVERNANCE_HTTP_STATUS, code)) {
         return GOVERNANCE_HTTP_STATUS[code] ?? undefined;
     }
+    if (Object.hasOwn(ROSTER_BOUND_HTTP_STATUS, code)) {
+        return ROSTER_BOUND_HTTP_STATUS[code];
+    }
+    if (isSessionErrorCode(code)) {
+        const wire = sessionErrorHttp(code, "open");
+        if (wire !== undefined)
+            return wire.status;
+    }
     if (code === "resume.session_not_found")
         return 404;
     if (code === "rewind_snapshot.unresolvable")
         return 422;
     if (code === "rewind.child_scope_unsupported")
         return 422;
+    if (code === "rewind.capture_disabled")
+        return 422;
+    if (code === "rewind.store_unconfigured")
+        return 409;
     if (code === "memory.capture_optout_unpersisted")
         return 503;
     if (code === "config.memory_capture_spelling")
@@ -94,6 +108,11 @@ export function resumeAtHttpStatus(result) {
         return undefined;
     return code === "resume_at.not_found" ? 404 : 422;
 }
+export function syncRefusalHttpStatus(result) {
+    if (result.stats.turns !== 0 || result.stats.tokens !== 0)
+        return undefined;
+    return resumeAtHttpStatus(result);
+}
 export class TurnAnchorCapture {
     capture;
     onCaptureFail;
@@ -221,8 +240,9 @@ export async function runInBackground(runner, spec, runStore, taskId, metrics, p
     const parkNeedsReview = async (res) => {
         await sink.appendParked("needs_review", res);
         await flushModelUsage();
-        reached = { kind: "needs_review" };
-        await runStore.setNeedsReview(taskId);
+        const sealed = sealResultForExit(res);
+        reached = { kind: "needs_review", result: sealed };
+        await runStore.setNeedsReview(taskId, sealed);
         metrics?.addGauge("runs_active", -1);
         metrics?.inc("tasks_total", { status: "needs_review" });
     };
@@ -361,10 +381,12 @@ export async function runInBackground(runner, spec, runStore, taskId, metrics, p
                     await flush();
                     const parkStatus = ev.result.terminal.kind === "paused" ? outwardPlane(ev.result.terminal).status : undefined;
                     if (parkStatus === "suspended") {
-                        await sink.appendParked("suspended", await graftParkToolCallId(ev.result, parkCheckpointReader));
+                        const grafted = await graftParkToolCallId(ev.result, parkCheckpointReader);
+                        await sink.appendParked("suspended", grafted);
                         await flushModelUsage();
-                        reached = { kind: "suspended" };
-                        await runStore.setSuspended(taskId);
+                        const sealed = sealResultForExit(grafted);
+                        reached = { kind: "suspended", result: sealed };
+                        await runStore.setSuspended(taskId, sealed);
                         metrics?.addGauge("runs_active", -1);
                         metrics?.inc("tasks_total", { status: "suspended" });
                         continue;
@@ -456,10 +478,10 @@ export async function runInBackground(runner, spec, runStore, taskId, metrics, p
                 await runStore.setTerminal(taskId, plane.status, reached.result, plane.errorMessage ?? null);
             }
             else if (reached?.kind === "suspended") {
-                await runStore.setSuspended(taskId);
+                await runStore.setSuspended(taskId, reached.result);
             }
             else if (reached?.kind === "needs_review") {
-                await runStore.setNeedsReview(taskId);
+                await runStore.setNeedsReview(taskId, reached.result);
             }
             else if (cancelCtrl.signal.aborted && observedDone === undefined) {
                 const c = cancelledResult();

package/dist/sealed-key.d.ts

@@ -13,16 +13,43 @@ export interface SealedKeyOpener {
      *  🔴 The returned plaintext is a live secret: memory-only, never log it, never persist it. */
     open(ciphertextB64: string, publicKeyId: string): string;
 }
-export interface SealedKeyStore extends SealedKeyOpener {
+/**
+ * S-737 —— the store's **discovery-safe face**: ONLY the newest public key. This is what the HTTP layer is handed
+ * (`ServiceDeps.sealedKeyPublic` → `GET /v1/capabilities` `sealedKey`) — never the whole store — so private-key
+ * material, the custody path and the held-id list are structurally unreachable from that layer (not merely
+ * "not read"). Built from a live store by {@link buildSealedKeyPublicFace}, which copies out `latest` alone.
+ */
+export interface SealedKeyPublicFace {
     /** The keypair NEW ciphertexts should be sealed against (max `createdAt`, ties broken by id) —
-     *  this is the key we report/print for center registration. `publicKey` is base64 (32 raw bytes,
-     *  44 chars): public by definition, safe to log. */
-    latest: {
+     *  this is the key we report/print for center registration and project onto `GET /v1/capabilities`.
+     *  `publicKey` is base64 (32 raw bytes, 44 chars): public by definition, safe to log. */
+    readonly latest: {
         publicKeyId: string;
         publicKey: string;
         createdAt: string;
     };
 }
+/** The custody store = the private half ({@link SealedKeyOpener}: open / has / ids) + the public face. */
+export interface SealedKeyStore extends SealedKeyOpener, SealedKeyPublicFace {
+}
+/** Copy the public face out of a live store — a NEW plain object carrying `latest` only (no `open` / `has` / `ids`
+ *  reachable through it, whatever the caller later casts it to). Plain data ⇒ `build*`. */
+export declare function buildSealedKeyPublicFace(store: SealedKeyPublicFace): SealedKeyPublicFace;
+/**
+ * S-737 —— the `GET /v1/capabilities` `sealedKey` segment: exactly three keys — the algorithm (the pinned v1
+ * {@link SEALED_KEY_ALG}, never a hand-copied literal), the id to write into `sealedApiKey.publicKeyId`, and the
+ * base64 X25519 public key to `crypto_box_seal` against. `createdAt` is deliberately NOT projected (it answers
+ * nothing a sealer needs; the wire keeps to the three keys the contract names).
+ */
+export interface SealedKeyCapability {
+    readonly alg: typeof SEALED_KEY_ALG;
+    readonly publicKeyId: string;
+    readonly publicKey: string;
+}
+/** The ONE projection from the public face to the caps segment. `undefined` in ⇒ `undefined` out: the caps route
+ *  omits the key entirely (present-iff this process built its custody store — see the route for the two meanings
+ *  of absence). */
+export declare function projectSealedKeyCapability(face: SealedKeyPublicFace | undefined): SealedKeyCapability | undefined;
 /** Why a model's sealed key could not be unsealed (the poison-pill diagnosis, see SealedKeyPoison). CUSTODY failures only:
  *  a sealedApiKey that is malformed (alg other than the pinned v1 SEALED_KEY_ALG, non-base64 ciphertext) makes the whole
  *  catalog entry unavailable instead (S-704 `config.model_entry_invalid`, settings-schema `SealedApiKey` is the shape

package/dist/sealed-key.js

@@ -8,6 +8,15 @@ import { centerFetch } from "./config-center/center-request.js";
 export const SEALED_KEY_ALG = "libsodium-sealedbox-x25519";
 const SEAL_OVERHEAD_BYTES = 48;
 const BASE64_STRICT = /^[A-Za-z0-9+/]+={0,2}$/;
+export function buildSealedKeyPublicFace(store) {
+    const { publicKeyId, publicKey, createdAt } = store.latest;
+    return { latest: { publicKeyId, publicKey, createdAt } };
+}
+export function projectSealedKeyCapability(face) {
+    if (face === undefined)
+        return undefined;
+    return { alg: SEALED_KEY_ALG, publicKeyId: face.latest.publicKeyId, publicKey: face.latest.publicKey };
+}
 export function sealedKeyPoison(publicKeyId, reason, errKind) {
     return { sealedKeyPoison: true, publicKeyId, reason, ...(errKind ? { errKind } : {}), at: new Date().toISOString() };
 }