@sema-agent/server 7.20.0 → 7.22.0-rc.1

package/dist/main.js

@@ -53,6 +53,7 @@ import { createLiveCoordinators } from "./boot/coordinators.js";
 import { createRuntimeCaps } from "./boot/runtime-caps.js";
 import { createRunnerDeps, createRunnerDepsOnAsk, createSharedRunnerDeps } from "./boot/runner-deps.js";
 import { createOrgMemoryAdmissionWiring } from "./boot/org-memory.js";
+import { createGovernanceSeams } from "./boot/governance-seams.js";
 import { createSharedMemoryScopeAuthorizer } from "./shared-memory-scope-authorizer.js";
 import { createSessionFaces } from "./boot/session-faces.js";
 import { createLeaderFace } from "./boot/leader.js";
@@ -171,7 +172,7 @@ async function main() {
     await configCenter.applyLocalRemoteExec();
     // design/158 A10:持久层装配搬到 src/boot/stores.ts(逐字)。⚠️ 该段就地归一 `config.sessionBackend`
     // 且承载三条 fail-loud 拒启断言 —— 位置即契约,理由见该文件头注。
-    const { backend, storeBackendDegraded, memoryEngine, memorySyncCursors, rosterStore, backgroundAgentStore, taskAttachmentStore, mailboxStore, memoryExportBackend, memorySyncRunner, sessionStore, breakerState, usageWindowStore, } = await openStores({ config, logger, metrics, localRoot });
+    const { backend, storeBackendDegraded, memoryEngine, memorySyncCursors, rosterStore, backgroundAgentStore, taskAttachmentStore, mailboxStore, memoryExportBackend, memorySyncRunner, sessionStore, breakerState, usageWindowStore, memoryPosture, } = await openStores({ config, logger, metrics, localRoot });
     // design/183 I6(server 同族):**每副本 boot 必查**收编日志的在飞行 —— 续跑或响亮留痕,禁静默跳过。
     // 位置:store 开完之后(要 backend)、任何路由装配之前(半迁移状态绝不带进服务期)。判据与「为什么
     // 是续跑而不是拒启」见 boot/adoption.ts 顶注。
@@ -263,6 +264,30 @@ async function main() {
     // 非 brand 部署维持 core 新缺省(不署)。判据逐字不变,变的只是它现在**也**喂给 subRunner ——
     // 一个被委派的子代提交进的是同一个仓、代表同一个部署,它的 commit 少一行 trailer 没有理由。
     const commitHands = config.configProvider === "local" ? { commitCoAuthor: "Sema <noreply@vivi-ai.com>" } : undefined;
+    // checkpointStore 构造(只依赖 backend/config——顺序安全;DURABLE_APPROVAL 仍是唯一门,ALL three
+    // backends carry checkpoint(),local = core FileCheckpointStore + service half)。四个消费点同一实例:
+    // 主 runner 的 per-task spec 面(resolveSpec durableEnabled 分支)、scenarioDeps(subagent spawn 面
+    // forwardDurableApproval)、subRunner deps(子代执行面 suspendAsk——[1584] 接线,裁定见 subRunner 构造
+    // 内注),以及紧随其下的 design/170 件D 留存能力校验(它要读这只店的 `retention` 声明位)。
+    // ⚠️ 位置即契约:必须早于 `createGovernanceSeams`(件D 校验的对象之一)与 `createRunnerDeps`。
+    const checkpointStore = backend?.checkpoint && config.durableApproval ? backend.checkpoint(logger) : undefined;
+    // design/170 件B/C/D(#252 件1):三个部署治理座席 + 两条拒启判据(锁的装配相容性、留存能力校验)。
+    // ⚠️ 位置即契约:必须在 store 三件都构造完之后(件D 校验读它们的 `retention` 声明)、`new Runner` 之前
+    // (座席进 RunnerDeps);拒启在这里发生 = 还没开始服务。
+    const governanceSeams = createGovernanceSeams({
+        config,
+        logger,
+        // 件D 的首批治理对象(design/170 §5.1 点名的三族)。**喂真身**:这道校验的全部价值就是读真店上的
+        // 声明位,喂一个"我以为装了什么"的替身等于把校验变成自证。`store: undefined` 的行由 core 跳过。
+        retentionStores: [
+            { name: "sessionStore", store: sessionStore },
+            { name: "checkpointStore", store: checkpointStore },
+            // 🔴 R2-F3(codex 对抗复审,验真后修):喂 **Runner 真用的那一只**(`runnerOffloadStore`),不是
+            // `toolResultStore` —— 后者缺席时 Runner 拿的是本文件铸的 InMemory 兜底,而那只店同样受留存策略管辖。
+            // 喂错实例 = 校验漏掉了真正在跑的那一个,正是「校验读的不是真身」这类假绿。
+            { name: "toolResultStore", store: runnerOffloadStore },
+        ],
+    });
     // design/158 A10:RunnerDeps 装配段搬到 src/boot/runner-deps.ts(逐字;runStore 晚绑改取值,见该文件头注)。
     const runnerDeps = createRunnerDeps({
         hands: commitHands,
@@ -272,6 +297,7 @@ async function main() {
         permissionRuleStore: permissionRuleStores?.provider,
         executionEnvFactory, lspManager, fleetBus, deploymentHooks, workflowRunStore, workflowJournalStore,
         workflowAgentRegistry, workflowNotifyGate, workflowCompletionInbox, deliverWorkflowCompletion, orgMemoryAdmission,
+        governanceSeams,
         sharedMemoryStores: sharedMemoryStore ? sharedMemoryStore : undefined,
         getRunStore: () => runStore,
     });
@@ -427,12 +453,8 @@ async function main() {
     //    fork 子代跨 wake 保 offload 引用;fork 形(有 sessionId)会话规则可达。
     // 1877 注释的「Deliberately NOT inherited」清单(selfOrchestration/scheduler/memory/fileSnapshot/
     // runtimeCaps)不变——本批只补漏配,不动裁定。
-    // checkpointStore 构造(从 runStore 区上移,只依赖 backend/config——顺序安全;DURABLE_APPROVAL 仍是
-    // 唯一门,ALL three backends carry checkpoint(),local = core FileCheckpointStore + service half)。
-    // 三个消费点同一实例:主 runner 的 per-task spec 面(resolveSpec durableEnabled 分支)、scenarioDeps
-    // (subagent spawn 面 forwardDurableApproval)、subRunner deps(子代执行面 suspendAsk——[1584] 接线,
-    // 裁定见下方 subRunner 构造内注)。
-    const checkpointStore = backend?.checkpoint && config.durableApproval ? backend.checkpoint(logger) : undefined;
+    // (checkpointStore 的构造已再上移到 RunnerDeps 装配之前 —— design/170 件D 的留存能力校验要把它与
+    //  session/tool-result 一起交给 core 的 `assertRetentionCapability`,而那道校验必须在拒启窗内跑完。)
     // [1593] 提名成变量:parked 子代的 ensureChildSessionDurable 晋升半场要拿它做 promoteToHost
     // (子会话住私有 TTL 店,park 前整树拷进 host durable 店——只查不迁的 1.263 形在拆店生产形下恒
     // 否决 park,cli 真机 14ms~2s expired 即此)。
@@ -459,6 +481,7 @@ async function main() {
             sessionPolicyStore,
             usageWindowStore,
             orgMemoryAdmission,
+            governanceSeams, // design/170 件B/C/D:与主 runner 同一份座席(子代平面同受档位/锁约束)
             sharedMemoryStores: sharedMemoryStore ? sharedMemoryStore : undefined, // design/177:与主 runner 同实例
         }),
         // ── 以下为 subRunner 差异键(不在共享基座;逐个有因)──────────────────────────────────────
@@ -823,7 +846,7 @@ async function main() {
         workflowCompletionInbox,
     });
     // design/158 A10:leader 段搬到 src/boot/leader.ts(逐字)。
-    const leaderEndpoint = createLeaderFace({ config, logger, brain, pricing, executionEnvFactory, toolResultStore, sessionStore, checkpointStore });
+    const leaderEndpoint = createLeaderFace({ config, logger, brain, pricing, executionEnvFactory, toolResultStore, sessionStore, checkpointStore, governanceSeams });
     // Graceful drain: shared mutable state — SIGTERM flips `draining` (shutdown below), createHttpServer
     // assigns `inflight` (live leg count on this instance), /health + the submit 503 gate read it.
     const drainState = { draining: false };
@@ -1007,6 +1030,7 @@ async function main() {
         scenarioDetails, // 场景详情只读面(内建+center 同判定源)
         workflowsCapable, // ① core split: capabilities.workflows = engine-can (workflowsCapability); workflowsList = store (below)
         staticWiring, // #154 件三:GET /v1/diagnostics/wiring 的 static 半场(与上面的拒启自检同一份产物)
+        memoryPosture, // #252 件2/件3:记忆面姿态(boot/stores.ts 的单一推导点;诊断面全量 + 能力位窄投影)
         instanceId,
         // Capability discovery: the deployment facts only main knows. Store-derived booleans
         // (asyncRuns/artifacts/approvals/leader) are computed inside the server from the deps themselves.
@@ -1065,6 +1089,7 @@ async function main() {
         selectEnvTool, sendUserFileToolSpec, memoryEngine, durableEnabled, approvalExemptionStore,
         singleUserAutoAcceptBaseline, checkpointStore, deploymentHooks, imageIndex, perTaskImage,
         sessionEnvSelection,
+        lockedKeys: governanceSeams.lockedKeys, // design/170 件C:同步拒面判据(与 RunnerDeps.lockedConfig 同源)
         liveQuestionFace: question, // #152:活体问答面在场 ⇒ durable question 门按活流分腿(见 ResolveSpecCtx 注)
     });
     // #196:执行点选路。resolveSpec 已按场景判别位登记 lane;`full` 恒回主 runner(修前行为逐字不变)。

package/dist/memory-posture.d.ts

@@ -0,0 +1,80 @@
+/**
+ * #252 件2/件3 —— 记忆面**姿态**的单一推导点。
+ *
+ * ## 病
+ *
+ * 「这台 worker 的记忆点亮没有 / 跑在哪个后端 / 检索在哪一档」这三件事此前只活在启动日志
+ * (`memory_engine_enabled`)里。日志不是接口:不可查询、跨副本不可聚合、也没有任何门保证它还在。
+ * 于是消费端(cli 的记忆 UX)与运维只能读日志、或者按 env 自己推 —— 而 env 推不出来:`MEMORY_ENGINE=on`
+ * 的部署在多租户 file 底座上是**暗的**,`MEMORY_ENGINE_BACKEND=pg` 的部署检索档还要看 embedder 在不在。
+ *
+ * ## 药
+ *
+ * 一次推导,两个读面:operator 面(`GET /v1/diagnostics/wiring` 的 `memoryPosture` 段,全量)与消费端面
+ * (`GET /v1/capabilities` 的 `memoryEngine` 位,窄投影)。两面同源是本件的全部意义 —— 「诊断页说点亮、
+ * 能力位说没有」这种自相矛盾在结构上不可能发生。
+ *
+ * ## 两条诚实纪律
+ *
+ * ① **档位取实例真值,不按后端推断**([3590] 裁①/[3606]①的延续):`vectorMode` 是「后端上限 × embedder
+ *    在场」的推断结果,两支 SQL 后端各自的实例 getter 才是真值;file 引擎**根本没有**这个指示面
+ *    (core 的 `MemoryBackend` 契约里没有 `vectorMode`,亲验),所以它报 `null` —— 「没有这个指示面」与
+ *    「档位是词面」是两件事,折成一件就是编一个数出来。
+ * ② **dark 成因是闭集词**:散文归日志(它的读者是人),机器读面要词(它的读者是 cli 的分支)。
+ */
+import type { ServiceConfig } from "./config-types.js";
+/** 检索档位(两支 SQL 后端的实例 getter 值域;file 腿无此面)。 */
+export type MemoryVectorRung = "native" | "portable" | "lexical";
+/** 记忆面**暗**的成因(闭集;三条各对应装配期的一道门)。 */
+export type MemoryDarkReason = 
+/** operator 显式关停(`MEMORY_ENGINE=off`)。 */
+"engine_off"
+/** 多租户 + file 底座:file 基座无租户隔离,fail-closed 不点亮(改 `MEMORY_ENGINE_BACKEND=pg|tidb`)。 */
+ | "multi_tenant_file_backend"
+/** 平面分裂车道:模型的文件工具在沙箱 fs、引擎在 worker fs,harvest 看不到沙箱写入 ⇒ fail-closed。 */
+ | "remote_lane_split";
+/** 部署的记忆面姿态(operator 面全量下发;能力面取其窄投影)。 */
+export interface MemoryPosture {
+    /** 引擎**真的**接上了吗(= `RunnerDeps.memoryBackend` 在场),不是「配置里写了什么」。 */
+    enabled: boolean;
+    /** 声明的后端方言。与点亮态**正交**:配了 pg 而引擎暗时这一位仍是 pg(配置事实与装配事实分开报)。 */
+    backend: ServiceConfig["memoryEngineBackend"];
+    /** 检索档位;`null` = 这条腿没有档位指示面(file 引擎),**不是**「档位是 lexical」。 */
+    vectorMode: MemoryVectorRung | null;
+    /** 暗的成因;点亮时恒 `null`(两者同时在场即自相矛盾)。 */
+    darkReason: MemoryDarkReason | null;
+    /** 多租户姿态(file 底座恒暗那条判据的输入,也是消费端判「这台的记忆是不是按租户分区」的依据)。 */
+    multiTenant: boolean;
+    /** embedder 身份(pg 向量档才可能在场)。**只报 model/dimensions**:端点与 key 是凭证面,不进读面。 */
+    embedder: {
+        model: string;
+        dimensions: number;
+    } | null;
+}
+/** 推导入参 = 装配现场的真事实(不在本函数里重算任何一件)。 */
+export interface MemoryPostureFacts {
+    config: Pick<ServiceConfig, "memoryEngineEnabled" | "memoryEngineBackend" | "requirePrincipal" | "memoryEmbedder">;
+    /** 引擎这一腿真的接上了吗(`memoryEngine !== undefined`)—— 装配结果。 */
+    engineWired: boolean;
+    /** 两支 SQL 后端从**实例 getter** 读到的档位;file 腿传 `undefined`(无此面)。 */
+    vectorMode: MemoryVectorRung | undefined;
+    /** 车道门判 dark 了吗(`memoryEngineRemoteLanePosture(config)?.posture === "dark"`)。 */
+    remoteLaneDark: boolean;
+}
+/**
+ * 纯推导(`build*`:产纯数据)。成因的判序是**显式关停 > 租户隔离 > 车道分裂**:
+ * operator 自己关的那一形必须报成 `engine_off`,报成隔离/车道会把人指向一个改了也没用的旋钮。
+ */
+export declare function buildMemoryPosture(facts: MemoryPostureFacts): MemoryPosture;
+/**
+ * 能力面(`GET /v1/capabilities` 的 `memoryEngine` 位)的**窄投影**:点亮 ⇒ 后端形 + 档位;
+ * 暗 ⇒ `false`(位在场且假 = 「这台认识这一位、本部署没点亮」,与位整个缺席 = 老 server 两回事)。
+ *
+ * 刻意**不**外泄 `darkReason` / `multiTenant` / embedder 身份:能力面是任何持凭证调用方都能读的面,
+ * 它只需要回答「我能不能用记忆、用的是哪一档」;成因与身份是运维诊断料,归 operator-only 那一面。
+ */
+export declare function projectMemoryEngineCapability(posture: MemoryPosture | undefined): false | {
+    backend: MemoryPosture["backend"];
+    vectorMode: MemoryVectorRung | null;
+};
+//# sourceMappingURL=memory-posture.d.ts.map

package/dist/memory-posture.js

@@ -0,0 +1,40 @@
+/**
+ * 纯推导(`build*`:产纯数据)。成因的判序是**显式关停 > 租户隔离 > 车道分裂**:
+ * operator 自己关的那一形必须报成 `engine_off`,报成隔离/车道会把人指向一个改了也没用的旋钮。
+ */
+export function buildMemoryPosture(facts) {
+    const { config, engineWired, vectorMode, remoteLaneDark } = facts;
+    const embedder = config.memoryEmbedder;
+    const darkReason = engineWired
+        ? null
+        : !config.memoryEngineEnabled
+            ? "engine_off"
+            : config.memoryEngineBackend === "file" && config.requirePrincipal === true
+                ? "multi_tenant_file_backend"
+                : remoteLaneDark
+                    ? "remote_lane_split"
+                    : // 到不了的第四形只可能是「装配拒启路径上」(DB 腿半配 fail-loud 已 throw),那时这个对象根本
+                        // 不会被建出来。仍然给一个词而不是 null:点亮态为假时 `darkReason` 必须有值,才谈得上机器可读。
+                        "engine_off";
+    return {
+        enabled: engineWired,
+        backend: config.memoryEngineBackend,
+        vectorMode: vectorMode ?? null,
+        darkReason,
+        multiTenant: config.requirePrincipal === true,
+        embedder: embedder !== undefined ? { model: embedder.model, dimensions: embedder.dimensions } : null,
+    };
+}
+/**
+ * 能力面(`GET /v1/capabilities` 的 `memoryEngine` 位)的**窄投影**:点亮 ⇒ 后端形 + 档位;
+ * 暗 ⇒ `false`(位在场且假 = 「这台认识这一位、本部署没点亮」,与位整个缺席 = 老 server 两回事)。
+ *
+ * 刻意**不**外泄 `darkReason` / `multiTenant` / embedder 身份:能力面是任何持凭证调用方都能读的面,
+ * 它只需要回答「我能不能用记忆、用的是哪一档」;成因与身份是运维诊断料,归 operator-only 那一面。
+ */
+export function projectMemoryEngineCapability(posture) {
+    if (posture === undefined || !posture.enabled)
+        return false;
+    return { backend: posture.backend, vectorMode: posture.vectorMode };
+}
+//# sourceMappingURL=memory-posture.js.map

package/dist/observability/fail-open.d.ts

@@ -69,6 +69,10 @@ export declare const FAIL_OPEN_TAGS: {
         readonly cls: "F";
         readonly note: "fleet bus 某订阅回调抛错 ⇒ 该回调本帧作废,其余订阅方与发布方不受影响。隔离是承重的:扇出同步,修前异常会传回发布方 put/update 投影点,core 持久化 catch{} 且不推进 storeRev ⇒ durable 行冻在 running 而 notify 已 ack(#183 复审 R3 HIGH)。丢的只是一个消费方的一帧渲染,故 F 类;但必须留痕——静默吞掉等于订阅方病灶永不显形。";
     };
+    readonly "server.fleet.run-status-unmapped": {
+        readonly cls: "F";
+        readonly note: "A-032 P1-④:`runStatusToFleet` 收到**词表外**的 run 状态词(闭集签名之外的唯一来路 = `rowToRun` 把无约束的 status 文本列裸 cast,滚动升级里更新的副本写的新词被旧副本读到)⇒ 折成 `idle`。放行的最坏后果 = 该行在 fleet 面板上**永久滞留**(removal 集 {completed,failed,killed} 收不到 idle),纯展示面、不影响 run 本身与任何执法判据,故 F 类。方向刻意不改(把 miss 折成终局会把一条还在跑的任务从面板上摘掉,误摘比多一行更伤)。留痕是承重的:2026-06-28 on-box e2e 逮到的 `blocked` 泄漏当年只能靠人眼在面板上发现——计数让下一次词表漂移在遥测里当场显形。编译期一侧已由闭集入参 + `never` 臂执法。";
+    };
     readonly "server.run-store.stale-claim-quarantine-unremoved": {
         readonly cls: "F";
         readonly note: "#213 陈旧 claim 接管:claim 已 rename 进 tmp/ 隔离名(接管本体已完成、正确性不受影响),但隔离件 rmSync 失败留在 tmp。放行的最坏后果 = tmp 里多一个死文件(不在 activeDir,hydrate 永不把它当 claim 复活);故 F 类。必须留痕:反复删不掉 = tmp 权限/fs 病灶,静默吞掉会让 tmp 无声膨胀。";

package/dist/observability/fail-open.js

@@ -92,6 +92,10 @@ export const FAIL_OPEN_TAGS = {
         cls: "F",
         note: "fleet bus 某订阅回调抛错 ⇒ 该回调本帧作废,其余订阅方与发布方不受影响。隔离是承重的:扇出同步,修前异常会传回发布方 put/update 投影点,core 持久化 catch{} 且不推进 storeRev ⇒ durable 行冻在 running 而 notify 已 ack(#183 复审 R3 HIGH)。丢的只是一个消费方的一帧渲染,故 F 类;但必须留痕——静默吞掉等于订阅方病灶永不显形。",
     },
+    "server.fleet.run-status-unmapped": {
+        cls: "F",
+        note: "A-032 P1-④:`runStatusToFleet` 收到**词表外**的 run 状态词(闭集签名之外的唯一来路 = `rowToRun` 把无约束的 status 文本列裸 cast,滚动升级里更新的副本写的新词被旧副本读到)⇒ 折成 `idle`。放行的最坏后果 = 该行在 fleet 面板上**永久滞留**(removal 集 {completed,failed,killed} 收不到 idle),纯展示面、不影响 run 本身与任何执法判据,故 F 类。方向刻意不改(把 miss 折成终局会把一条还在跑的任务从面板上摘掉,误摘比多一行更伤)。留痕是承重的:2026-06-28 on-box e2e 逮到的 `blocked` 泄漏当年只能靠人眼在面板上发现——计数让下一次词表漂移在遥测里当场显形。编译期一侧已由闭集入参 + `never` 臂执法。",
+    },
     "server.run-store.stale-claim-quarantine-unremoved": {
         cls: "F",
         note: "#213 陈旧 claim 接管:claim 已 rename 进 tmp/ 隔离名(接管本体已完成、正确性不受影响),但隔离件 rmSync 失败留在 tmp。放行的最坏后果 = tmp 里多一个死文件(不在 activeDir,hydrate 永不把它当 claim 复活);故 F 类。必须留痕:反复删不掉 = tmp 权限/fs 病灶,静默吞掉会让 tmp 无声膨胀。",

package/dist/orchestration/workflow-completion-inbox.d.ts

@@ -1,3 +1,4 @@
+import type { LedgerEventType } from "../trace/ledger-events.js";
 /** One pending completion, scoped to the session that must be told about it. `summary` is ALREADY
  *  redacted + length-bounded by core's notifier seam (see {@link WorkflowCompletionPayload}). */
 export interface WorkflowCompletionInboxEntry {
@@ -211,7 +212,7 @@ export declare class FileWorkflowCompletionInbox extends InMemoryWorkflowComplet
  * wedges the queue.
  */
 export declare function emitPendingWorkflowCompletions(inbox: WorkflowCompletionInbox | undefined, sessionId: string | undefined, callerPrincipal: string | null, emit: (frame: {
-    type: string;
+    type: LedgerEventType;
 }) => void | Promise<void>, 
 /** Emit-TARGET diagnostics — WHICH leg drained (route) onto WHAT kind of connection
  *  (live SSE write vs durable event-log append), plus the enqueue→emit lag, so a "workflow completed but the

package/dist/parked-decide.js

@@ -1,3 +1,4 @@
+import { defaultSubagentTailBus } from "./fleet/subagent-tail-bus.js";
 /**
  * pending checkpoint → parked bg 行匹配。
  *
@@ -192,6 +193,14 @@ export async function decideParkedAgent(deps, req) {
             return "retry";
         }
     };
+    // [3911] per-agent tail 的**内容帧供给形**必须随赎回周期作废(codex 复审 round3 high)。
+    // 本车道是第四条腿:上面这只 ctx 是**裸的**(只有 toolCallId + reviveClaim),没有宿主
+    // forward / notification sink —— 于是 ①park 是非终态,三条 run 腿的终态撤销手够不到它;
+    // ②赎回周期是否有帧供给取决于**进程内 retain 条目还在不在**(在 ⇒ core 用 spawn 期的
+    // internalsSnapshot 继续转发;不在 ⇒ 这一周期结构上一帧都不会有)。两种都不是本处能断言的事,
+    // 所以把上一周期的答案作废成「不知道」:新周期真有帧时首帧会重新登记真相,没有帧时 meta 也不会
+    // 拿旧周期的 `on` 骗订阅方去等一个永远不来的转录(那正是本批要消灭的静默形)。
+    defaultSubagentTailBus.forgetHandleContentMode(match.handle);
     let receipt;
     try {
         receipt = await deps.reviveTool.execute(mintReviveArgs(row, deps.knownAgentTypes ?? new Set()), ctx);

package/dist/plugins/approval-ask-store-sql.d.ts

@@ -343,7 +343,9 @@ export declare class SqlApprovalAskStore implements ApprovalAskStore {
     constructor(db: SqlDriver);
     private q;
     private json;
-    /** 唯一键冲突判别(方言差异显式,checkpoint-store-sql.ts 同形):mysql2 挂 `errno`,node-pg 挂 SQLSTATE `code`。 */
+    /** 唯一键冲突判别 —— 判据属主 = `sql-errors.ts`(A-032 P1-①)。`decideAsk` 用它把 `(task_id,
+     *  idempotency_key)` 撞键翻成 typed 的 `idempotency_conflict` 臂,不让驱动错误对象漏给消费层;
+     *  旧形 tidb 臂只认 errno,只带 `code` 的驱动错误会漏判成"真障碍"。 */
     private isDupKey;
     /**
      * 🔴 失败臂的回读**必须走当前这条 `conn`**,不许调 `this.getAsk`/`this.getBatch`(codex 复审 F1,

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

@@ -1,5 +1,6 @@
 import { mysqlDriver, pgDriver, dialectJsonEncoder } from "./sql-driver.js";
 import { canAskTransition } from "../approval-ask-machine.js";
+import { isDupKeyError } from "./sql-errors.js";
 /**
  * 幂等键的入店卫生门(属主兜底轮 F2,三 twin 同判——SQL 双方言与 InMemory 都从这里过)。
  *
@@ -233,10 +234,6 @@ const ASK_COLS = "ask_id, task_id, source_task_id, session_id, owner, batch_id,
     "gate_bound_call_id, gate_bound_input_hash, idempotency_key, card_json, schema_version, expires_at_ms, " +
     "created_at_ms, updated_at_ms";
 const BATCH_COLS = "batch_id, task_id, state, bound_ask_id, rev, created_at_ms, updated_at_ms";
-/** 唯一键冲突的方言判别(checkpoint-store-sql.ts 同一对常量)——`decideAsk` 用它把 `(task_id,
- *  idempotency_key)` 撞键翻成 typed 的 `idempotency_conflict` 臂,不让驱动错误对象漏给消费层。 */
-const DUP_ENTRY = 1062; // MySQL/TiDB ER_DUP_ENTRY
-const PG_UNIQUE_VIOLATION = "23505";
 /** JSON 列的读出:**本层只做存取,不解释**——返回类型即 `unknown`,把「这是什么形」的责任留给消费方。
  *  两个 JSON 列的 schema 属主都不在本车:`decision_actor` = design/171 ActorAssertion 形(车4 回决端点
  *  消费,届时按宪法 [2704] 立 schema 后 safeParse);`card_json` = 172 §3.1 呈卡帧载荷(车3 wire 面属主)。
@@ -338,9 +335,11 @@ export class SqlApprovalAskStore {
     json(value) {
         return dialectJsonEncoder(this.db.dialect)(value);
     }
-    /** 唯一键冲突判别(方言差异显式,checkpoint-store-sql.ts 同形):mysql2 挂 `errno`,node-pg 挂 SQLSTATE `code`。 */
+    /** 唯一键冲突判别 —— 判据属主 = `sql-errors.ts`(A-032 P1-①)。`decideAsk` 用它把 `(task_id,
+     *  idempotency_key)` 撞键翻成 typed 的 `idempotency_conflict` 臂,不让驱动错误对象漏给消费层;
+     *  旧形 tidb 臂只认 errno,只带 `code` 的驱动错误会漏判成"真障碍"。 */
     isDupKey(e) {
-        return this.db.dialect === "tidb" ? e?.errno === DUP_ENTRY : e?.code === PG_UNIQUE_VIOLATION;
+        return isDupKeyError(this.db.dialect, e);
     }
     /**
      * 🔴 失败臂的回读**必须走当前这条 `conn`**,不许调 `this.getAsk`/`this.getBatch`(codex 复审 F1,

package/dist/plugins/background-agent-store-sql.js

@@ -1,5 +1,6 @@
 import { BackgroundAgentStoreError, STALE_RUNNING_REAP_ATTRIBUTION, } from "@sema-agent/core";
 import { pgSafeJsonStringify, pgSanitizeText } from "./pg-safe-json.js";
+import { isMysqlDupKeyError } from "./sql-errors.js";
 export const BACKGROUND_AGENT_TABLE = "background_agent";
 const SUMMARY_COLS = "handle, owner, session_scoped, session_id, parent_session_id, root_session_id, name, agent_type, status, spawned_at_ms, updated_at_ms, settled_at_ms, usage_json";
 /** put/update 共用的投影列(scope_key/handle 键列另拼;record_json 恒最后)。core 1.383([1565] 提货单)
@@ -238,7 +239,9 @@ export class TiDBBackgroundAgentStore {
             await this.pool.query(`INSERT INTO ${BACKGROUND_AGENT_TABLE} (scope_key, handle, ${PROJ_COLS}) VALUES (${Array.from({ length: PROJ_N + 2 }, () => "?").join(", ")})`, [stored.scope, stored.handle, ...projParams(stored, JSON.stringify, (t) => t)]);
         }
         catch (e) {
-            if (e.code === "ER_DUP_ENTRY") {
+            // 判据属主 = `sql-errors.ts`(A-032 P1-①:旧形只认 `code`,只带 errno 的驱动错误会让
+            // `agent_record.already_exists` 这条 typed 分流腿静默失效)。
+            if (isMysqlDupKeyError(e)) {
                 throw new BackgroundAgentStoreError("agent_record.already_exists", "agent record already exists");
             }
             throw e;

package/dist/plugins/checkpoint-store-sql.d.ts

@@ -248,6 +248,8 @@ export declare class SqlCheckpointStore implements CheckpointStore {
      *  scrubbing the byte and storing the scrubbed row is the unacceptable arm; refusing loudly is the chosen one.
      *  That refusal is why {@link SqlCheckpointStore.fidelity} carries a documented residual (see it). */
     private json;
+    /** 判据属主 = `sql-errors.ts`(A-032 P1-①;旧形 tidb 臂只认 errno ⇒ 只带 `code` 的 dup 会把
+     *  `checkpoint.already_exists` 这条 typed 契约错误退化成裸驱动对象上抛)。 */
     private isDupKey;
     /** Create-once. core mints the token (`mintCheckpointToken`) and calls this during suspend. */
     put(token: CheckpointToken, cp: Checkpoint): Promise<void>;

package/dist/plugins/checkpoint-store-sql.js

@@ -34,6 +34,7 @@ import { MAX_RULE_SUGGESTIONS, RuleSuggestionRawSchema } from "../approval-card.
 import { parseJsonStrict as parseJson } from "./sql-row-helpers.js";
 import { recordFailOpen } from "../observability/fail-open.js";
 import { mysqlDriver, pgDriver, dialectProtocolJsonEncoder } from "./sql-driver.js";
+import { isDupKeyError } from "./sql-errors.js";
 /** Cap the persisted/served pending-approval args so a pathological tool payload can't bloat the checkpoint row
  *  or the operator-queue response (the BFF renders this in an approval card; a few KB is plenty). */
 const MAX_TOOL_INPUT_CHARS = 8192;
@@ -243,8 +244,6 @@ function pendingActionToolCallId(blob) {
         return { readable: false };
     return { readable: true, toolCallId: id, boundInputHash: bih, kind, sourceTaskId };
 }
-const DUP_ENTRY = 1062; // MySQL/TiDB ER_DUP_ENTRY
-const PG_UNIQUE_VIOLATION = "23505";
 function readActorAssertion(v) {
     if (typeof v !== "object" || v === null)
         return undefined;
@@ -412,10 +411,10 @@ export class SqlCheckpointStore {
     json(value, label) {
         return dialectProtocolJsonEncoder(this.db.dialect)(value, label);
     }
+    /** 判据属主 = `sql-errors.ts`(A-032 P1-①;旧形 tidb 臂只认 errno ⇒ 只带 `code` 的 dup 会把
+     *  `checkpoint.already_exists` 这条 typed 契约错误退化成裸驱动对象上抛)。 */
     isDupKey(e) {
-        return this.db.dialect === "tidb"
-            ? e?.errno === DUP_ENTRY
-            : e?.code === PG_UNIQUE_VIOLATION;
+        return isDupKeyError(this.db.dialect, e);
     }
     /** Create-once. core mints the token (`mintCheckpointToken`) and calls this during suspend. */
     async put(token, cp) {

package/dist/plugins/file-run-store.d.ts

@@ -33,6 +33,7 @@ import { type UsageRow } from "../usage-analytics.js";
 import type { TaskResult, TaskStatus } from "@sema-agent/core";
 import type { RunRecord, SessionSummary, RunEvent } from "./store-contracts.js";
 import type { RunStoreCheckpointProbe } from "./memory-run-store.js";
+import type { LedgerEventType } from "../trace/ledger-events.js";
 export declare class FileRunStore {
     private readonly runsDir;
     private readonly activeDir;
@@ -87,7 +88,7 @@ export declare class FileRunStore {
     requestPreempt(taskId: string, owner: string | null): Promise<boolean>;
     isPreemptRequested(taskId: string, owner: string | null): Promise<boolean>;
     heartbeat(taskId: string, owner: string | null): Promise<void>;
-    appendEvent(taskId: string, seq: number, type: string, data: unknown): Promise<void>;
+    appendEvent(taskId: string, seq: number, type: LedgerEventType, data: unknown): Promise<void>;
     maxSeq(taskId: string): Promise<number>;
     retainedFrom(taskId: string): Promise<number>;
     getEvents(taskId: string, afterSeq: number): Promise<RunEvent[]>;

package/dist/plugins/image-bake-store-sql.js

@@ -41,6 +41,7 @@ import { pgSanitizeText, pgHasUnstorable } from "./pg-safe-json.js";
 import { parseJsonOr as parseJson, toIso as iso } from "./sql-row-helpers.js";
 import { mysqlDriver, pgDriver, dialectJsonEncoder } from "./sql-driver.js";
 import { mapBakeRow as mapRow, BAKE_SELECT_COLS as SELECT_COLS, } from "./store-contracts.js";
+import { isDupKeyError } from "./sql-errors.js";
 /** PG translation of the image_bake / image_bake_event / image_bake_lease DDL in tidb-pool.ts SCHEMA_STATEMENTS
  *  (JSON→JSONB, TINYINT→SMALLINT, DATETIME(3)→TIMESTAMPTZ(3), inline UNIQUE/KEY→named CONSTRAINT + CREATE INDEX).
  *  TINYINT(1) 归一(clay 批 2026-07-26):布尔列的 PG 映射统一 SMALLINT 0/1(此前本家族用 BOOLEAN)——
@@ -115,11 +116,10 @@ export async function ensurePgImageBakeSchema(pool, poolName = "standard") {
     // Seed the always-present admission sentinel (idempotent) so createBakeIfIdle can FOR UPDATE-lock it.
     await pool.query("INSERT INTO image_bake_admit (pool) VALUES ($1) ON CONFLICT (pool) DO NOTHING", [poolName]);
 }
-/** Dup-key detection — mysql2 names it `ER_DUP_ENTRY`, PG raises SQLSTATE 23505. */
-function isDupKey(dialect, err) {
-    const code = err?.code;
-    return Boolean(err) && code === (dialect === "tidb" ? "ER_DUP_ENTRY" : "23505");
-}
+/** Dup-key detection — the PREDICATE has a single owner (`sql-errors.ts`); only the ATTRIBUTION
+ *  (which UNIQUE collided — `dupKeyName` below) is store-specific. A-032 P1-①: the old local form
+ *  recognized only mysql2's string `code`, so an error carrying just `errno` fell through. */
+const isDupKey = isDupKeyError;
 /** Which UNIQUE key did the dup collide on? The ATTRIBUTION CHANNEL differs by engine: mysql2 names the key in
  *  `sqlMessage` ("Duplicate entry '…' for key 'image_bake_event.uq_image_bake_event_line'" vs "…'image_bake_event.PRIMARY'");
  *  PG names the violated constraint in `err.constraint` (the PK is auto-named `image_bake_event_pkey`, the line

package/dist/plugins/memory-embedder-fingerprint.d.ts

@@ -49,6 +49,19 @@
  * 3. **门自身失败 = 抛(拒启)**。吞掉 = 元表停留旧值 = 下次 boot 再清一次,把一次性代价变成每次 boot
  *    的代价;且「门在场但没跑成」静默 = fail-open。
  *
+ * ## 两条已知残余(codex 对抗复审 R1-F1/R1-F3,均判为真;处置=成文,不落码面)
+ *
+ * - **跨门回滚**(F1):指纹门**之前**的版本(7.14.x/7.15.x:有 embedder、无本门)照写 `embedding` 列却
+ *   不认识元表 ⇒「装本版(元表=B)→ 回滚旧版跑一段(写 A 空间向量)→ 升回本版仍配 B」走完,元表与配置
+ *   都说 B 而列里是 A 空间 ⇒ 此后恒判 B 态。**与滚动窗是同一族**(第二写者不维护指纹),码面根治只有
+ *   行级记账列 —— 稿已列出界(触主表删库重建窗)。纪律面处置与滚动窗同:回滚前后手动清列,或删掉
+ *   元表那一行让下次 boot 按 D 态保守清。USAGE 已成文。
+ * - **崩溃丢审计行**(F3):「清过就必响亮」以**进程活到 emitOutcome** 为界。清列与写元表是两条各自
+ *   autocommit 的语句,日志在回读之后才发 ⇒ 清完即崩 ⇒ 下次 boot 元表无行、向量已 NULL ⇒ 走 E 态报
+ *   「没有向量可清」;写完元表即崩 ⇒ 下次 boot 判 B 态、**一条日志都不发**。**数据面安全**(次序钉买的
+ *   正是这个:绝不残留旧空间),丢的只有那一次的 cleared 计数。刻意**不做**两阶段 pending marker ——
+ *   为纯审计价值给 boot 路加一张表 + 两阶段协议,代价与收益不成比例;承诺句在 USAGE 已标出这条边界。
+ *
  * 计数取法:`PgQueryResult` 刻意无 `rowCount` ⇒ 用 CTE `WITH c AS (UPDATE … RETURNING 1) SELECT
  * count(*)::int`(禁 `RETURNING id` 全表拉回)。计数**按整次调用累计**、原因锚在第一次真清的那一轮 ——
  * 「清过就必响亮」对终局判 B 的那一支同样成立(codex R2 finding 2)。
@@ -57,6 +70,16 @@
  *
  * 主动回填件(清空后不回填,行被 patch 时自然重嵌)/ 行级 embedder 记账列(结构性根治滚动窗)/
  * pgvector 接线件的列 dim 校验 / TiDB 向量面(v1 lexical only)。
+ *
+ * 🔴 **不回填的真代价(#234 定界车 2026-08-14 实测更正,稿 §4/§V3 说轻了一档)**:稿把代价写成「那些行
+ * 长期停留 lexical 档」,读起来像**排序退化**;真码是**可达性悬崖**——`memory-engine-pg.ts` 的进程内腿
+ * 对无向量行落 `jaccardDistance`,core 的该函数在**零词交集**时返回 `null`,`search` 当场 `continue`,
+ * 行被**丢出结果集**;仍有向量的行则走余弦、不被这道门丢(前提是查询侧也嵌得出来——embedder 故障那一
+ * 刻查询拿不到向量,整轮退词面档,零交集的行一起丢)。即清空之后、重嵌之前,那些行对改述/同义/跨
+ * 语言查询**检索不到**——而那恰恰是向量档存在的理由。真库端到端实证:db-integration 套件「清空后的
+ * 代价」一钉(清空前 "zulu" 命中该行,清空后同查询恒空,有字面交集的查询仍命中)。
+ * ⚠️ 这条只更正**成文口径**,不改裁定:主动回填仍在射程外(clay 已否);但将来复裁该件时,输入应当是
+ * 「可达性悬崖」而不是「排序退化」。
  */
 import { z } from "zod";
 import type { Logger } from "../observability/logger.js";

package/dist/plugins/memory-embedder-fingerprint.js

@@ -49,6 +49,19 @@
  * 3. **门自身失败 = 抛(拒启)**。吞掉 = 元表停留旧值 = 下次 boot 再清一次,把一次性代价变成每次 boot
  *    的代价;且「门在场但没跑成」静默 = fail-open。
  *
+ * ## 两条已知残余(codex 对抗复审 R1-F1/R1-F3,均判为真;处置=成文,不落码面)
+ *
+ * - **跨门回滚**(F1):指纹门**之前**的版本(7.14.x/7.15.x:有 embedder、无本门)照写 `embedding` 列却
+ *   不认识元表 ⇒「装本版(元表=B)→ 回滚旧版跑一段(写 A 空间向量)→ 升回本版仍配 B」走完,元表与配置
+ *   都说 B 而列里是 A 空间 ⇒ 此后恒判 B 态。**与滚动窗是同一族**(第二写者不维护指纹),码面根治只有
+ *   行级记账列 —— 稿已列出界(触主表删库重建窗)。纪律面处置与滚动窗同:回滚前后手动清列,或删掉
+ *   元表那一行让下次 boot 按 D 态保守清。USAGE 已成文。
+ * - **崩溃丢审计行**(F3):「清过就必响亮」以**进程活到 emitOutcome** 为界。清列与写元表是两条各自
+ *   autocommit 的语句,日志在回读之后才发 ⇒ 清完即崩 ⇒ 下次 boot 元表无行、向量已 NULL ⇒ 走 E 态报
+ *   「没有向量可清」;写完元表即崩 ⇒ 下次 boot 判 B 态、**一条日志都不发**。**数据面安全**(次序钉买的
+ *   正是这个:绝不残留旧空间),丢的只有那一次的 cleared 计数。刻意**不做**两阶段 pending marker ——
+ *   为纯审计价值给 boot 路加一张表 + 两阶段协议,代价与收益不成比例;承诺句在 USAGE 已标出这条边界。
+ *
  * 计数取法:`PgQueryResult` 刻意无 `rowCount` ⇒ 用 CTE `WITH c AS (UPDATE … RETURNING 1) SELECT
  * count(*)::int`(禁 `RETURNING id` 全表拉回)。计数**按整次调用累计**、原因锚在第一次真清的那一轮 ——
  * 「清过就必响亮」对终局判 B 的那一支同样成立(codex R2 finding 2)。
@@ -57,6 +70,16 @@
  *
  * 主动回填件(清空后不回填,行被 patch 时自然重嵌)/ 行级 embedder 记账列(结构性根治滚动窗)/
  * pgvector 接线件的列 dim 校验 / TiDB 向量面(v1 lexical only)。
+ *
+ * 🔴 **不回填的真代价(#234 定界车 2026-08-14 实测更正,稿 §4/§V3 说轻了一档)**:稿把代价写成「那些行
+ * 长期停留 lexical 档」,读起来像**排序退化**;真码是**可达性悬崖**——`memory-engine-pg.ts` 的进程内腿
+ * 对无向量行落 `jaccardDistance`,core 的该函数在**零词交集**时返回 `null`,`search` 当场 `continue`,
+ * 行被**丢出结果集**;仍有向量的行则走余弦、不被这道门丢(前提是查询侧也嵌得出来——embedder 故障那一
+ * 刻查询拿不到向量,整轮退词面档,零交集的行一起丢)。即清空之后、重嵌之前,那些行对改述/同义/跨
+ * 语言查询**检索不到**——而那恰恰是向量档存在的理由。真库端到端实证:db-integration 套件「清空后的
+ * 代价」一钉(清空前 "zulu" 命中该行,清空后同查询恒空,有字面交集的查询仍命中)。
+ * ⚠️ 这条只更正**成文口径**,不改裁定:主动回填仍在射程外(clay 已否);但将来复裁该件时,输入应当是
+ * 「可达性悬崖」而不是「排序退化」。
  */
 import { z } from "zod";
 import { PG_MEMORY_ENGINE_TABLES } from "./memory-engine-pg.js";
@@ -187,7 +210,11 @@ export async function reconcileEmbedderFingerprint(query, identity, opts = {}) {
                 reason: firstClear?.reason ?? firstChange?.reason ?? terminalState, // "changed" | "unattributed" | "unreadable"
                 rounds,
                 elapsedMs,
-                note: `${SCALE_ZERO_NOTE}; cleared vectors are NOT backfilled — rows re-embed as they are next written (retrieval falls back to the lexical floor meanwhile)`,
+                // 🔴 代价按真码说(#234 定界车实测,真库端到端钉在 db-integration 的「清空后的代价」):
+                // 「退回 lexical」是**说轻了**——词面档对与查询**零词交集**的行返回「无定义」,检索当场把该行
+                // 跳过,于是清空之后、重嵌之前,那些行对改述/同义/跨语言查询是**不可达**的(带向量的行则恒有
+                // 余弦读数、永不被丢)。operator 看见这条日志的那一刻就该知道丢的是可达性,不是名次。
+                note: `${SCALE_ZERO_NOTE}; cleared vectors are NOT backfilled — rows re-embed only as they are next written, and until then each cleared row is reachable ONLY by a query sharing a literal term with it (the lexical floor drops a row with zero term overlap, whereas a row that still has a vector is scored by cosine as long as the query embeds too) — rewrite the corpus to restore vector reach immediately`,
             });
             return;
         }

package/dist/plugins/memory-engine-tidb.js

@@ -25,6 +25,7 @@ import { jaccardDistance, termSet } from "@sema-agent/core";
 import { computeEntryRev, serializeEntryFile } from "@sema-agent/core";
 import { pgHasUnstorable } from "./pg-safe-json.js";
 import { assertSlugWidth } from "./memory-key-guards.js"; // R5 批γ:slug 写前宽守卫
+import { isMysqlDupKeyError } from "./sql-errors.js";
 /** Table names (single source) — SAME names as PG_MEMORY_ENGINE_TABLES (the two dialects never share
  *  one database), deliberately DISJOINT from the legacy `agent_memory*` MemoryStore plane. */
 export const TIDB_MEMORY_ENGINE_TABLES = {
@@ -58,11 +59,8 @@ export async function ensureTiDBMemoryEngineSchema(pool) {
     PRIMARY KEY (scope)
   ) COLLATE utf8mb4_bin`);
 }
-function isDupEntry(err) {
-    if (typeof err !== "object" || err === null)
-        return false;
-    return err.code === "ER_DUP_ENTRY" || err.errno === 1062;
-}
+/** 判据属主 = `sql-errors.ts`(A-032 P1-①;本站点旧形已是并集形,收编后语义不变)。 */
+const isDupEntry = isMysqlDupKeyError;
 /** ER_DUP_ENTRY messages name the violated key (`… for key 'tbl.PRIMARY'` / `… for key 'tbl.uq_agent_memory_engine_entry_scope_slug'`)
  *  — the add path uses this to tell "id already exists (→ overwrite leg)" from "slug race (→ -n retry)". */
 function isPrimaryKeyDup(err) {

package/dist/plugins/memory-engine-vector-util.d.ts

@@ -1,7 +1,2 @@
-/** memory-engine 方言实现共用的纯工具函数。三个距离/词集函数(termSet/jaccardDistance/cosineDistance)
- *  在 core(1.268.0 起公开导出,单一语义源)——消费者直引 core([2354] 兼容面全清:此处转口已删)。
- *  `isUniqueViolation` 重新内联:它当年随 core 的 pg **示例适配器**导出面走,core 1.424 按 clay 包卫生令
- *  把整个 examples 面退出 npm 包([1803] BREAKING)⇒ re-export 断源。逐字抄自 core 1.423
- *  `examples/adapters/pg-adapter.js`(纯谓词,无 byte-equal 契约约束)。 */
 export declare function isUniqueViolation(err: unknown): boolean;
 //# sourceMappingURL=memory-engine-vector-util.d.ts.map

package/dist/plugins/memory-engine-vector-util.js

@@ -1,13 +1,19 @@
 /** memory-engine 方言实现共用的纯工具函数。三个距离/词集函数(termSet/jaccardDistance/cosineDistance)
  *  在 core(1.268.0 起公开导出,单一语义源)——消费者直引 core([2354] 兼容面全清:此处转口已删)。
  *  `isUniqueViolation` 重新内联:它当年随 core 的 pg **示例适配器**导出面走,core 1.424 按 clay 包卫生令
- *  把整个 examples 面退出 npm 包([1803] BREAKING)⇒ re-export 断源。逐字抄自 core 1.423
- *  `examples/adapters/pg-adapter.js`(纯谓词,无 byte-equal 契约约束)。 */
+ *  把整个 examples 面退出 npm 包([1803] BREAKING)⇒ re-export 断源。原为逐字抄自 core 1.423
+ *  `examples/adapters/pg-adapter.js`(纯谓词,无 byte-equal 契约约束);A-032 P1-① 后**码面判据**
+ *  改走属主 `sql-errors.ts`,只留 message 补充臂(理由在函数体内)。 */
+import { isPgUniqueViolation } from "./sql-errors.js";
 export function isUniqueViolation(err) {
+    // 码面判据 = 属主谓词(A-032 P1-①,`plugins/sql-errors.ts`)。
+    if (isPgUniqueViolation(err))
+        return true;
+    // 🔴 message 正则臂是**本站点的显式补充**,不上提属主:memory-engine 的 pg 腿吃的是**裸 PgQueryFn**
+    // (调用方自带的连接封装),错误对象未必是 node-pg 的原生错误类——中间层可能只把 message 传下来。
+    // 其余各店都攥着自己的驱动/池,拿得到带 SQLSTATE 的原错误,不需要也不该按文案分支(#90 门②)。
     if (typeof err !== "object" || err === null)
         return false;
-    if (err.code === "23505")
-        return true;
     return /duplicate key|unique constraint|already exists/i.test(String(err.message ?? ""));
 }
 //# sourceMappingURL=memory-engine-vector-util.js.map

package/dist/plugins/memory-run-store.d.ts

@@ -13,6 +13,7 @@
 import { type UsageRow } from "../usage-analytics.js";
 import type { TaskResult, TaskStatus } from "@sema-agent/core";
 import type { RunRecord, SessionSummary, RunEvent } from "./store-contracts.js";
+import type { LedgerEventType } from "../trace/ledger-events.js";
 /**
  * [868] P0 — the local lane's stand-in for the SQL twins' checkpoint-table JOIN. The file/memory run stores
  * cannot JOIN `checkpoint` (separate store, separate files), so the suspended-run reapers were NO-OPs — which
@@ -59,7 +60,7 @@ export declare class MemoryRunStore {
     requestPreempt(taskId: string, owner: string | null): Promise<boolean>;
     isPreemptRequested(taskId: string, owner: string | null): Promise<boolean>;
     heartbeat(taskId: string, owner: string | null): Promise<void>;
-    appendEvent(taskId: string, seq: number, type: string, data: unknown): Promise<void>;
+    appendEvent(taskId: string, seq: number, type: LedgerEventType, data: unknown): Promise<void>;
     maxSeq(taskId: string): Promise<number>;
     retainedFrom(taskId: string): Promise<number>;
     getEvents(taskId: string, afterSeq: number): Promise<RunEvent[]>;