@sema-agent/server 7.143.0 → 7.144.0

package/dist/boot/runner-deps.js

@@ -1,4 +1,4 @@
-import { createFileWorkflowScriptStore } from "@sema-agent/core";
+import { createFileWorkflowScriptStore, setDefaultEngineNoticeSeat } from "@sema-agent/core";
 import { join } from "node:path";
 import { lkgReadDenyRows } from "../config-lkg.js";
 import { auditReadDenyAnchoring } from "./read-deny-anchor-audit.js";
@@ -14,7 +14,6 @@ import { makeLoadProjectMemory, makeProbeInstructionSources } from "../project-m
 import { createInstructionSourceSeat } from "../instruction-source-notice.js";
 import { workflowModelAllowlistFor } from "../task-workflow.js";
 import { buildCrossSessionInboundLayers, crossSessionDialogExpiryOf } from "../cross-session-settings.js";
-import { defaultPeerInboundFace } from "../peer-inbound-face.js";
 import { createPeerDirectory } from "../peer-directory.js";
 import { storeFormRefusalInIncident } from "../memory-store-refusal.js";
 import { coreFileHistoryCaptureSeat } from "../file-history-capture.js";
@@ -48,7 +47,7 @@ export const PROMPT_CACHE_BREAK_CAUSE_LEVEL = {
 };
 const PROMPT_CACHE_BREAK_LEVELS = new Map(Object.entries(PROMPT_CACHE_BREAK_CAUSE_LEVEL));
 const CEILING_ORIGINS = new Set(["walltime", "turns"]);
-export function createEngineNoticeForwarder(logger, router = defaultEngineNoticeRouter, metrics, peerInbound = defaultPeerInboundFace) {
+export function createEngineNoticeForwarder(logger, router = defaultEngineNoticeRouter, metrics) {
     return (notice) => {
         const detail = redactNoticeRuleText(notice.code, notice.detail);
         const message = redactNoticeMessage(notice.message);
@@ -58,10 +57,12 @@ export function createEngineNoticeForwarder(logger, router = defaultEngineNotice
             if (typeof origin === "string" && CEILING_ORIGINS.has(origin))
                 metrics.inc("limit_ceiling_after_answer_total", { origin });
         }
-        peerInbound.observe(notice);
         router.route(notice);
     };
 }
+export function installDefaultEngineNoticeSeat(logger, metrics) {
+    setDefaultEngineNoticeSeat(createEngineNoticeForwarder(logger, defaultEngineNoticeRouter, metrics));
+}
 export function createEngineNoticeSeat(logger, router = defaultEngineNoticeRouter) {
     const warn = logger?.warn?.bind(logger);
     return warn ? { onNotice: createEngineNoticeForwarder({ warn }, router) } : {};

package/dist/boot/shutdown.d.ts

@@ -98,7 +98,7 @@ export interface ShutdownCtx {
     /**
      * [ref]:被扣跨会话来信的收信方决断面(`peer-inbound-face.ts`,进程单例)的关停口 —— CC `HBe` 的宿主半场(core 不调 `PeerHeldQueue.shutdown()`)。
      * hardShutdown 起点与审批面收尾**并行**调它、`backend.close()` 之前等它(结清要走信箱店的 CAS 与回执投递):本进程仍被扣的信按 core 的规则
-     * 带 `expired` 回执结清(reason `shutdown`)。缺席 = 本装配不接(测试装配)。
+     * 带 `expired` 回执结清(reason `shutdown`),core 等回执落箱再兑现(没落的点名 seq ⇒ 读数 `receiptFaults`)。缺席 = 本装配不接(测试装配)。
      */
     peerInbound?: {
         shutdown(): Promise<PeerInboundShutdownReading>;

package/dist/boot/shutdown.js

@@ -98,8 +98,10 @@ export function installShutdownHandlers(ctx) {
             : (async () => {
                 const deadline = new AbortController();
                 const settled = peerInbound.shutdown().then((reading) => {
-                    if (reading.queues > 0 || reading.scopeUnresolved > 0)
-                        logger.info("peer_inbound_settled_at_shutdown", { queues: reading.queues, scopeUnresolved: reading.scopeUnresolved });
+                    if (reading.cards > 0)
+                        logger.info("peer_inbound_settled_at_shutdown", { queues: reading.queues, cards: reading.cards });
+                    for (const fault of reading.receiptFaults)
+                        logger.warn("peer_inbound_shutdown_receipt_unlanded", { err: seatText("operator-log-text", fault) });
                 }, (err) => logger.warn("peer_inbound_shutdown_failed", { err: seatText("operator-log-text", String(err)) }));
                 const timedOut = delay(Math.max(0, graceDeadlineMs - Date.now()), undefined, { signal: deadline.signal }).then(() => "deadline", () => "done");
                 const winner = await Promise.race([settled.then(() => "done"), timedOut]);

package/dist/boot/stage-01-config.js

@@ -15,6 +15,7 @@ import { setRedactionObserver } from "../trace/redact.js";
 import { installOutboundDispatcher } from "../outbound-dispatcher.js";
 import { provisionSemaConfigDir } from "../sema-config-dir.js";
 import { bindOwnCredentialsConfig, declareServerWithheldEnv } from "../server-secret-env.js";
+import { installDefaultEngineNoticeSeat } from "./runner-deps.js";
 export function runStage01() {
     declareServerWithheldEnv();
     const config = loadConfig();
@@ -27,6 +28,7 @@ export function runStage01() {
     const metrics = createMetrics();
     installFailOpenRecorder({ logger, metrics, redactDetail: redactSecrets });
     installSecretEnvScrubRecorder({ logger, metrics });
+    installDefaultEngineNoticeSeat(logger, metrics);
     installFileHistoryFailureRecorder({ logger, metrics });
     logConfigDiagnostics(logger);
     for (const w of drainNumEnvWarnings())

package/dist/boot/stage-07-capability-layer.js

@@ -172,7 +172,7 @@ export async function runStage07(ctx) {
             .catch((e) => logger.warn("web_search_probe_failed", { provider: webSearchCfg.provider, error: seatText("operator-log-text", e instanceof Error ? e.message : String(e)) }));
     }
     const ensureChildSessionDurable = checkpointStore && resolveSubagentTranscriptTier(backgroundAgentStore !== undefined, sessionStore) === "full"
-        ? (sessionId, root) => attestChildSessionDurable(sessionStore, sessionId, root, logger)
+        ? (sessionId, given) => attestChildSessionDurable(sessionStore, sessionId, given)
         : undefined;
     const webFetchSummarize = createWebFetchSummarizeLane({ brain, config, getKeyResolver: () => webAdmin.getKeyResolver(), logger });
     const scenarioDeps = {

package/dist/boot/stage-10-http-server.js

@@ -13,7 +13,7 @@ import { backgroundAgentOutput, taskHandleOutput, taskHandleStop } from "../runs
 import { createStoreLiveProbe } from "../store-live-probe.js";
 import { counterStoreLabel } from "../plugins/store-backend.js";
 import { sessionStoreLabelOf } from "../store-posture.js";
-import { defaultPeerInboundFace, peerBoxScope } from "../peer-inbound-face.js";
+import { defaultPeerInboundFace } from "../peer-inbound-face.js";
 import { startFleetClientFromConfig } from "../fleet-client.js";
 import { createCenterWiringReader } from "../capabilities/center-wiring.js";
 import { mintEngineSignal } from "../fleet/engine-signal.js";
@@ -344,12 +344,7 @@ export async function runStage10(ctx) {
         retentionLane: retentionLaneStarted,
         releaseRetentionLease: retentionLaneStore !== undefined ? () => retentionLaneStore.release(instanceId) : undefined,
         servingLease,
-        peerInbound: {
-            shutdown: () => defaultPeerInboundFace.shutdown(async (sessionId) => {
-                const head = await ownerAware.headOf?.(sessionId);
-                return head === undefined ? undefined : peerBoxScope(head.owner);
-            }),
-        },
+        peerInbound: defaultPeerInboundFace,
     });
     servingLease?.resumeStickyDenial();
     return { ...ctx };

package/dist/capabilities/scenarios.d.ts

@@ -84,12 +84,11 @@ export interface ScenarioContext {
      */
     sessionId?: string;
     /**
-     * [ref] / [ref]:**委派树根的见证**(停驻挂点的属主来源)—— 根会话 id + 调用方判断那一刻读到的根行住客(`delegated-session-owner.ts` 的 `DelegationRootWitness`)。
-     * 由**每一个**接了停驻挂点的取用方显式交出(一条读法,没有回落):请求腿 = 本请求经鉴权解析的会话与受理时那一读(`boot/resolve-spec.ts`);`/decide` 赎回面 = 行上的
-     * `rootSessionId` 与赎回腿写口放行的那一位住客(`parked-revive-surface.ts`,交不交座都交)。它喂停驻挂点与 Runner 之外的后台子代完成 relay(会话通知门的目标住客:属主与化身),
-     * 不挂任何会话级设施(那是 {@link sessionId} 的事,
-     * 判据是「这只 bundle 是不是在那只会话上取用的」,与属主来源是两个独立判据)。缺席 = 没有根可交(boot 期探针、run-local、行上没有根)⇒ 律给哨兵。
-     * 挂点在停驻那一刻再读一次根行:住客不是见证的那一位(删了、同 id 被重新登记)⇒ 停驻否决 —— 不按新住客认领。
+     * [ref]:**委派树根的见证** —— 根会话 id + 调用方判断那一刻读到的根行住客(`delegated-session-owner.ts` 的 `DelegationRootWitness`)。
+     * 由取用方显式交出(一条读法,没有回落):请求腿 = 本请求经鉴权解析的会话与受理时那一读(`boot/resolve-spec.ts`);`/decide` 赎回面 = 行上的
+     * `rootSessionId` 与赎回腿写口放行的那一位住客(`parked-revive-surface.ts`,交不交座都交)。它只喂 Runner 之外的后台子代完成 relay(会话通知门的目标住客:属主与化身),
+     * 不挂任何会话级设施(那是 {@link sessionId} 的事,判据是「这只 bundle 是不是在那只会话上取用的」)。缺席 = 没有根可交(boot 期探针、run-local、行上没有根)⇒ 不接 relay。
+     * 停驻挂点不读它(core 7.62.0 起挂点只比对引擎交来的委派树属主;根见证在停驻挂点的读法随 [ref] P-5 退役)。
      */
     delegationRoot?: DelegationRootWitness;
 }
@@ -143,22 +142,19 @@ export interface ScenarioDeps {
      * pre-153 行为(子代 SAFETY ask 照旧 deny+continue,零回归)。
      *  - `checkpointStore` 必须与 `RunnerDeps.checkpointStore`(主 runner 的 per-task spec 面)**同实例**
      *    ——子代 suspend 在那里铸 token,异实例 = park 全静默失效(core JSDoc 钉过症状,组装区注释同步)。
-     *  - `ensureChildSessionDurable` = park 提交前的 capability 挂点(core 签名 `(sessionId) => Promise<void>`)
-     *    ——resolve = 该子代 session 已从任意进程可读,reject/缺席 = veto(子代按 pre-153 settle failed,
-     *    checkpoint 被 expire)。**本车保守实现**:只在子代 session 已经真正路由到宿主 durable 会话店
-     *    **且真有内容**(`getLeafId() !== null`——排除 F-7 同族的空壳 claim-create 行,那种行 acquire
-     *    命中但零内容,是`register()`对任意自报 sessionId 的副作用,不是真正 durable 的会话)时 resolve
-     *    (=fork 续聊的常见形),其余一律 reject——不做「主动迁移私店会话进 durable 店」这一步
-     *    (ForkRoutingSessionStore 的路由表是私有状态,无迁移 API;主动迁移是更大的活,candidate 留给
-     *    后续按需再做)。
+     *  - `ensureChildSessionDurable` = park 提交前的 capability 挂点(core 签名 `(sessionId, given: { owner }) => Promise<void>`,下面那个字段)
+     *    ——resolve = 该子代 session 已从任意进程可读且属主是引擎交来的那一位,reject/缺席 = veto(子代按 pre-153 settle failed,
+     *    checkpoint 被 expire)。实现只验不搬(`plugins/session-store.ts` 的 `attestChildSessionDurable`):宿主店里在、有真内容
+     *    (`getLeafId() !== null`——排除 F-7 同族的空壳 claim-create 行)、属主相等,才 resolve。
      */
     checkpointStore?: CheckpointStore;
     /**
-     * [ref]:比 core 挂点多一个参数 —— `root` = **委派树根的见证,由取用这只 bundle 的调用方交出**({@link ScenarioContext.delegationRoot};缺席 = 没有根可交)。
-     * core 的挂点只给子代 id,停驻写下 / 定夺的宿主行属主却要按委派继承律取委派树根的属主;场景工厂把见证绑进交给 core 的那只闭包,同一棵树里任何深度的后台子代
-     * 停驻都经它(子代沿用父的委派工具实例)。
+     * 停驻挂点 —— 签名就是 core 的(`(sessionId, given: { owner }) => Promise<void>`,core 7.62.0 [ref]):`given.owner` = 引擎判的委派树属主,挂点只比对宿主行属主与它
+     * (`plugins/session-store.ts` 的 `attestChildSessionDurable`)。场景工厂原样交给委派工具,不绑任何调用方见证(委派树根见证闭包随 [ref] P-5 退役)。
      */
-    ensureChildSessionDurable?: (sessionId: string, root: DelegationRootWitness | undefined) => Promise<void>;
+    ensureChildSessionDurable?: (sessionId: string, given: {
+        readonly owner: string | null;
+    }) => Promise<void>;
     /**
      * **Runner 之外的后台子代完成**交给哪里 —— 按委派树根见证({@link ScenarioContext.delegationRoot})造委派工具挂载期的 `background.notify`。
      * 停驻赎回腿的复活、操作员 `handle.resume` 都不是哪一次 run 内的调用,没有调用车道;引擎只在能解出一只完成 sink(调用 ?? 挂载)时才起后台续跑,

package/dist/capabilities/scenarios.js

@@ -38,7 +38,6 @@ export function buildScenarios(deps) {
         const webSearch = requestWebSearchBackend(deps.requirePrincipal !== true
             ? judgeRequestWebSearch(req?.settings?.webSearch)
             : { kind: "absent" }, deps.webSearch, deps.logger);
-        const ensureChildSessionDurable = deps.ensureChildSessionDurable;
         const delegationRoot = ctx?.delegationRoot;
         return {
             tools: [
@@ -58,7 +57,7 @@ export function buildScenarios(deps) {
                             scope: "default",
                             ...(deps.backgroundAgentStore ? { agentStore: deps.backgroundAgentStore } : {}),
                             ...(deps.checkpointStore ? { checkpointStore: deps.checkpointStore } : {}),
-                            ...(ensureChildSessionDurable !== undefined ? { ensureChildSessionDurable: (childSessionId) => ensureChildSessionDurable(childSessionId, delegationRoot) } : {}),
+                            ...(deps.ensureChildSessionDurable !== undefined ? { ensureChildSessionDurable: deps.ensureChildSessionDurable } : {}),
                             ...(deps.backgroundCompletionSinkFor !== undefined && delegationRoot !== undefined ? { notify: deps.backgroundCompletionSinkFor(delegationRoot) } : {}),
                         },
                         ...createSubagentExtraTools(deps.subagentExtraTools),

package/dist/config-d-migration.d.ts

@@ -28,6 +28,8 @@ export interface ConfigDirMigrationLog {
  *  · `noop` / `no-documents` / 目录不在 ⇒ 不出声(没有东西可迁);
  *  · `refused` ⇒ warn `config_dir_migration_refused`(一字未写;逐条点名迁移 id、坐标与契约的拒句 —— 读侧随后对这些旧形照旧响亮拒);
  *  · `unreadable` / 调用抛 ⇒ warn `config_dir_migration_failed`(一字未写或写到一半;原因 —— 坏文件的句子与读腿同一只判官)。
+ *    契约的 `unreadable` 不带成因,本仓分不出两类:① 读腿同一拍也会拒的坏文本(空 / 坏 JSON / 不是对象 / 嵌得过深〔根下 199 层〕:同一只文本判官,读腿随后另有一行 `config_candidate_rejected`,同一件事两行);
+ *    ② 只有迁移读不了的(目录列不了、悬空符号链接 —— 读腿接受,这一行是唯一的信号)。静默 ① 就会连 ② 一起吞,所以两类同一行;契约交出成因后 ① 改为只留读腿那一行(待契约)。
  *  · `pending` 只在契约的 `check: true` 下出现,本仓从不传 ⇒ 撞上即是接线错,响亮抛。
  */
 export declare function logConfigDirMigration(log: ConfigDirMigrationLog, m: ConfigDirMigration): void;

package/dist/delegated-session-owner.d.ts

@@ -1,59 +1,33 @@
 /**
- * 🔴 **委派子代会话的属主 —— 一条律;三处写点,各自的来源集;属主 = 判断时见证到的,写只 CAS 子行自己**([ref])。
+ * 🔴 **委派子代会话的属主 —— 引擎判、店原样记**(core 7.62.0 [ref];[ref];server 7.144.0 起)。本模块只剩三件:存量行的一次性回填(M23)的判据与写句、
+ * 孤行哨兵属主的保留前缀、委派树根的见证形。
  *
- * ## 律
- * 一只委派子代会话(引擎为委派铸的 placed 会话;升级前停驻时晋升进宿主店的普通行在停驻挂点也按这条律比对)的属主**不是它自己的事实**:它是发起它的那棵委派树的
- * **根会话的属主**。树根是**铸行那一刻存在的那只根行**(id + 住客化身,`session-incarnation.ts`);此后同 id 另起的会话不是这棵树的根。所以写下的属主 =
- * **判断时见证到的**(读法顺序按写点交来的来源集):
- *  1. 根会话在本店有行 ⇒ 它的属主(根无主 ⇒ 子代也无主 —— 与根同读数,不是另一种读数);
- *  2. 根行不在 ⇒ 父会话的行(同上);
- *  3. 来源集里一只都不在本店(孤行)⇒ 写一只**任何已验身份都不可能等于**的哨兵属主 `_orphan:<子代 id>`(前缀登记在 `security.ts` 的保留主体前缀里,
- *     鉴权边界拒任何报出它的主体)+ 写落下之后一行 warn `delegated_session_owner_orphaned`。宁可没人能读,也不让谁都能读。
- * 一只记下的根 / 父是空串(`''`)⇒ 读作没有那一格(与 `session-placement.ts` 的 `placementFromRow` 同一个读法;M23 的扫描句在同一条语句里对连接键套
- * `NULLIF(…, '')`,与判据同读)。
- * **与引擎属主对说法不同(如实登记,收口在引擎)**:引擎 7.55.0 的属主对把「acquire 建的行」与 placed 行一并列为记 `null`(匿名);本律对**每一只** placed 行
- * 在建行那一笔记委派树的属主(哨兵只是「来源都不在」那一形)—— 照引擎的读法记 `null`,在本服务的门上就只有 fleet 调用方读得到(发起它的主体自己读不到;`security.ts` 的 `ownerlessRowOpen`)、且留在认领句 / M23 的射程里,
- * 照引擎「匿名 = 对每个主体放行」的字面读法则是拿到 id 的人都读得到;哨兵两条路都不走。引擎会话店试剂盒「对已有的行
- * register 什么都不做」一格因此在 SQL 两店上登记待翻格,盒那一格的不变量(register 不认领任何已有的行)另由正向钉逐步断言(`test/store-contract-kit-db-integration.test.ts` §9b)。
- * **写只 CAS 子行自己**:`owner IS NULL ∧ incarnation = 判断时读到的子行化身 ∧ placed`({@link CLAIM_OWNERLESS_PLACED_SQL},两方言各一句)。判断与写之间
- * 根 / 父被删、被同 id 重建、换住客 —— 写进去的仍是**判断时那棵树**的属主,这正是律要的:不锁根、不读根、不要求「根到写时还是那个根」。之后与任何会话一样
- * 首写不可变(`register` 的首写律)。判断那一刻的检查照旧在判断里做、不进 CAS:宿主行记下的根是不是这一棵;调用方见证之后根行换没换住客
- * (停驻挂点,{@link assertRootStillWitnessed})。
+ * ## 律(唯一来源 = 引擎)
+ * 委派树的属主 D 由引擎判:没人派生的 run 读自己那一行(`sessions.headOf`,按化身绑一次),原样带给每一层子代(`SessionPlacement.owner: string | null`;`null` = 根匿名);
+ * 复活的子代 = 它自己那一行的属主。本仓两处只读它:
+ *  · 三只持久会话店的 placing write 把 `placement.owner` 原样记进行的属主格(盒义务 7;唯一读法 `plugins/session-ownership.ts` 的 `placedSessionOwnerOf`);
+ *  · 停驻挂点(`plugins/session-store.ts` 的 `attestChildSessionDurable`)只比对宿主行属主与引擎交来的 `given.owner`,不认领、不推断。
+ * 本仓此前自己的委派继承律([ref]:建行那一笔读根 / 父推断、来源都不在写孤行哨兵、停驻挂点按记录的树认领无主行、根见证换住客即拒)在这两处随之退役 ——
+ * 一个事实两份判据(引擎的 D 与本仓的推断)是双真源([ref] (a)),收成引擎那一份。
  *
- * **根先于父**:父的属主按同一条律恒等于根的属主,读根一次就到;而读父会把「父行是升级前写下的无主 placed 行」(滚动升级窗里旧副本建的、
- * 一次性迁移还没回填的)那一格 NULL 传下去。父只在根行不在时才读。
+ * ## 还在的:一次性迁移 M23 的回填(窗随 M23,登记表 M23 行;窗关同删本节全部)
+ * 7.132.x 及更早写下的 placed 行属主恒 NULL(当年 SQL 两店建行不记属主)。M23 每次起服按**旧律**给它们回填一次(引擎的 D 当时没有被记下来,读不回):
+ *  1. 根会话在本店有行 ⇒ 它的属主(根无主 ⇒ 子代也无主 —— 与根同读数);
+ *  2. 根行不在 ⇒ 父会话的行(同上);
+ *  3. 两者都不在本店(孤行)⇒ 一只任何已验身份都不可能等于的哨兵属主 `_orphan:<子代 id>`(前缀登记在 `security.ts` 的保留主体前缀里,鉴权边界拒任何报出它的主体)。
+ * 一只记下的根 / 父是空串(`''`)⇒ 读作没有那一格(与 `session-placement.ts` 的 `placementFromRow` 同一个读法;M23 的扫描句对连接键套 `NULLIF(…, '')`,与判据同读)。
+ * 写只 CAS 子行自己:`owner IS NULL ∧ incarnation = 扫描读到的子行化身 ∧ placed`({@link CLAIM_OWNERLESS_PLACED_SQL})。
+ * 对同一棵树,旧律的「根行的属主」与引擎的 D(根 run 读到的自己那一行的属主)是同一格的读数;两者只在「根行已不在」时分开(旧律取父 / 哨兵,引擎那时的读数没有留下)。
  *
- * ## 无主的子代行
- * 属主为 NULL 的 placed 行有两种来历:律给的(根无主 —— 一棵无身份调用方的树),或还没定下的(7.132.x 及更早写下的;判断时它读到的来源本身还是一只无主的
- * 委派子代行)。会话行属主门上的无主放行臂对它**只对 fleet 调用方成立**(出示 service 凭据、不报主体;唯一判据 `security.ts` 的 `ownerlessRowOpen`,
- * 会话面 / fork / 删除 / 审批豁免 / notify 同读;dev-open 照旧 fleet-wide),具名主体与没有 service 凭据的无身份调用方一律与别人的行同体 404 ——
- * 所以还没定下的行只是暂时只有 fleet 面读得到,不是谁都能读。它们由一次性迁移 M23(窗内每次起服)或这一行的下一次停驻(停驻挂点的认领)
- * 定下;两处都不承诺「一次收敛」。
- * **只有记录委派树的行才认领**:三只持久会话店的 placed 行都记着委派树(placement 元组:SQL 两店在 `session_meta`,local 店在会话存档行头);
- * 不记委派树的行(普通行,含升级前停驻时晋升进来的行)⇒ 没有可按的树 ⇒ 不认领(在停驻挂点照「属主不是律给的那一只 ⇒ 拒」处置)。不按更松的判据认领。
+ * ## 孤行哨兵前缀 —— **永久保留**(不随 M23 删)
+ * 已落库的行可能带着它(7.133.0–7.143.x 的建行推断与 M23 写下的);前缀从保留主体前缀里拿掉 = 让一个能自报 `_orphan:<id>` 的主体读到那些行。
  *
- * ## 三处写点 —— 律一只,**来源集按写点不同**(都调这里,不各写一份判据)
- *  · **三只持久会话店按 placement 建行**({@link createPlacedSessionRow}:`plugins/tidb-session-store.ts` / `plugins/pg-session-storage.ts` 的 acquire 一条 INSERT,属主与 placement
- *    同一笔落库;`plugins/local-session-store.ts` 的 acquire 先建存档(行头带元组)、再写会话元数据那一格(属主 + 化身))。来源 = placement 上的根、父两只 id({@link ownerSourcesOf});
- *    读来源 → 判 → 写(首写律)。读来源之后来源才变有主(滚动升级窗里别的副本的
- *    M23 回填了无主的父)⇒ 写下的仍是判断时的读数 —— 按律如此;那一行若因此无主,照上一节处置。
- *  · **停驻挂点**(`plugins/session-store.ts` 的 `attestChildSessionDurable`;只验、不搬):来源 = **调用方交出的委派树根,只有这一只**,连同
- *    调用方判断那一刻读到的根行住客({@link DelegationRootWitness};见证值,判断用,不进 CAS):请求腿 = 本请求经鉴权解析的会话,住客 = 受理时那一读
- *    (`boot/resolve-spec.ts`);`/decide` 的赎回腿 = 行上的 `rootSessionId`,住客 = 赎回腿写口放行的那一位(认领之前解析器那一读;`parked-revive-surface.ts`,每一行都交)。
- *    挂点先读一次根行:它在而住客不是见证的那一位 ⇒ 根被删、同 id 换了住客 ⇒ **拒**(不按新住客认领,{@link assertRootStillWitnessed});它不在 ⇒ 律给哨兵
- *    (根真没了)。不回落父:core 的挂点 `ensureChildSessionDurable(sessionId)` 只交子代 id,父 id 在这一写点拿不到;两条候选读法都读不到东西 ——
- *    ① 读子代行记下的父:记着委派树的行(placed 行)在下面的定夺里本就按**它记录的**根、父再判一次;不记委派树的行(升级前晋升进来的普通行)没有这一格;
- *    ② 登记簿(后台子代行 / core 注册簿):core 接口没有「按子代 sessionId 查行」的读口,SQL 表 `background_agent.session_id` 无索引,加一条只在一处用的私有读腿
- *       = 多一只读法;`scope` 列还把匿名折成 `"default"`(与真名 `default` 的租户不可分)。行上没有根(没有会话的取用形)⇒ 来源集空 ⇒ 哨兵。
- *    宿主行的属主经 {@link settleDelegatedOwner} 定下:宿主行记着委派树而不是这一棵 ⇒ 拒(两边属主都是 null 也拒);记着这一棵 ⇒ 按**它记录的** placement(根、父)
- *    再判一次(与 M23 对同一行同读数 —— 见证只答「是不是这一棵、根住客换没换」,来源集取行上记的),无主 ⇒ 认领(CAS 子行),认领试了没落下 ⇒ 拒;然后比对 ——
- *    不是律给的那一只 ⇒ 停驻否决。
- *  · **一次性迁移 M23**(`plugins/one-time-migrations.ts`):存量 placed 行,来源 = 根、父(扫描时同一条语句连读两行);回填 = 认领(同一句,绑扫描读到的子行化身)。
- * local 店没有第三处:它的 placed 行自本律起由第一处写下(属主在建行那一笔);存档在而那一格缺(建行两笔之间崩了,或同一数据根上 run-local 腿写下的 placed 存档)
- * 读作从没被记下的属主 = 无主,照「无主的子代行」一节处置(停驻挂点的认领)。
+ * ## 委派树根的见证 —— Runner 之外的后台子代完成 relay 的地址
+ * {@link DelegationRootWitness}:根会话 id + 调用方判断那一刻读到的根行住客(属主与化身)。读者 = 会话通知门的 relay(`session-notify-door.ts`)、会话行记录座、
+ * 请求腿的腿事实;停驻挂点自 7.144.0 起不读它。
  */
 import type { SessionPlacement } from "@sema-agent/core";
-import { type HeadRead, type SessionFace } from "./session-incarnation.js";
+import type { SessionFace } from "./session-incarnation.js";
 import type { SqlDialect } from "./plugins/sql-driver.js";
 /** 孤行哨兵属主的前缀(保留主体前缀:`security.ts` 的 `RESERVED_PRINCIPAL_PREFIXES` 登记它,任何身份来源报出带它的主体都在鉴权边界被拒)。 */
 export declare const ORPHAN_SESSION_OWNER_PREFIX = "_orphan:";
@@ -63,7 +37,7 @@ export declare function orphanSessionOwner(sessionId: string): string;
 export declare function isOrphanSessionOwner(owner: string | null): boolean;
 /** 一只来源行在本店的读数:`undefined` = 本店没有这一行;`null` = 行在、无主;串 = 属主(与 `headOf(id)?.owner` 的三态同义)。 */
 export type SourceOwnerReading = string | null | undefined;
-/** 律的判决:继承自哪一行(属主可以是 `null` = 来源行无主),或孤行(哨兵属主)。 */
+/** 旧律的判决:继承自哪一行(属主可以是 `null` = 来源行无主),或孤行(哨兵属主)。 */
 export type InheritedOwner = {
     readonly kind: "inherited";
     readonly owner: string | null;
@@ -72,122 +46,30 @@ export type InheritedOwner = {
     readonly kind: "orphan";
     readonly owner: string;
 };
-/** placement 上律要读的两格(调用方交的 `SessionPlacement`,或店里落库的那一份元组)。 */
+/** placement 上旧律要读的两格(M23 扫描行上记下的那一份元组)。 */
 export type PlacementSources = Pick<SessionPlacement, "rootSessionId" | "parentSessionId">;
 /** placement 上的来源 id,按读法顺序(根在前、父在后;去空、去重 —— 一层子代的根就是父)。 */
 export declare function ownerSourcesOf(placement: PlacementSources): readonly string[];
-/** 律本身(纯函数)。`sources` = 按读法顺序的 `[来源 id, 本店读数]`;第一只**在本店有行**的来源给出属主,一只都没有 ⇒ 孤行。 */
+/** 旧律本身(纯函数)。`sources` = 按读法顺序的 `[来源 id, 本店读数]`;第一只**在本店有行**的来源给出属主,一只都没有 ⇒ 孤行。 */
 export declare function inheritedOwnerOf(childId: string, sources: ReadonlyArray<readonly [string, SourceOwnerReading]>): InheritedOwner;
+/** M23 的**唯一判据**(纯函数):按记录的来源(placement 上的根、父)与它们此刻在本店的会话面(本店没有的 id 不在表里)判一次。 */
+export declare function judgeDelegatedOwner(childId: string, placement: PlacementSources, faces: ReadonlyMap<string, SessionFace>): InheritedOwner;
 /**
- * 判据读到的**委派树**:记下的根(`null` = 没有根 —— 缺或空串)+ 判据那一读里根行的住客(化身;`null` = 那一读里根行不在本店)。
- * 只在判断里用(停驻挂点:宿主行记下的根是不是这一棵、调用方见证之后根住客换没换);**不进认领句**(律:写只 CAS 子行自己)。
- */
-export interface DelegationTree {
-    readonly root: string | null;
-    readonly rootIncarnation: string | null;
-}
-/** 律的一次判:判决 + 读的来源 id(warn 行用)+ 判据读到的委派树(判断用)。 */
-export interface JudgedOwner {
-    readonly inherited: InheritedOwner;
-    readonly sources: readonly string[];
-    readonly tree: DelegationTree;
-}
-/**
- * **唯一的判据**(纯函数;三处写点都调它):按记录的来源(placement 上的根、父)与它们此刻在本店的会话面(属主 + 化身;本店没有的 id 不在表里)判一次 ——
- * 律给出属主(判断时见证到的),同时交出判据读到的委派树(判断用)。
- */
-export declare function judgeDelegatedOwner(childId: string, placement: PlacementSources, faces: ReadonlyMap<string, SessionFace>): JudgedOwner;
-/** 一次读回若干来源行的会话面(属主 + 化身;本店没有的 id 不在表里)。 */
-export type SourceFacesReader = (ids: readonly string[]) => Promise<ReadonlyMap<string, SessionFace>>;
-/** 按律读一次来源行、判一次(纯读,不告警 —— 孤行 warn 只在写落下之后,{@link reportWrittenOwner})。读失败照原样上抛(调用方的写随之失败,不猜一个属主)。 */
-export declare function readDelegatedOwner(childId: string, placement: PlacementSources, read: SourceFacesReader): Promise<JudgedOwner>;
-/** 孤行那一行 warn 的去处(logger 的子集)。 */
-export interface OrphanOwnerLog {
-    warn(msg: string, fields?: Record<string, unknown>): void;
-}
-/** 写点的名字(warn 行的 `site` 字段:运维据它知道是哪一笔写下的哨兵)。`placed_create` = 按 placement 建行;`park` = 停驻挂点对宿主无主 placed 行的认领。 */
-export type DelegatedOwnerSite = "placed_create" | "park";
-/** 一笔写**已落下**之后调:写下的是孤行哨兵 ⇒ 一行 warn(写失败的那一笔走不到这里,不留下「已写」的话)。继承来的属主(含继承自孤行祖先的哨兵)不告。 */
-export declare function reportWrittenOwner(log: OrphanOwnerLog, site: DelegatedOwnerSite, childId: string, judged: JudgedOwner): void;
-/**
- * 委派继承律的**认领句**(唯一的写法;停驻挂点对宿主无主行的认领与一次性迁移 M23 的回填**同一只**,都按 {@link claimOwnerlessParams} 绑参;窗随 M23)。
- * **只 CAS 子行自己**:这一位住客(判断时读到的化身)、仍无主、placed 行(原文 CAS,第二次命中零行)。不读根、不锁根、不连接 —— 判断与写之间根 / 父的变化
- * 不改变写进去的值(律:属主 = 判断时见证到的,本文件头注)。两方言只差占位符。
+ * M23 回填的**认领句**(唯一的写法;按 {@link claimOwnerlessParams} 绑参;窗随 M23)。**只 CAS 子行自己**:这一位住客(扫描读到的化身)、仍无主、placed 行
+ * (原文 CAS,第二次命中零行)。不读根、不锁根、不连接。两方言只差占位符。
  * MySQL 协议下 mysql2 缺省带 FOUND_ROWS,但条件里有 `owner IS NULL` ⇒ 匹配行数 = 改写行数。
  */
 export declare const CLAIM_OWNERLESS_PLACED_SQL: Readonly<Record<SqlDialect, string>>;
-/** 认领句的绑参(两方言同序;店与 M23 都经它,不各排一份):`incarnation` = 判断时读到的子行化身。 */
+/** 认领句的绑参(两方言同序):`incarnation` = 扫描读到的子行化身。 */
 export declare function claimOwnerlessParams(sessionId: string, incarnation: string, owner: string): readonly [string, string, string];
-/** 店的认领口(三只持久会话店 + 缓存包装层同一个签名):这只会话的那一位住客(`incarnation`)仍是无主的 placed 行 ⇒ 写 `owner`,返回是否写成。 */
-export type OwnerlessClaim = (sessionId: string, incarnation: string, owner: string) => Promise<boolean>;
-/** 一只 SQL 店建 placed 行要交的 I/O(两店按各自方言交,都是店的既有读写口;读法与顺序只住在 {@link createPlacedSessionRow})。 */
-export interface PlacedRowWriter {
-    /** 来源行的会话面一次读回。 */
-    readonly readFaces: SourceFacesReader;
-    /** 建行那一条 INSERT(属主与 placement 同一条落库;行已在 ⇒ 一个字节不动,首写律)。 */
-    insert(owner: string | null): Promise<void>;
-    /** 写后读回本行的属主(店的头读 `headOf(id)?.owner`:`undefined` = 行不在)—— 只为判「本笔的哨兵落没落下」。 */
-    readOwner(): Promise<string | null | undefined>;
-}
 /**
- * **SQL 两店建 placed 行的那一只**:读来源 → 判 → INSERT(属主 = 判断时见证到的,与 placement 同一笔落库)。INSERT 是首写律(行已在 ⇒ 不动),
- * 所以落库的那一行未必是本笔写的(同 id 的另一位建行者先落了)⇒ 读回属主:带着本笔判出的孤行哨兵才告一行 warn;别的 ⇒ 什么都没写下,不告。
- * 不写后复核:判断之后来源才变有主,写下的仍是判断时的读数(律;那一行若因此无主,由无主放行臂的判据挡住非 fleet 调用方、由 M23 / 下一次停驻定下 —— 本文件头注)。
- */
-export declare function createPlacedSessionRow(sessionId: string, placement: PlacementSources, io: PlacedRowWriter, log: OrphanOwnerLog): Promise<void>;
-/**
- * 停驻挂点的**见证**:调用方交出的委派树根 + 调用方判断那一刻读到的根行住客(属主与化身,同一读;化身 `null` = 那一读里根行不在,此时属主恒 `null`)。
+ * **委派树根的见证**:调用方交出的委派树根 + 调用方判断那一刻读到的根行住客(属主与化身,同一读;化身 `null` = 那一读里根行不在,此时属主恒 `null`)。
  * 请求腿 = 鉴权解析的会话与受理时那一读;赎回腿 = 行上的根与写口放行的那一位住客(认领之前解析器那一读)。
- * 读者:停驻挂点({@link assertRootStillWitnessed},只比化身)、会话行记录座(化身)、后台子代完成 relay(属主与化身,会话通知门的目标住客)。
+ * 读者:后台子代完成 relay(属主与化身,会话通知门的目标住客)、会话行记录座(化身)、请求腿的腿事实。
  */
 export interface DelegationRootWitness {
     readonly sessionId: string;
     readonly owner: string | null;
     readonly incarnation: string | null;
 }
-/**
- * 「根行的化身已换 ⇒ 拒」在停驻挂点的那一道(挂点的见证是更早的一读,不是这一读):此刻根行在、而住客不是见证的那一位(见证那一读里不在,或是另一位)⇒ 抛。
- * 根行此刻不在 ⇒ 不抛(根真没了 ⇒ 律给哨兵,不是「换了住客」)。这是**判断**的一部分;判断之后、写之前根的变化不改变写进去的值(律:属主 = 判断时见证到的)。
- */
-export declare function assertRootStillWitnessed(sessionId: string, witness: Pick<DelegationRootWitness, "incarnation"> | undefined, judged: JudgedOwner): void;
-/** 记录委派树的宿主店多交的两只口(三只持久会话店与缓存包装层;无 repo 的内存店两只都没有 ⇒ 没有可按的树 ⇒ 不认领)。 */
-export interface DelegationTreeStore {
-    /** 本行落库的 placement 元组(`undefined` = 本行不是 placed 行 ⇒ 不记委派树)。 */
-    readonly placementOf: (sessionId: string) => Promise<PlacementSources | undefined>;
-    readonly claimOwnerless: OwnerlessClaim;
-}
-/** 停驻挂点要的宿主店口(按 id 读一行的唯一读口 `headOf` —— 属主与住客都是它的投影;记录委派树的店另有 {@link DelegationTreeStore})。 */
-export interface DelegatedOwnerHost {
-    readonly headOf: HeadRead;
-    /** 缺席 = 这只店不记委派树(不实现 placement)。 */
-    readonly trees: DelegationTreeStore | undefined;
-}
-/**
- * 「这只宿主店能不能承载委派子代的属主」—— 只判这一处(停驻挂点读它):店有按 id 的头读(`headOf`,「有没有」沿用 `headReadOf` 的同一处判法)⇒
- * 绑好的 {@link DelegatedOwnerHost};没有 ⇒ `undefined`(调用方响亮拒:读不回属主的宿主店上,停驻出来的就是一只谁都能读的转录)。记录委派树的两只口
- * (`placementOf` + `claimOwnerless`)**同在或同缺**:同在 ⇒ `trees`;同缺 ⇒ 不记委派树;只有一只 ⇒ `undefined`(记着树却认领不了,或认领却读不回树 —— 半只店不猜)。
- */
-export declare function delegatedOwnerHostOf(store: {
-    readonly headOf?: unknown;
-    readonly placementOf?: (sessionId: string) => Promise<PlacementSources | undefined>;
-    readonly claimOwnerless?: OwnerlessClaim;
-}): DelegatedOwnerHost | undefined;
-/** {@link settleDelegatedOwner} 的结果:这一笔是否写下了属主(认领成了);`judged` = 宿主行记着委派树时按**它记录的树**的那一次判(缺席 = 行不记委派树,按调用方的判)。 */
-export interface SettledOwner {
-    readonly claimed: boolean;
-    readonly judged: JudgedOwner | undefined;
-}
-/**
- * 宿主店里这只会话的行属主**按律定下来**(停驻挂点的那一道;拒句不带任何一方的属主值 —— 它会进停驻否决的错误面)。
- * `owner` / `tree` = 调用方按见证的根判出的属主与委派树。
- *  1. 宿主行**记着委派树**(placed 行):记下的根 ≠ `tree.root` ⇒ 抛(不以属主是否 null 为前提:那是另一棵树的行);是这一棵 ⇒ **按它记录的 placement(根、父)
- *     再判一次**(唯一判据 {@link judgeDelegatedOwner} —— 与 M23 / 建行复核对这一行同读数:根不在取父),调用方那一读之后根住客变了 ⇒ 抛({@link assertRootStillWitnessed},
- *     调用方的读数当见证);行无主而律给出属主 ⇒ 认领(CAS 刚读到的那一位住客;写进去的是这一次判的读数)—— **试了没落下 ⇒ 抛**(这一行在判断之后被写过 /
- *     删过 / 换了住客,不由事后的属主比对放行);
- *  2. 不记委派树的行(普通行,含升级前晋升进来的行)不认领、不再判;
- *  3. 比对 —— 此刻的属主不是律给的那一只(记着委派树 ⇒ 按记录的树判的那一只;否则 = `owner`)⇒ 抛。
- */
-export declare function settleDelegatedOwner(host: DelegatedOwnerHost, sessionId: string, owner: string | null, tree: DelegationTree): Promise<SettledOwner>;
-/** 按 id 逐只读头的店(`headOf`,活住客经 `sessionFaceOfHead` 投影 —— 空化身响亮拒)→ {@link SourceFacesReader}。 */
-export declare function sourceFacesVia(headOf: HeadRead): SourceFacesReader;
 //# sourceMappingURL=delegated-session-owner.d.ts.map

package/dist/delegated-session-owner.js

@@ -1,4 +1,3 @@
-import { headReadOf, sessionFaceOfHead } from "./session-incarnation.js";
 export const ORPHAN_SESSION_OWNER_PREFIX = "_orphan:";
 export function orphanSessionOwner(sessionId) {
     return `${ORPHAN_SESSION_OWNER_PREFIX}${sessionId}`;
@@ -25,26 +24,7 @@ export function inheritedOwnerOf(childId, sources) {
     return { kind: "orphan", owner: orphanSessionOwner(childId) };
 }
 export function judgeDelegatedOwner(childId, placement, faces) {
-    const sources = ownerSourcesOf(placement);
-    const inherited = inheritedOwnerOf(childId, sources.map((id) => [id, faces.get(id)?.owner]));
-    const root = sourceIdOf(placement.rootSessionId) ?? null;
-    return { inherited, sources, tree: { root, rootIncarnation: root === null ? null : (faces.get(root)?.incarnation ?? null) } };
-}
-export async function readDelegatedOwner(childId, placement, read) {
-    const ids = ownerSourcesOf(placement);
-    return judgeDelegatedOwner(childId, placement, ids.length === 0 ? new Map() : await read(ids));
-}
-export function reportWrittenOwner(log, site, childId, judged) {
-    if (judged.inherited.kind !== "orphan")
-        return;
-    log.warn("delegated_session_owner_orphaned", {
-        sessionId: childId,
-        site,
-        sources: judged.sources,
-        owner: judged.inherited.owner,
-        note: "a delegated session's owner could not be derived: none of the sessions it was delegated from has a row in this session store (none was named, or they are gone), " +
-            "so the session was written with an owner no caller can match — only fleet-wide and operator faces reach it. If someone should read it, set its owner in the session store by hand",
-    });
+    return inheritedOwnerOf(childId, ownerSourcesOf(placement).map((id) => [id, faces.get(id)?.owner]));
 }
 export const CLAIM_OWNERLESS_PLACED_SQL = {
     mysql: "UPDATE session_meta SET owner = ? WHERE session_id = ? AND incarnation = ? AND owner IS NULL AND placement_kind IS NOT NULL",
@@ -53,66 +33,4 @@ export const CLAIM_OWNERLESS_PLACED_SQL = {
 export function claimOwnerlessParams(sessionId, incarnation, owner) {
     return [owner, sessionId, incarnation];
 }
-export async function createPlacedSessionRow(sessionId, placement, io, log) {
-    const judged = await readDelegatedOwner(sessionId, placement, io.readFaces);
-    await io.insert(judged.inherited.owner);
-    if (judged.inherited.kind === "orphan" && (await io.readOwner()) === judged.inherited.owner)
-        reportWrittenOwner(log, "placed_create", sessionId, judged);
-}
-export function assertRootStillWitnessed(sessionId, witness, judged) {
-    if (witness === undefined || judged.tree.rootIncarnation === null || judged.tree.rootIncarnation === witness.incarnation)
-        return;
-    throw new Error(`session "${sessionId}" cannot be parked as this delegated session: its delegation tree's root session was deleted and its id registered again since the delegation was judged, ` +
-        "so the root's current owner is not the owner of this delegation tree");
-}
-export function delegatedOwnerHostOf(store) {
-    const headOf = headReadOf(store);
-    const placementOf = store.placementOf;
-    const claimOwnerless = store.claimOwnerless;
-    if (headOf === undefined)
-        return undefined;
-    if ((typeof placementOf === "function") !== (typeof claimOwnerless === "function"))
-        return undefined;
-    const trees = typeof placementOf === "function" && typeof claimOwnerless === "function"
-        ? { placementOf: (id) => placementOf.call(store, id), claimOwnerless: (id, incarnation, owner) => claimOwnerless.call(store, id, incarnation, owner) }
-        : undefined;
-    return { headOf, trees };
-}
-export async function settleDelegatedOwner(host, sessionId, owner, tree) {
-    const refuse = () => new Error(`session "${sessionId}" cannot be parked as this delegated session: the host session store holds a session with this id that is not this delegation tree's ` +
-        "(a different owner, or a different recorded delegation root), so it does not attest this delegated transcript");
-    const face = sessionFaceOfHead(sessionId, await host.headOf(sessionId));
-    const trees = host.trees;
-    const recorded = face === undefined || trees === undefined ? undefined : await trees.placementOf(sessionId);
-    let expected = owner;
-    let judged;
-    let claimed = false;
-    if (face !== undefined && trees !== undefined && recorded !== undefined) {
-        if ((sourceIdOf(recorded.rootSessionId) ?? null) !== tree.root)
-            throw refuse();
-        judged = await readDelegatedOwner(sessionId, recorded, sourceFacesVia(host.headOf));
-        if (tree.root !== null)
-            assertRootStillWitnessed(sessionId, { incarnation: tree.rootIncarnation }, judged);
-        expected = judged.inherited.owner;
-        if (face.owner === null && expected !== null) {
-            claimed = await trees.claimOwnerless(sessionId, face.incarnation, expected);
-            if (!claimed)
-                throw refuse();
-        }
-    }
-    if ((await host.headOf(sessionId))?.owner !== expected)
-        throw refuse();
-    return { claimed, judged };
-}
-export function sourceFacesVia(headOf) {
-    return async (ids) => {
-        const out = new Map();
-        for (const id of ids) {
-            const face = sessionFaceOfHead(id, await headOf(id));
-            if (face !== undefined)
-                out.set(id, face);
-        }
-        return out;
-    };
-}
 //# sourceMappingURL=delegated-session-owner.js.map

package/dist/entry-mode-clamp-notice.d.ts

@@ -18,7 +18,7 @@
  * `{ requested, effective, ceiling, sessionId }` —— `requested` = 被折的那个词(体的生效词:顶层 `permissionMode` 或
  * `settings.permissions.defaultMode`)、`effective` = run 起步的词、`ceiling` = 折它的地板,三个都是 core 的模式闭集词;`sessionId` = 归属键。
  * 🔴 **无 `runId`**:钳制发生在受理门,引擎的 run 身份要到 prepare 才铸,这一刻不存在(core 码册那一行写了 `runId`;本仓不编造,
- * 归属看它落在哪条 run 的流 / 账本上 —— 与 `instructions.source_changed` / `session.records_skipped` 同形)。
+ * 归属看它落在哪条 run 的流 / 账本上 —— 与 `instructions.source_changed` 同形)。
  * 什么时候不铸:没有地板;没声明词(取地板本身不算改词,`clamped` 为假);请求的词不比地板松;会话 id 缺席(无处可投,宁缺不串)。
  */
 import type { EngineNotice, EngineNoticeCode } from "@sema-agent/core";

package/dist/execution-placement.d.ts

@@ -87,11 +87,12 @@ export interface ExecutionPlacementSeat {
 }
 /**
  * 读不出的存档的故障词(闭集;一次性迁移 M32 的 local 腿点名用 —— 随 M32 · 窗口见 `plugins/one-time-migrations.ts` 登记表,窗关后随迁移码删):
- *  · `corrupt_session` —— 存档在,会话头读不出 / 截断;`invalid_session` —— 读得出而日志结构走不通(两个都是 core 的 `SessionError` 词,原样);
+ *  · `corrupt_session` —— 存档在,会话头读不出 / 截断,或读得出而日志走不成一棵树(core 的 `SessionError` 词,原样;后一形在 core 7.61.x 及以前是 `invalid_session`,
+ *    core 7.62.0 [ref] 起两形一个词,本闭集随之收窄);
  *  · `storage` —— 读的时候抛了**别的**故障(I/O 级:权限 / 磁盘 I/O / 超大 —— core 的 `readJsonlRecords` 只吞 ENOENT,其余 errno 原样抛,不是 `SessionError`),
  *    说不出在不在也说不出内容;{@link UnusableArchive.errno} 带那只故障的 `code`。
  */
-export type UnusableArchiveWord = "corrupt_session" | "invalid_session" | "storage";
+export type UnusableArchiveWord = "corrupt_session" | "storage";
 /**
  * local 的会话存档**读不出**(会话头读不出 / 日志结构走不通 / 读的时候抛了别的故障):盘上有这只会话的存档,只是读不出它 —— 与「不在」是两件事。
  * (本型与 {@link isUnusableArchive} 随 M32 · 窗口见 `plugins/one-time-migrations.ts` 登记表。)
@@ -135,8 +136,10 @@ export declare function executionPlacementView(cell: ExecutionPlacementCell): Ex
 /**
  * 住客谓词的 JS 读法(SQL `incarnation = ? AND owner <=> ?` 的对位)= core 的行期望判官 `sessionRowMatches`(会话行格写原语锁内判的也是它,
  * `session-row.ts` 的 `judgeSessionRowWrite`):属主与化身两样都没变才是判过的那一位 —— 同一化身的属主会变(local M10 认领、identical 重戳、
- * SQL 导入提交点改属主)。两侧收「属主 + 化身」那一读:活住客(`SessionFace`)与店的头(`SessionHead`,门判过的那一读);调用方一侧恒是执行席的读数
- * (住客经 `sessionFaceFromRow` 解码,令牌非空),所以「两侧都没有令牌」这一形在这里不可达。写口的判官与执行上下文解析器步 ① 的 `judged` 复核都经它。
+ * SQL 导入提交点改属主)。两侧收「属主 + 化身」那一读:活住客(`SessionFace`)与店的头(`SessionHead`,门判过的那一读)。三处调用方:
+ *  · 执行格的写口判官(本模块)与执行上下文解析器步 ① 的 `judged` 复核(`http/execution-context.ts`)—— 一侧恒是执行席的读数(住客经 `sessionFaceFromRow` 解码,令牌非空);
+ *  · 会话通知门投递前的住客复核(`session-notify-door.ts` 的 `recheck`)—— 两侧都是会话店的头读:不铸化身的店上**两侧都没有令牌**。
+ * 两侧都没有令牌 ⇒ 化身一项 `undefined === undefined` 恒等,判据退成**只比属主**(core 判官本身的读法,不是本处的特例);一侧有一侧没有 ⇒ 不是同一位。
  */
 export declare function sameOccupant(a: Pick<SessionHead, "owner" | "incarnation">, b: Pick<SessionHead, "owner" | "incarnation">): boolean;
 /**

package/dist/hooks/classic-stations.d.ts

@@ -11,7 +11,7 @@
  *     它是 handler 体的第二个入参 —— 触发之后 handler 不再起新事、在飞的子进程要叫停(`hooks/hook-runner.ts` 的命令钩子腿)。
  *
  * 站的集合 = 引擎事件表里有站的 `classic.*` 名(一条钉从 `MOD_EVENT_TABLE` 派生对拍,不手抄第二份)。
- * 观察站(`StopFailure` / `PostCompact` / `PermissionDenied`)只许观察者:答案形是「无」,core 的迁移配方要求挂 `{ observe: true }`。
+ * 观察站(`StopFailure` / `PostCompact` / `PermissionDenied` / `SessionStart` / `SessionEnd`)只许观察者:答案形是「无」,core 的迁移配方要求挂 `{ observe: true }`。
  */
 import type { ClassicEventMap, ClassicEventName, EngineDollar, On } from "@sema-agent/core";
 /** 引擎有站的 `classic.*` 名(core 的 `ClassicEventMap` 键集)。 */
@@ -30,6 +30,8 @@ export declare const CLASSIC_STATION_ROLE: {
     readonly "classic.PreCompact": "chain";
     readonly "classic.PostCompact": "observe";
     readonly "classic.PermissionDenied": "observe";
+    readonly "classic.SessionStart": "observe";
+    readonly "classic.SessionEnd": "observe";
 };
 /** 本仓 handler 体对一站作的答:观察站不作答(`void`);链站 = core 的答案形,去掉本仓从不作的 `null` / `false`(PreToolUse 的两个「不表态」词)。 */
 type StationAnswer<K extends ClassicStation> = (typeof CLASSIC_STATION_ROLE)[K] extends "observe" ? void : Exclude<ClassicEventMap[K]["answer"], null | false>;

package/dist/hooks/classic-stations.js

@@ -11,6 +11,8 @@ export const CLASSIC_STATION_ROLE = {
     "classic.PreCompact": "chain",
     "classic.PostCompact": "observe",
     "classic.PermissionDenied": "observe",
+    "classic.SessionStart": "observe",
+    "classic.SessionEnd": "observe",
 };
 export function hangClassic(on, station, answer) {
     if (CLASSIC_STATION_ROLE[station] === "observe") {