@sema-agent/server 7.137.0 → 7.138.0

package/dist/boot/deployment-mods.d.ts

@@ -1,31 +1,61 @@
+import { type EngineDollar, type ModAdmissionRecord, type ModRegistration } from "@sema-agent/core";
+import { type ModsDeclaration } from "../mods-declaration.js";
+import type { Logger } from "../observability/logger.js";
+import type { Metrics } from "../observability/metrics.js";
 /**
- * 部署座(`RunnerDeps.mods`)的注册:**铸**({@link createDeploymentMods})与**起服自证**({@link assertDeploymentModsAdmitted})都在这一处。
- *
- * 起服自证(律三:拒形只有引擎一种读法,本仓只负责「不写」与「启动时自证」):
- * 部署座上的注册是本仓自己铸的。它们坏了
- * —— 坏名、坏档、缺 `uses.calls`、`on` 越出 `uses`、只选无站的名字、`register` 抛 —— 引擎在每条腿的 prepare 里拒
- * (`config.mods_invalid`),那就是每个请求都失败。所以起服时让引擎的 admission 判一次:判官仍是引擎(`admitModChain`),
- * 本函数不判形,只把它的拒折成一句起服错误、拒启。两个起服入口(server 第五段、本地 CLI)同调这一只。
+ * 部署座注册的**出处标签**(谁供的这张注册)—— 宿主自己的词,引擎原样携带、不判;**全仓唯一写点**。
  *
- * 也拒启的两形(同一个理由:部署注册一张都不该缺席,也不该带病挂上):
- *  · admission 期的报告(引擎对坏 `budgetMs` 只报告、回落缺省,不拒)—— 部署注册不设 `budgetMs`,报告出现就是铸法坏了;
- *  · 被 `plugin.register` 判拒的注册(本部署没有这种判官;出现即装配错)。
- * 腿外 admission 只建一只总线并跑一次各注册的 `register`(本仓的 `register` 是纯函数),不碰任何腿。
+ * `wiring_manifest.mods[]` 的一行上有两个词字段,各自一张闭集、互不相交:`seat` 是引擎的座词(`MOD_SEATS`:`deployment` | `task`,这张注册站在哪一座),
+ * `provenance` 是这张表的值(这张注册是谁供的)。两个字段不共用词 —— 同一个词不在一行里指两件事。
+ *  · `minted` → `server`:本服务自己铸的(拒绝计量 / 工具追踪 / 品牌行);
+ *  · `declared` → `operator`:运维在部署声明(`MODS_ROOT` / `MODS_PACKAGES`)里点名装进来的包。词取「谁供的」:与 `server` 同一个维度(供给方),
+ *    并沿用本仓对这件事的既有称呼「运维声明」。不用 `deployment`:它是座词,同一行上同形不同义。
+ * 加一种供给方 = 在这里加一行;取到的词与座词相交 ⇒ 下面的类型门编译红。
  */
-import { type EngineDollar, type ModRegistration } from "@sema-agent/core";
-import type { Logger } from "../observability/logger.js";
-import type { Metrics } from "../observability/metrics.js";
+export declare const MOD_PROVENANCE: {
+    readonly minted: "server";
+    readonly declared: "operator";
+};
 /**
- * 部署座上的注册列表 —— 两个起服入口(server 第五段与本地 CLI)同一只铸法,哪几张、什么顺序只写在这里:
+ * 本仓自铸的部署注册 —— 哪几张、什么顺序只写在这里(装配口 {@link assembleDeploymentMods} 把它们排在声明的包之前):
  *  · 拒绝计量恒挂、在前;工具追踪(`TOOL_TRACE=true`,交 `traceLogger`)在后。两张都是 `prepend` 档的观察者,引擎按「档 → 部署先于任务 → 座内顺序」
  *    串行跑观察者、且都在链之前 ⇒ 同一次拒绝先计数、后写追踪行;
  *  · 品牌行(`brandIdentity`:品牌部署 = local / TOC)—— `prompt.compose` 上的一条部署类 overlay(`capabilities/brand-identity.ts`),与两只观察者
  *    不在同一个事件上,顺序不影响它们。部署开不开品牌只在这一个入参表态。
+ * 出处标签:自铸的每一张都带宿主标签 {@link MOD_PROVENANCE}`.minted`,声明的包由装配口给 `.declared` —— 引擎把宿主给的标签原样记进准入记录与每条腿的
+ * `wiring_manifest.mods[]`,一条腿的部署座由此分得出「本服务自铸」与「运维声明」两种来源。
  */
 export declare function createDeploymentMods(input: {
     readonly metrics: Pick<Metrics, "inc">;
     readonly traceLogger?: Logger | undefined;
     readonly brandIdentity?: boolean | undefined;
 }): readonly ModRegistration<EngineDollar>[];
-export declare function assertDeploymentModsAdmitted(mods: readonly ModRegistration<EngineDollar>[]): Promise<void>;
+/** 起服装上的一只声明包(起服日志行 `mods_package_loaded` 与 `/health` / `/v1/capabilities` 的读数都读这一份)。 */
+export interface LoadedModPackage {
+    readonly name: string;
+    /** 引擎准入记录里这只包站的档(准入判过的那一份,不是声明里写的)。 */
+    readonly tier: ModAdmissionRecord["tier"];
+    /** 读包者按相等判过的引擎契约号(包声明的 `contract` 与引擎的 `KERNEL_CONTRACT_VERSION` 相等才装得上)。 */
+    readonly contract: number;
+    /** 读包者交回的三件字节摘要(`ModPackageRegistration.digest`,按给值记)—— 认得出「装的是哪几份字节」,不是代码完整性凭据。 */
+    readonly digest: string;
+}
+/** 装配的结果:部署座的注册(自铸在前、声明在后,整列已过引擎准入)与装上的声明包(只数声明的包,自铸的不算)。 */
+export interface DeploymentModsAssembly {
+    readonly registrations: readonly ModRegistration<EngineDollar>[];
+    readonly loaded: readonly LoadedModPackage[];
+}
+/** 部署座的唯一装配口(两只起服入口同调;三段与失败见文件头注)。 */
+export declare function assembleDeploymentMods(input: {
+    readonly metrics: Pick<Metrics, "inc">;
+    readonly traceLogger?: Logger | undefined;
+    readonly brandIdentity?: boolean | undefined;
+    readonly declaration: ModsDeclaration;
+    readonly logger: Pick<Logger, "info">;
+}): Promise<DeploymentModsAssembly>;
+/**
+ * 第三段:整列交引擎准入判一次(判官是引擎;本函数不判形,只把它的拒、报告与判拒折成一句 `admission_refused`)。
+ * 过了 ⇒ 交回这一次准入的记录(每张注册一行,全部挂上了 —— 有一行被判拒就不会走到这里)。
+ */
+export declare function assertDeploymentModsAdmitted(mods: readonly ModRegistration<EngineDollar>[]): Promise<readonly ModAdmissionRecord[]>;
 //# sourceMappingURL=deployment-mods.d.ts.map

package/dist/boot/deployment-mods.js

@@ -1,26 +1,102 @@
-import { admitModChain } from "@sema-agent/core";
+import { realpathSync, statSync } from "node:fs";
+import { isAbsolute, relative, sep } from "node:path";
+import { admitModChain, KERNEL_CONTRACT_VERSION, loadModPackage } from "@sema-agent/core";
 import { createBrandIdentityRegistration } from "../capabilities/brand-identity.js";
 import { createPermissionDeniedMeter, createToolTracer } from "../observability/tool-trace.js";
+import { errorCodeOf, errorText } from "../observability/err-text.js";
+import { sanitizeWireText } from "../trace/engine-notice-wire.js";
+import { DeploymentModsRefusedError } from "../mods-declaration.js";
+export const MOD_PROVENANCE = { minted: "server", declared: "operator" };
 export function createDeploymentMods(input) {
     return [
         createPermissionDeniedMeter(input.metrics),
         ...(input.traceLogger !== undefined ? [createToolTracer(input.traceLogger)] : []),
         ...(input.brandIdentity === true ? [createBrandIdentityRegistration()] : []),
-    ];
+    ].map((registration) => ({ ...registration, provenance: MOD_PROVENANCE.minted }));
+}
+export async function assembleDeploymentMods(input) {
+    const minted = createDeploymentMods(input);
+    const resolved = resolveDeclaredPackages(input.declaration);
+    const declared = [];
+    for (const { pkg, realDir } of resolved)
+        declared.push(await loadDeclaredPackage(pkg, realDir));
+    const registrations = [...minted, ...declared];
+    const records = await assertDeploymentModsAdmitted(registrations);
+    const loaded = resolved.map(({ pkg }, i) => ({ name: pkg.name, tier: admittedRecordOf(records, pkg.name).tier, contract: KERNEL_CONTRACT_VERSION, digest: declared[i].digest }));
+    for (const row of loaded)
+        input.logger.info("mods_package_loaded", { name: sanitizeWireText(row.name), tier: row.tier, contract: row.contract, digest: row.digest });
+    return { registrations, loaded };
+}
+function fsCauseOf(e) {
+    const code = errorCodeOf(e);
+    return typeof code === "string" && /^E[A-Z0-9]{1,31}$/.test(code) ? code : "unknown";
+}
+function strictlyUnderRoot(root, child) {
+    const rel = relative(root, child);
+    return rel !== "" && rel.split(sep)[0] !== ".." && !isAbsolute(rel);
+}
+function resolveDeclaredPackages(declaration) {
+    if (declaration.packages === undefined)
+        return [];
+    let realRoot;
+    try {
+        realRoot = realpathSync(declaration.root);
+    }
+    catch (e) {
+        throw new DeploymentModsRefusedError({ word: "root_unreadable", cause: fsCauseOf(e) });
+    }
+    return declaration.packages.map((pkg, entry) => {
+        let realDir;
+        let isDirectory;
+        try {
+            realDir = realpathSync(pkg.dir);
+            isDirectory = statSync(realDir).isDirectory();
+        }
+        catch (e) {
+            throw new DeploymentModsRefusedError({ word: "dir_unreadable", entry, cause: fsCauseOf(e) });
+        }
+        if (!strictlyUnderRoot(realRoot, realDir))
+            throw new DeploymentModsRefusedError({ word: "outside_root", entry });
+        if (!isDirectory)
+            throw new DeploymentModsRefusedError({ word: "not_a_directory", entry });
+        return { pkg, realDir };
+    });
+}
+function machineCodeOf(e) {
+    const code = errorCodeOf(e);
+    return typeof code === "string" && /^[A-Za-z][A-Za-z0-9_.-]{0,63}$/.test(code) ? code : undefined;
+}
+async function loadDeclaredPackage(pkg, realDir) {
+    let registration;
+    try {
+        registration = await loadModPackage(realDir, { tier: pkg.tier, provenance: MOD_PROVENANCE.declared, ...("options" in pkg ? { options: pkg.options } : {}) });
+    }
+    catch (e) {
+        throw new DeploymentModsRefusedError({ word: "package_refused", name: pkg.name, code: machineCodeOf(e), reason: errorText(e) });
+    }
+    if (registration.name !== pkg.name)
+        throw new DeploymentModsRefusedError({ word: "name_mismatch", name: pkg.name, packageName: registration.name });
+    return registration;
 }
-const REFUSED = "deployment extension registration refused";
 export async function assertDeploymentModsAdmitted(mods) {
     const reports = [];
     let records;
     try {
-        ({ records } = await admitModChain({ deployment: mods }, (err) => void reports.push(err.message)));
+        ({ records } = await admitModChain({ deployment: mods }, (err) => void reports.push(errorText(err))));
     }
     catch (e) {
-        throw new Error(`${REFUSED}: ${e instanceof Error ? e.message : String(e)}`);
+        throw new DeploymentModsRefusedError({ word: "admission_refused", code: machineCodeOf(e), reason: errorText(e) });
     }
     const refused = records.flatMap((r) => ("refusedBy" in r ? [`"${r.name}" refused by ${r.refusedBy}: ${r.reason}`] : []));
     const problems = [...reports, ...refused];
     if (problems.length > 0)
-        throw new Error(`${REFUSED}: ${problems.join("; ")}`);
+        throw new DeploymentModsRefusedError({ word: "admission_refused", code: undefined, reason: problems.join("; ") });
+    return records;
+}
+function admittedRecordOf(records, name) {
+    const record = records.find((r) => r.seat === "deployment" && r.name === name);
+    if (record === undefined)
+        throw new DeploymentModsRefusedError({ word: "admission_refused", code: undefined, reason: `the engine's admission returned no record for ${JSON.stringify(name)}` });
+    return record;
 }
 //# sourceMappingURL=deployment-mods.js.map

package/dist/boot/governance-seams.d.ts

@@ -41,13 +41,13 @@
  *
  * ## 件D 的边界(成文,别读成「数据会被删」)
  *
- * 本仓**没有任何** store 声明 `retention:"managed"`(亲验:session/checkpoint/tool-result 三族 SQL 双生
- * 与 local 形都没有这一位),托管留存的执行面(调度/重试/副本协调/逐行审计)按 §5.2 是「server 半场四件
- * 皆新建」,不在本批。所以本装配点对件D 只做两件事:①把策略递给 core 的启动期校验
- * (`assertRetentionCapability` —— 锁着 + 店不能删 ⇒ 拒启,「策略锁着、数据永存」不许发生);②策略在场
- * 而没有任何 managed 店时打一条响亮 warn。**不**假装有执行面。
+ * 三只被托管的 SQL 店(session / checkpoint / tool-result)的 `retention` 声明读一个事实 —— 留存扫车道开不开(`plugins/retention-store-sql.ts` 的
+ * `retentionSweepRuns`):开 ⇒ `managed`,关(缺省)⇒ `none`;local 形的店恒声明 `none`。删除的执行面是扫车道(`boot/retention-lane.ts`)与 SQL 店上的
+ * 执行器,不在本装配点。所以本装配点对件D 只做两件事:①把策略与执行器递给 core 的启动期校验
+ * (`assertRetentionCapability` —— 配对由引擎一个判官判:店声明 `managed` 而部署不跑执行器、执行器不是执行器,锁不锁都拒;锁着 + 店不能删 ⇒ 拒启,
+ * 「策略锁着、数据永存」不许发生);②策略在场而没有任何 managed 店时打一条响亮 warn。**不**假装有执行面。
  */
-import { type LockedKey, type RunnerDeps } from "@sema-agent/core";
+import { type LockedKey, type ManagedRetentionCapability, type RunnerDeps } from "@sema-agent/core";
 import type { ServiceConfig } from "../config.js";
 import type { Logger } from "../observability/logger.js";
 /** 装配产物:三个 core 座席 + 已校验的锁集(同步拒面 `assertRequestMcpUnlocked` 读它)。 */
@@ -72,18 +72,11 @@ export interface GovernanceSeamsCtx {
         store: object | undefined;
     }>;
     /**
-     * [ref] 车1 —— **本 build 是否真的接了留存执行器**(sweep lane;车2 的 `startRetentionLane()`)。
-     * 缺席 = `false`。
-     *
-     * 🔴 为什么这一位必须存在(codex 交叉复审 R2-[critical],验真后修):core 的
-     * `assertRetentionCapability` 只读**店的声明位**。[ref] 车1 让三只 SQL 店如实声明了 `"managed"`
-     * (它们的行确实由托管留存删),于是那道门从此**放行** locked policy —— 可执行器还在车2 手里。
-     * 两者之间的窗口如果什么都不做,后果正是本仓最忌的那种:部署自述「策略已受管」、审计与能力面
-     * 也这么说,而**没有任何东西在删数据**;车1 之前那条 `retention_policy_not_executed` 的响亮 warn
-     * 还会因为"有 managed 店在场"而**静音**。
-     * ⇒ 判据改成问「有没有东西真会删」,而不是「有没有店说自己被管」。车2 接上 lane 时把这一位传 true。
+     * 交给引擎启动检查的留存执行器 —— 本部署跑扫车道 ⇒ 那只执行器(`backend.retention`),不跑 ⇒ `null`(必填:漏递即编译红,
+     * 引擎对 `undefined` 也拒启)。「店说 managed」与「有执行器」的配对由引擎一个判官判(引擎 7.58.0:锁不锁都判);
+     * 店的词与这一格读同一个事实(`retention-store-sql.ts` 的 `retentionSweepRuns`),本仓不再另判一遍。
      */
-    retentionExecutorWired?: boolean;
+    retentionExecutor: ManagedRetentionCapability | null;
 }
 /**
  * 件C 的装配相容性判据(纯,可单测)——见文件头「两条判据」。

package/dist/boot/governance-seams.js

@@ -49,30 +49,18 @@ export function createGovernanceSeams(ctx) {
     }
     const retentionPolicy = config.retentionPolicy;
     const locked = lockedKeys.has("retentionPolicy");
-    assertRetentionCapability({ policy: retentionPolicy, locked, stores: retentionStores });
+    assertRetentionCapability({ policy: retentionPolicy, locked, stores: retentionStores, executor: ctx.retentionExecutor });
     if (retentionPolicy !== undefined) {
         const managed = retentionStores.filter((s) => s.store?.retention === "managed");
-        const executorWired = ctx.retentionExecutorWired === true;
         if (managed.length === 0) {
             logger.warn("retention_policy_not_executed", {
                 maxAgeDays: retentionPolicy.maxAgeDays,
-                note: "RETENTION_MAX_AGE_DAYS is configured but NO wired store declares retention:\"managed\", and this build ships no " +
-                    "retention scheduler — the policy is a DECLARATION only; nothing deletes data on its account. It is relayed to the " +
-                    "engine for the startup capability check and will become effective when a managed-retention store + scheduler land.",
+                note: "RETENTION_MAX_AGE_DAYS is configured but NO wired store declares retention:\"managed\" (the retention sweep lane is off — " +
+                    "RETENTION_SWEEP_INTERVAL_SEC unset or 0 — or the store medium has no sweep) — the policy is a DECLARATION only; nothing " +
+                    "deletes data on its account. It is relayed to the engine for the startup capability check; run the sweep lane on a SQL " +
+                    "backend to make it effective.",
             });
         }
-        else if (!executorWired) {
-            const detail = `retention policy is configured (maxAgeDays=${retentionPolicy.maxAgeDays}) and ${managed.length} wired store(s) declare ` +
-                `retention:"managed", but THIS BUILD WIRES NO RETENTION EXECUTOR (the sweep lane) — nothing enumerates domains or calls ` +
-                `the destructive store methods, so no data is deleted on the policy's account. A "managed" declaration is a statement ` +
-                `about who OWNS deleting those rows, not proof that a scheduler is running.`;
-            if (locked) {
-                throw new Error(`${detail} Refusing to start with the retentionPolicy key LOCKED: a locked policy over a deployment that does not ` +
-                    `actually delete is exactly the "policy locked, data immortal" posture the engine's capability check exists to ` +
-                    `prevent. Unlock the key, remove the policy, or run a build whose retention sweep lane is wired.`);
-            }
-            logger.warn("retention_policy_not_executed", { maxAgeDays: retentionPolicy.maxAgeDays, note: detail });
-        }
     }
     return { compliancePostureResolver, lockedConfig, retentionPolicy, lockedKeys };
 }

package/dist/boot/leader.d.ts

@@ -49,6 +49,9 @@ export interface LeaderCtx {
      *  唯一出口就是它(`runtask.js` 的 `catch (flushErr) => deps.onError`),所以它与 `usageWindowStore`
      *  席同生共死:挂窗不挂汇 = 治理轴上的静默失败面([ref])。必填键,理由同 `tracer`。 */
     onError: RunnerDeps["onError"];
+    /** 部署座 —— 起服第 5 段装配口 `assembleDeploymentMods` 交回的**同一份**(主车道各 Runner 经共享基座吃的就是它)。leader 车道的每一只 Runner 都要带:
+     *  缺席 = 运维声明的 mod 包管不到 leader 派出的腿。必填键,理由同 `tracer`。 */
+    deploymentMods: NonNullable<RunnerDeps["mods"]>;
     /** [ref] 车4 件1:durable store 后端(leader-run 登记表从这里取)。缺席 = 无 DB 的 env-only worker。 */
     backend?: StoreBackend | undefined;
 }

package/dist/boot/leader.js

@@ -59,6 +59,7 @@ export function createLeaderFace(ctx) {
                 : {}),
             ...(ctx.promptSource ? { promptSource: ctx.promptSource } : {}),
             ...(ctx.onError ? { onError: ctx.onError } : {}),
+            mods: ctx.deploymentMods,
             fanoutEnabled: config.leaderFanoutEnabled,
             ...((process.env.MODEL_ROUTER_ID || process.env.MODEL_CHEAP_ID)
                 ? { routerModel: (process.env.MODEL_ROUTER_ID || process.env.MODEL_CHEAP_ID) }

package/dist/boot/org-delivery.js

@@ -1,5 +1,17 @@
 import { principalInboxConsumerOf } from "@sema-agent/core";
 import { createOrgDeliveryGate } from "../org-delivery-gate.js";
+function declarationOf(consumer) {
+    switch (consumer.kind) {
+        case "assistant":
+            return { declared: "PRINCIPAL_INBOX_ASSISTANT declares a principal-inbox consumer", undeclare: "unset PRINCIPAL_INBOX_ASSISTANT" };
+        case "terminals":
+            return { declared: 'RunnerDeps.principalInboxConsumer declares "terminals" (the scope\'s terminal sessions drain the principal inbox)', undeclare: "drop the RunnerDeps.principalInboxConsumer declaration" };
+        default: {
+            const unknown = consumer;
+            throw new Error(`unknown principal-inbox consumer kind: ${JSON.stringify(unknown)}`);
+        }
+    }
+}
 export function mountOrgDeliveryGate(input) {
     const consumer = principalInboxConsumerOf(input.runnerDeps);
     if (consumer.kind === "none")
@@ -11,8 +23,9 @@ export function mountOrgDeliveryGate(input) {
             ...(directory === undefined ? ["an organization membership directory (a web-admin center, or MEMORY_ORG_DIRECTORY_JSON)"] : []),
             ...(backend === undefined ? ["a store backend for the delivery quota (DB_BACKEND=mysql|pg|local)"] : []),
         ];
-        throw new Error(`PRINCIPAL_INBOX_ASSISTANT declares a principal-inbox consumer, so this deployment must mount the organization delivery gate — but it lacks ${missing.join("; ")}. ` +
-            `Refusing to boot rather than run with a declared inbox that nothing may legitimately write to; provide the missing pieces or unset PRINCIPAL_INBOX_ASSISTANT.`);
+        const { declared, undeclare } = declarationOf(consumer);
+        throw new Error(`${declared}, so this deployment must mount the organization delivery gate — but it lacks ${missing.join("; ")}. ` +
+            `Refusing to boot rather than run with a declared inbox that nothing may legitimately write to; provide the missing pieces or ${undeclare}.`);
     }
     input.logger.info("org_delivery_gate_mounted", { consumer: consumer.kind });
     return createOrgDeliveryGate({ directory, mailbox: mailboxStore, quota: backend.orgDeliveryQuota(), consumer });

package/dist/boot/resolve-spec.d.ts

@@ -18,6 +18,7 @@ import { type TaskAttachmentStore } from "../plugins/task-attachment-store.js";
 import { type createPrincipalEntitlementsClient } from "../runtime-caps-resolver.js";
 import { type OwnerAwareSessionStore } from "../security.js";
 import type { MemorySyncRunner } from "../memory-sync-client.js";
+import type { PeerDesk } from "../peer-seat.js";
 import type { RunnerDepsOnAsk } from "./runner-deps.js";
 type PrincipalCaps = ReturnType<typeof createPrincipalEntitlementsClient>;
 /** `resolveSpec` 原先从 `main()` 闭包里拿到的全部 boot 局部量。 */
@@ -84,6 +85,8 @@ export interface ResolveSpecCtx {
     /** [ref] 件C:本部署已校验的锁集(boot/governance-seams.ts 的产物,与 `RunnerDeps.lockedConfig`
      *  同源一次解析)。空集 = 无锁 = 现行为。本域只用它做**同步拒面**(§4.3),不做第二次裁决。 */
     lockedKeys: ReadonlySet<import("@sema-agent/core").LockedKey>;
+    /** 本进程的对端座 desk(stage-05 建、HTTP 服务的 `peerDesk` 同一只):请求面 MCP / A2A 的胜出草稿在 `opts.lease` 下经它登记,换回声明带的引用 —— 两只漏斗开的租约属于它。 */
+    peerDesk: PeerDesk;
     /** 本部署**装载簿**(stage-07 的出厂技能 + 配置源覆盖之后的终表,场景工厂读的同一份)。本装配器只拿它答「场景交来的这只技能来自哪里」
      *  (run 名册 `wiring_manifest.skills[].source`,`buildRunSkills`);名字在装载簿里唯一(装载器同名即抛、配置源按名覆盖)。 */
     loadedSkills: readonly LoadedSkill[];

package/dist/boot/resolve-spec.js

@@ -29,6 +29,7 @@ import { gateExecutionLane } from "../runtime-caps-resolver.js";
 import { applyRuntimeGovernance } from "../runtime-governance.js";
 import { HttpError, createCodedHttpError, encodeCheckpointScope } from "../security.js";
 import { headReadOf, sessionFaceOfHead } from "../session-incarnation.js";
+import { legProjectIdOf, sessionWorkspaceStoreOf, stampLegSessionWitness } from "../session-workspace.js";
 import { memorySpecForRequest } from "../memory-scope.js";
 import { createMemoryProjectLayers } from "../memory-project-layer.js";
 import { inheritEnvFacts, inheritEnvFieldIssue, singleMemberOffFieldIssue } from "../request-value-closure.js";
@@ -40,6 +41,7 @@ import { DEPLOYMENT_SHAPE_PREDICATES } from "../deployment-shape.js";
 import { assertRequestA2aEntries, resolveRequestA2a, snapshotRequestA2a } from "../task-a2a.js";
 import { assertRequestImageUrls } from "../request-image-urls.js";
 import { assertRequestMcpEntries, assertRequestMcpUnlocked, resolveRequestMcp } from "../task-mcp.js";
+import { GOVERNANCE_HTTP_STATUS } from "../governance-http-status.js";
 import { storedToolAxesRereadM19 } from "../stored-request-tool-axes-m19.js";
 import { storedHooksRereadM20 } from "../stored-request-hooks-m20.js";
 import { MAX_SETTINGS_OUTPUT_STYLE_CHARS, REQUEST_SETTINGS_REFUSAL_PREFIX, SETTINGS_RULE_REFUSAL_CODE, SettingsRuleRefusalError, acceptAppendSystemPrompt, applyTaskSettings, createWorkflowAskPolicy, effectivePermissionMode, effectiveThinking, parseTaskSettings, taskHooksHonored, settingsPermissionBucketIssue } from "../task-settings.js";
@@ -54,10 +56,11 @@ import { effectiveMemoryPersistenceCapable } from "./memory-boundary.js";
 import { withUnattendedLeg } from "../unattended-permission-mode.js";
 import { fieldConflictFacts } from "../field-conflict.js";
 export function createResolveSpec(ctx) {
-    const { config, logger, metrics, localRoot, scenarios, principalCaps, centerRuntimeCapsResolver, getKeyResolver, taskAttachmentStore, perSessionCwd, setSessionCwd, setSessionShellEnv, fenceSessionOwner, hookLlm, hookAgent, fleetBus, hookWakeBus, resumeAnchorStore, ownerAware, taskLimitCaps, taskTimeoutSec, selectEnvTool, sendUserFileToolSpec, memoryEngine, memorySyncRunner, durableEnabled, approvalExemptionStore, checkpointStore, imageIndex, perTaskImage, sessionEnvSelection, liveQuestionFace, approverSeat, lockedKeys, loadedSkills, } = ctx;
+    const { config, logger, metrics, localRoot, scenarios, principalCaps, centerRuntimeCapsResolver, getKeyResolver, taskAttachmentStore, perSessionCwd, setSessionCwd, setSessionShellEnv, fenceSessionOwner, hookLlm, hookAgent, fleetBus, hookWakeBus, resumeAnchorStore, ownerAware, taskLimitCaps, taskTimeoutSec, selectEnvTool, sendUserFileToolSpec, memoryEngine, memorySyncRunner, durableEnabled, approvalExemptionStore, checkpointStore, imageIndex, perTaskImage, sessionEnvSelection, liveQuestionFace, approverSeat, lockedKeys, loadedSkills, peerDesk, } = ctx;
     const deploymentSkillSources = new Map(loadedSkills.map((k) => [k.spec.name, k.source]));
     const scenarioGate = createScenarioGate({ config, scenarios, principalCaps, logger }, "enforce");
     const sessionHeadOf = headReadOf(ownerAware);
+    const sessionWorkspace = sessionWorkspaceStoreOf(ownerAware);
     assertGuardPatternsUsable(config);
     const onlySensitiveBaseline = buildOnlySensitiveBaselineWarning(config, {
         approvalSeat: durableEnabled ? "durable" : "absent",
@@ -80,6 +83,13 @@ export function createResolveSpec(ctx) {
         if (seatRefusal !== undefined)
             throw createCodedHttpError(501, "capability.checkpoint_store_required", seatRefusal);
         assertRequestMcpUnlocked(body.mcpServers, lockedKeys);
+        const storedToolAxes = opts?.leg === "fresh" ? undefined : storedToolAxesRereadM19(new Date().toISOString().slice(0, 10));
+        const a2aPeers = snapshotRequestA2a(body.a2aPeers, { reread: storedToolAxes !== undefined });
+        if (lockedKeys.has("a2a") && a2aPeers !== undefined && a2aPeers !== null) {
+            throw new HttpError(GOVERNANCE_HTTP_STATUS["config.locked_key"], "`a2aPeers` is administratively locked by this deployment (locked key \"a2a\") — task-supplied A2A peers are refused; locks are config-time and there is no request-time unlock", {
+                code: "config.locked_key",
+            });
+        }
         if (opts?.leg === "fresh")
             assertRequestMcpEntries(body.mcpServers);
         if (opts?.leg === "fresh") {
@@ -142,8 +152,6 @@ export function createResolveSpec(ctx) {
                 }
             }
         }
-        const storedToolAxes = opts?.leg === "fresh" ? undefined : storedToolAxesRereadM19(new Date().toISOString().slice(0, 10));
-        const a2aPeers = snapshotRequestA2a(body.a2aPeers, { reread: storedToolAxes !== undefined });
         if (opts?.leg === "fresh")
             assertRequestA2aEntries(a2aPeers);
         if (opts?.leg === "fresh")
@@ -167,12 +175,13 @@ export function createResolveSpec(ctx) {
             hostSemanticsLane: folded.hostSemanticsLane,
         });
         const stamped = stampHandsLane(final, gated.hands);
-        return stampRunSkills(stamped, runSkills.roster);
+        return stampLegSessionWitness(stampRunSkills(stamped, runSkills.roster), gated.sessionWitness);
     };
     const gateScenarioAndAppend = async (body, auth, opts) => {
         const scenarioName = await scenarioGate(auth?.principal, body.scenario);
         gateExecutionLane(await principalCaps?.executionRuling(auth?.principal), executionLaneOf(config.remoteExec?.provider), logger);
-        const cap = selectScenario(scenarios, scenarioName)(body, auth?.principal, auth?.sessionId !== undefined ? { sessionId: auth.sessionId, delegationRoot: { sessionId: auth.sessionId, incarnation: (sessionHeadOf === undefined ? undefined : sessionFaceOfHead(auth.sessionId, await sessionHeadOf(auth.sessionId)))?.incarnation ?? null } } : {});
+        const sessionWitness = auth?.sessionId !== undefined ? { sessionId: auth.sessionId, incarnation: (sessionHeadOf === undefined ? undefined : sessionFaceOfHead(auth.sessionId, await sessionHeadOf(auth.sessionId)))?.incarnation ?? null } : undefined;
+        const cap = selectScenario(scenarios, scenarioName)(body, auth?.principal, sessionWitness !== undefined ? { sessionId: sessionWitness.sessionId, delegationRoot: sessionWitness } : {});
         const acceptedAppend = acceptAppendSystemPrompt(body.appendSystemPrompt, (detail) => logger.warn("append_system_prompt_dropped", { detail, sessionId: auth?.sessionId ?? null }));
         const objective = typeof body.objective === "string" ? body.objective : "";
         const parsedSettings = parseTaskSettings(body.settings, opts?.leg === "fresh" || !taskHooksHonored(config) ? {} : { storedHooksReread: storedHooksRereadM20(new Date().toISOString().slice(0, 10)) });
@@ -222,7 +231,7 @@ export function createResolveSpec(ctx) {
                 }
             }
         }
-        return { scenarioName, cap, hands: cap.hands, acceptedAppend, objective, parsedSettings, attachmentNotice };
+        return { scenarioName, cap, hands: cap.hands, acceptedAppend, objective, parsedSettings, attachmentNotice, sessionWitness };
     };
     const bindSettingsCwdEnvAndModel = (body, auth, gated, opts) => {
         const { objective, parsedSettings } = gated;
@@ -339,9 +348,10 @@ export function createResolveSpec(ctx) {
             if (rewindFilesToEntryId === undefined)
                 throw new HttpError(404, `rewindFilesTo: no such message in this session (rewind_files_to.unknown_event) — ${NO_ANCHOR_HINT}; name another prompt`, { code: "rewind_files_to.unknown_event" });
         }
-        const s4ProjectId = auth?.resolvedProjectId ?? (typeof body.projectId === "string" && body.projectId ? body.projectId.toLowerCase() : undefined);
-        const s4DefaultScopes = s4ProjectId ? config.projects[s4ProjectId]?.defaultScopes : undefined;
-        return { resumeAtEntryId, rewindFilesToEntryId, s4DefaultScopes };
+        const submittedProjectId = auth?.resolvedProjectId ?? (typeof body.projectId === "string" && body.projectId ? body.projectId.toLowerCase() : undefined);
+        const s4DefaultScopes = submittedProjectId ? config.projects[submittedProjectId]?.defaultScopes : undefined;
+        const legProjectId = await legProjectIdOf(submittedProjectId, sessionWorkspace, auth?.sessionId);
+        return { resumeAtEntryId, rewindFilesToEntryId, s4DefaultScopes, legProjectId };
     };
     const declaresInteractivePosture = (body, req, opts) => {
         if (opts?.liveStream !== true)
@@ -358,7 +368,7 @@ export function createResolveSpec(ctx) {
         return deriveAskEffective(askForm.form, "unresolved") === "human_reachable";
     };
     const assembleSpecLiteral = (body, auth, req, opts, parts, effMode) => {
-        const { scenarioName, cap, hands, acceptedAppend, parsedSettings, attachmentNotice, taskHooks, additionalDirectories, additionalReadDirectories, wireCatalog, picked, resumeAtEntryId, rewindFilesToEntryId, s4DefaultScopes, projectKey, a2aPeers, storedToolAxes, runSkills, } = parts;
+        const { scenarioName, cap, hands, acceptedAppend, parsedSettings, attachmentNotice, taskHooks, additionalDirectories, additionalReadDirectories, wireCatalog, picked, resumeAtEntryId, rewindFilesToEntryId, s4DefaultScopes, legProjectId, projectKey, a2aPeers, storedToolAxes, runSkills, } = parts;
         const spec = {
             objective: attachmentNotice ? `${picked.cleanedObjective}\n\n${attachmentNotice}` : picked.cleanedObjective,
             ...buildPromptSeats(scenarioName, cap.prompt, typeof body.systemPrompt === "string" ? body.systemPrompt : undefined),
@@ -366,6 +376,7 @@ export function createResolveSpec(ctx) {
             ...(body.outputStyle !== undefined ? { outputStyle: body.outputStyle } : {}),
             ...(body.projectMemory !== undefined ? { projectMemory: body.projectMemory } : {}),
             sessionId: auth?.sessionId,
+            ...(legProjectId !== undefined ? { projectId: legProjectId } : {}),
             principal: auth?.principal,
             images: body.images,
             ...(body.userAttachments !== undefined ? { userAttachments: body.userAttachments } : {}),
@@ -491,8 +502,8 @@ export function createResolveSpec(ctx) {
             ...(() => { const v = toolNameListFromBody(body.userInvokedSkills); return v ? { userInvokedSkills: v } : {}; })(),
             ...(parsedSettings.settings?.skillListingBudgetFraction !== undefined ? { skillListingBudgetFraction: parsedSettings.settings.skillListingBudgetFraction } : {}),
             ...(parsedSettings.settings?.skillListingMaxDescChars !== undefined ? { skillListingMaxDescChars: parsedSettings.settings.skillListingMaxDescChars } : {}),
-            mcp: resolveRequestMcp(mcpForScenario(config.mcpServers, scenarioName), body.mcpServers, config, logger, opts?.onNotice !== undefined ? { sessionId: auth?.sessionId, emit: opts.onNotice } : undefined, storedToolAxes),
-            a2a: resolveRequestA2a(a2aForScenario(config.a2aPeers, scenarioName), a2aPeers, config, logger, opts?.leg === "fresh" ? "fresh" : "resume", storedToolAxes),
+            mcp: resolveRequestMcp(mcpForScenario(config.mcpServers, scenarioName), body.mcpServers, config, peerDesk, opts.lease, logger, opts?.onNotice !== undefined ? { sessionId: auth?.sessionId, emit: opts.onNotice } : undefined, storedToolAxes),
+            a2a: resolveRequestA2a(a2aForScenario(config.a2aPeers, scenarioName), a2aPeers, config, peerDesk, opts.lease, logger, opts?.leg === "fresh" ? "fresh" : "resume", storedToolAxes),
             toolPolicy: toolPolicyForHands(hands, durableEnabled
                 ? createApprovalBaselinePolicy(config, {
                     kind: "durable",

package/dist/boot/retention-lane.d.ts

@@ -155,15 +155,21 @@ export interface RetentionSweepOutcome {
 /**
  * lane **自持的** boot 不变式(设计稿 §7,codex F3)—— 与 core 的 `assertRetentionCapability` 是两道门,
  * 各答各的问题:
- *  · core 那道问的是「**锁着**的策略会不会盖在一只删不了的店上」——只在 locked 时说话;
- *  · **本道**问的是「lane 开着的时候,它真的能删吗」——**不看 locked 状态**。
+ *  · core 那道判**配对**,锁不锁都判(`executor` 必给):声明 `managed` 的店 × 没有执行器(`null`)⇒ 拒;执行器四个契约方法
+ *    (`listRetentionDomains` / `expireCheckpoints` / `deleteExpiredSessions` / `deleteOrphanToolResults`)缺一 ⇒ 拒;
+ *    **锁着**的策略盖在声明 `none` 的店上 ⇒ 拒。它不问 lane 开没开、策略在不在,也不拦没锁时「执行器在场 × 店声明 `none`」(部署可以持有执行器而不在某只店上跑);
+ *  · **本道**问的是「lane 开着的时候,它真的能删吗」——**不看 locked 状态**:策略在场、执行器在场、lane 调的**五**个方法都在
+ *    (多出的 `previewRetention` 是 audit-only 档的读数口,不在 core 的四方法契约里,引擎的检查覆盖不到它)、每只被 lane 消费的店都声明 `managed`。
+ *    「执行器在场」与「契约方法齐」两格和引擎的判官说的是同一件事(各自一句拒句),其余几格是引擎不问的。
  *
- * 为什么后者必须存在:core 的门在 `locked=false` 时整条放行,于是
+ * 为什么本道必须存在:引擎的门不拦
  *  ① `RETENTION_SWEEP_INTERVAL_SEC>0` 而 policy 缺席 = 没有有效 cutoff 的 sweep(每 tick 什么都算不出来,
  *     读数一路 0,看起来像"没有候选");
- *  ② unlocked policy × 一只 `"none"` 的店照样过检 —— 部署于是**广告了一个不执行的留存面**:能力位说
+ *  ② 没锁时,执行器在场 × 一只 `"none"` 的店 —— 部署于是**广告了一个不执行的留存面**:能力位说
  *     `{mode,maxAgeDays}`、审计表也在长,而那只店的行谁都没在删。
- * 两者都在**启动期**拒(安全控件不得半开),不是让运维从一台"启动成功、什么也没删"的机器上猜。
+ *     本仓的 SQL 后端按同一个事实(扫车道开不开,`plugins/retention-store-sql.ts` 的 `retentionSweepRuns`)给它铸的三只店声明词,所以 lane 开着时
+ *     这三只店在这一格上恒是 `managed`;这一格防的是声明与 lane 脱钩的店(别的后端、替身)。
+ * 这些都在**启动期**拒(安全控件不得半开),不是让运维从一台"启动成功、什么也没删"的机器上猜。
  *
  * @param locked 只进文案(让拒启信息能说清"你锁没锁都一样拒");**判据本身不读它** —— 这一格的存在
  *               就是为了让"不看 locked"这句话在签名上可见,而不是靠注释声明。

package/dist/boot/retention-lane.js

@@ -2,6 +2,7 @@ import { recordFailOpen } from "../observability/fail-open.js";
 export const RETENTION_SWEEP_STUCK_THRESHOLD = 5;
 export const RETENTION_LEASE_TTL_FACTOR = 2;
 const DAY_MS = 86_400_000;
+const LANE_EXECUTOR_METHODS = ["listRetentionDomains", "previewRetention", "expireCheckpoints", "deleteExpiredSessions", "deleteOrphanToolResults"];
 export function assertRetentionLaneWirable(input) {
     if (input.intervalSec <= 0)
         return;
@@ -18,8 +19,7 @@ export function assertRetentionLaneWirable(input) {
             `declares retention:"none" and nothing would delete a row${lockNote}. Run a SQL backend, or set RETENTION_SWEEP_INTERVAL_SEC=0.`);
     }
     const executor = input.executor;
-    const CONTRACT_METHODS = ["listRetentionDomains", "previewRetention", "expireCheckpoints", "deleteExpiredSessions", "deleteOrphanToolResults"];
-    for (const m of CONTRACT_METHODS) {
+    for (const m of LANE_EXECUTOR_METHODS) {
         if (typeof executor[m] !== "function") {
             throw new Error(`the wired retention executor is missing \`${m}\` — a store that declares retention:"managed" PROMISES the whole ` +
                 `ManagedRetentionCapability contract, and the sweep lane calls every method of it${lockNote}. Refusing to start with a ` +

package/dist/boot/runner-deps.d.ts

@@ -29,6 +29,7 @@ import type { ToolApprovalCoordinator } from "../tool-approval.js";
 import type { MemoryBackend } from "@sema-agent/core";
 import type { MemorySyncRunner } from "../memory-sync-client.js";
 import type { MailboxRecipientLifecycle } from "../plugins/mailbox-recipient-lifecycle.js";
+import type { PeerDesk } from "../peer-seat.js";
 /**
  * `RunnerDeps.onAsk` 的装配([ref] 件4:从内联闭包提为具名导出,**纯 testability 重构、零行为变化**)。
  *
@@ -163,6 +164,8 @@ export interface RunnerDepsCtx {
     /** core 7.49.0 [ref]:引擎数据根(boot 事实,`boot/stores.ts` 恒铸 —— 记忆引擎开不开都在)。共享基座把它交成每只 Runner 的
      *  `memoryEngineDir`:引擎从它解出每条腿的唯一豁免根(守卫集不再收 `dataRoot`)。开引擎时与 `memoryEngine.root` 同一只。 */
     engineDataRoot: string;
+    /** 对端座的 desk(进程一只,`peer-seat.ts`):共享基座把它的座交成每只 Runner 的 `peerSeat` —— MCP / A2A 声明里的引用只经它在发送时作答。 */
+    peerDesk: PeerDesk;
     /**
      * [ref](core 7.21.1)—— 记忆整理的**已解析座**(`boot/memory-consolidation.ts` 的
      * `resolveConsolidationDriverSeat` 产物),在场 **iff** 整理阀门开着(`resolveConsolidationValve` 的判决:
@@ -228,7 +231,8 @@ export interface RunnerDepsCtx {
     executionEnvFactory: RunnerDeps["executionEnvFactory"];
     lspManager: RunnerDeps["lspManager"];
     fleetBus: FleetEventBus;
-    /** 部署座的 mods 注册(stage-05 `createDeploymentMods` 铸、起服自证过)—— 共享基座 ⇒ 主 / handless / hookAgent / sub 每一只 Runner 同一份。 */
+    /** 部署座的 mods 注册(起服第 5 段装配口 `assembleDeploymentMods` 铸:自铸 + 运维声明的包,起服自证过)—— 主 / handless / hookAgent / sub 经本共享基座、
+     *  leader 车道的路由 / worker / 修复腿经 `LeaderWireConfig.mods`(`boot/leader.ts` 递同一份),每一只 Runner 同一份。 */
     deploymentMods: NonNullable<RunnerDeps["mods"]>;
     workflowRunStore: WorkflowRunStore | undefined;
     workflowJournalStore: ServiceWorkflowJournalStore | undefined;
@@ -241,7 +245,7 @@ export interface RunnerDepsCtx {
 }
 /** [ref] A10 留档发现②:main runner `RunnerDeps` 与 main.ts subRunner 字面量之间此前手工重复
  * 的 ~15 个键,类型标注见 {@link createSharedRunnerDeps} 头注。 */
-export type SharedRunnerDeps = Pick<RunnerDeps, "brain" | "readFace" | "readDenyPatterns" | "readDenyBuiltinTiers" | "readDenyBuiltinExclude" | "memoryDelegationEvidence" | "memoryProvenance" | "memoryCapturePolicy" | "delegationEntryCaps" | "crossSessionInbound" | "crossSessionDialogExpiry" | "writeProtectedPaths" | "memoryEngineDir" | "allowedTools" | "crossBoundaryPosture" | "models" | "roles" | "tiers" | "pricing" | "tracer" | "promptSource" | "executionEnvFactory" | "lspManager" | "backgroundAgentStore" | "mailboxStore" | "rosterStore" | "mods" | "toolResultStore" | "checkpointStore" | "hands" | "sessionPolicyStore" | "usageWindows" | "usageWindowStore" | "memoryScopeAdmission" | "deploymentMemoryScopes" | "sharedMemoryStores" | "compliancePostureResolver" | "lockedConfig" | "retentionPolicy" | "onNotice" | "mcpRevocations">;
+export type SharedRunnerDeps = Pick<RunnerDeps, "brain" | "readFace" | "readDenyPatterns" | "readDenyBuiltinTiers" | "readDenyBuiltinExclude" | "memoryDelegationEvidence" | "memoryProvenance" | "memoryCapturePolicy" | "delegationEntryCaps" | "crossSessionInbound" | "crossSessionDialogExpiry" | "writeProtectedPaths" | "memoryEngineDir" | "allowedTools" | "crossBoundaryPosture" | "models" | "roles" | "tiers" | "pricing" | "tracer" | "promptSource" | "executionEnvFactory" | "lspManager" | "backgroundAgentStore" | "mailboxStore" | "rosterStore" | "mods" | "toolResultStore" | "checkpointStore" | "hands" | "sessionPolicyStore" | "usageWindows" | "usageWindowStore" | "memoryScopeAdmission" | "deploymentMemoryScopes" | "sharedMemoryStores" | "compliancePostureResolver" | "lockedConfig" | "retentionPolicy" | "onNotice" | "mcpRevocations" | "peerSeat">;
 /**
  * [ref] A10 留档发现②(review 2026-07-29,[ref]§三族A 同源修补的延续):main runner 的
  * `RunnerDeps` 字面量(下方 `createRunnerDeps`)与 `main.ts` 里 subRunner 的 `new Runner({...})`
@@ -268,7 +272,7 @@ export type SharedRunnerDeps = Pick<RunnerDeps, "brain" | "readFace" | "readDeny
  *    属性,比再抽一层共享基座更强的同源保证),不重复收纳进这里。
  */
 /** 基座真实消费的窄面(Pick)——subRunner 调用点(main.ts)只需凑这 13 个字段,不必造全量 ctx。 */
-export type SharedRunnerDepsCtx = Pick<RunnerDepsCtx, "config" | "brain" | "pricing" | "tracer" | "promptSource" | "executionEnvFactory" | "lspManager" | "backgroundAgentStore" | "mailboxStore" | "rosterStore" | "deploymentMods" | "toolResultStore" | "checkpointStore" | "sessionPolicyStore" | "hands" | "usageWindowStore" | "orgMemoryAdmission" | "sharedMemoryStores" | "logger" | "governanceSeams" | "mcpRevocations" | "metrics" | "engineDataRoot">;
+export type SharedRunnerDepsCtx = Pick<RunnerDepsCtx, "config" | "brain" | "pricing" | "tracer" | "promptSource" | "executionEnvFactory" | "lspManager" | "backgroundAgentStore" | "mailboxStore" | "rosterStore" | "deploymentMods" | "toolResultStore" | "checkpointStore" | "sessionPolicyStore" | "hands" | "usageWindowStore" | "orgMemoryAdmission" | "sharedMemoryStores" | "logger" | "governanceSeams" | "mcpRevocations" | "metrics" | "engineDataRoot" | "peerDesk">;
 /** 转发席只需要 `inc` —— 刻意窄到这一个动词,免得把整只 Metrics 拖进这条纯转发腿。 */
 export interface EngineNoticeMetricsSeat {
     inc: (name: string, labels?: Record<string, string>) => void;

package/dist/boot/runner-deps.js

@@ -131,6 +131,7 @@ export function createSharedRunnerDeps(ctx) {
         lockedConfig: ctx.governanceSeams.lockedConfig,
         retentionPolicy: ctx.governanceSeams.retentionPolicy,
         mcpRevocations: ctx.mcpRevocations ? ctx.mcpRevocations : undefined,
+        peerSeat: ctx.peerDesk.seat.answer,
     };
     return shared;
 }

package/dist/boot/stage-04-stores.d.ts

@@ -27,18 +27,7 @@ export declare function runStage04(ctx: Awaited<ReturnType<typeof runStage03>>):
     ruleConsent: import("../rules-consent.js").RuleConsentLane | undefined;
     sessionMemoryStatusFace: import("../memory-operator-faces.js").SessionMemoryStatusFace | undefined;
     sessionPolicyStore: import("@sema-agent/core").SessionPolicyStore | undefined;
-    sideQueryAccounting: (principal: string | undefined, r: {
-        model: string;
-        usage?: {
-            input?: number;
-            output?: number;
-            cacheRead?: number;
-            cacheWrite?: number;
-            cost?: {
-                total?: number;
-            };
-        };
-    }) => void;
+    sideQueryAccounting: import("../budget.js").SideQueryAccounting;
     toolResultStore: import("../plugins/store-backend.js").ToolResultStoreFull | undefined;
     tracer: import("@sema-agent/core").TracerHook;
     backend: import("../index.js").StoreBackend | undefined;