@sema-agent/server 7.109.0 → 7.111.0

package/dist/http/resume-legs.js

@@ -20,6 +20,7 @@ import { buildCheckpointAnchorHash } from "../approval-ask-audit-store.js";
 import { TERMINAL_PARK_GATE_KINDS } from "../plugins/checkpoint-store-sql.js";
 import { withPrincipal } from "../observability/principal-context.js";
 import { withModelReachScope } from "../model-reach-scope.js";
+import { createInstructionSelectionLeg } from "../instruction-selection.js";
 import { modelTextEventData, turnEndEventData, contextUsageEventData, toolStartEventData, toolEndEventData, taskProgressEventData, taskNotificationEventData, compactedEventData, diagnosticsEventData, brainStatusEventData, steeringInjectedEventData, compactionOutcomeEventData, workspaceChangedEventData, wiringManifestEventData, toolRosterDeltaEventData, toolDisclosureEventData, humanInputEventData, appendModelUsageDelta, appendPromptManifest, attachModelUsage } from "../trace/project.js";
 import { redactSecrets } from "../trace/redact.js";
 import { createLedgerSink, createSerialLedgerAppend } from "../trace/ledger-sink.js";
@@ -503,7 +504,8 @@ export function createResumeLegs(ctx) {
             await args.onResumeCommitted();
         let unregisterEngineNotice;
         try {
-            result = await withModelReachScope(sessionId, () => withPrincipal(principal, async () => {
+            const instructionLeg = createInstructionSelectionLeg();
+            result = await instructionLeg.run(sessionId, () => withModelReachScope(sessionId, () => withPrincipal(principal, async () => {
                 const resumeNotifiedKeys = new NotifiedKeys();
                 if (deps.runStore && taskId) {
                     const rs0 = deps.runStore;
@@ -526,6 +528,7 @@ export function createResumeLegs(ctx) {
                         persistThinking: deps.config.traceThinking,
                         notifiedKeys: resumeNotifiedKeys,
                         ...(taskId ? { onActivity: () => recordTurnActivity(taskId) } : {}),
+                        instructionsSegment: instructionLeg.segment,
                     });
                     const vAppend = (type, data) => verifySink.append(type, data);
                     const verifyTailContentMode = resumeTaskConfig.forwardSubagentEvents === true ? "on" : "progress_only";
@@ -622,11 +625,14 @@ export function createResumeLegs(ctx) {
                 unregisterEngineNotice = registerEngineNoticeLeg({
                     sessionId,
                     ...(args.engineNotices !== undefined && args.engineNotices.length > 0 ? { pending: [...args.engineNotices] } : {}),
-                    durable: (row) => void append("engine_notice", row).catch((err) => {
+                    durable: (row) => append("engine_notice", row).then(() => true, (err) => {
                         recordFailOpen("server.engine-notice.durable-append-failed", `leg=resume code=${row.code} task=${taskId ?? ""}`);
                         deps.logger?.warn?.("engine_notice_append_failed", { taskId, noticeCode: row.code, sessionId: row.sessionId, err: err instanceof Error ? err.message : String(err) });
+                        return false;
                     }),
                 });
+                if (deps.userInputLedger && taskId)
+                    await deps.userInputLedger.announceUndrained({ sessionId, taskId });
                 const anchorOwner = principal ?? null;
                 const getLeafId = deps.sessionStorage?.getLeafId?.bind(deps.sessionStorage);
                 const captureTurnAnchor = deps.resumeAnchorStore && getLeafId
@@ -768,7 +774,7 @@ export function createResumeLegs(ctx) {
                                 break;
                             case "wiring_manifest":
                                 await flush();
-                                await append("wiring_manifest", wiringManifestEventData(ev));
+                                await append("wiring_manifest", wiringManifestEventData(ev, instructionLeg.segment()));
                                 break;
                             case "tool_roster_delta": {
                                 await flush();
@@ -872,7 +878,7 @@ export function createResumeLegs(ctx) {
                 return await (deps.sendUserFile && taskId
                     ? deps.sendUserFile.runWithContext({ taskId, emit: async (frame) => { const { type, ...rest } = frame; await append(type, rest); } }, withElicitation)
                     : withElicitation());
-            }));
+            })));
         }
         catch (e) {
             if (e instanceof CheckpointError) {
@@ -964,6 +970,8 @@ export function createResumeLegs(ctx) {
         finally {
             unregisterEngineNotice?.();
             if (taskId) {
+                if (resumeStreamRef !== undefined)
+                    await deps.userInputLedger?.settleLeg(resumeStreamRef);
                 if (inflightRuns.get(taskId) === cancelCtrl)
                     inflightRuns.delete(taskId);
                 if (preemptableRuns.get(taskId) === preemptCtrl)

package/dist/http/routes/runs.d.ts

@@ -6,7 +6,6 @@ import type { RouteCtx, PreparedTaskSubmission, RouteMatch, RouteIdsOf } from ".
  *  —— 导出的是**行为**而不是 schema 对象:schema 的推断类型会牵出 registry-core 内嵌的 zod 路径
  *  (TS2742,不可移植),而这道门要钉的本来就是行为。非 wire 面。 */
 export declare function projectDecisionActor(raw: unknown): ActorAssertionWire | undefined;
-/** 子代理 / 任务句柄 / HITL 应答段——`handle()` 里它在 SVC-5 workflow steer **之后**,故是独立的域入口。 */
 /** 路由体 = 从 `server.ts` 的 `handle()` 里**整段剪切**过来的原文(唯一改动:统一去缩进两格)。裸 `return;`
  *  = 「本域已应答」;走到函数尾才是「没匹配上」。跨域的东西一律在首行解构出来。 */
 export declare function handleRuns(req: IncomingMessage, res: ServerResponse, match: RouteMatch<RunsRouteId>, ctx: RouteCtx): Promise<void>;

package/dist/http/routes/runs.js

@@ -134,6 +134,18 @@ async function streamRunEvents(req, res, deps, runStore, taskId, staleMs) {
         staleFrame: () => ({ event: "failed", data: { type: "failed", errorMessage: "run stalled (instance lost?)" } }),
     }, taskId, staleMs);
 }
+async function acceptLiveUserInput(deps, res, at) {
+    if (!deps.userInputLedger)
+        return undefined;
+    try {
+        return await deps.userInputLedger.accept({ input: "steer", messageId: at.messageId, sessionId: at.sessionId, taskId: at.taskId, leg: at.leg });
+    }
+    catch (e) {
+        deps.logger?.warn?.("user_input_ledger_accept_failed", { taskId: at.taskId, sessionId: at.sessionId, err: e instanceof Error ? e.message : String(e) });
+        sendError(res, 503, "steering.ledger_unavailable", "this steer was NOT delivered: the server could not record it in its user-input ledger (an acceptance receipt is only given once the acceptance is durable, so a crash before the run consumes it can be announced) — nothing reached the engine; retry later");
+        return "refused";
+    }
+}
 export async function handleRuns(req, res, match, ctx) {
     const { deps } = ctx;
     const { idemCache, inflightRuns, preemptableRuns, cancelledViaVerb, steerableRuns, wakeParkMints } = ctx.registry;
@@ -468,12 +480,17 @@ export async function handleRuns(req, res, match, ctx) {
         const sendNotRunning = (error) => sendError(res, 409, "steering.not_running", error);
         const live = steerableRuns.get(taskId);
         if (live) {
+            const acceptance = await acceptLiveUserInput(deps, res, { messageId, sessionId: run.sessionId, taskId, leg: live });
+            if (acceptance === "refused")
+                return;
             try {
                 await live.steer(text, { trusted, ...(steerInputId !== undefined ? { inputId: steerInputId } : {}) });
                 sendJson(res, 200, { taskId, status: "running", delivery: "applied", messageId, ...(priority ? { priority } : {}) });
                 return;
             }
             catch (e) {
+                if (acceptance !== undefined)
+                    await deps.userInputLedger.withdraw(acceptance);
                 const code = e.code;
                 if (code === "steering.invalid_content") {
                     sendError(res, 422, "steering.invalid_content", e instanceof Error ? e.message : "invalid steering content");
@@ -776,10 +793,15 @@ export async function handleRuns(req, res, match, ctx) {
             });
             return;
         }
+        const acceptance = await acceptLiveUserInput(deps, res, { messageId: interruptMessageId, sessionId: run.sessionId, taskId, leg: liveStream });
+        if (acceptance === "refused")
+            return;
         try {
             await liveStream.steer(text, { trusted, priority: "now", ...(interruptInputId !== undefined ? { inputId: interruptInputId } : {}) });
         }
         catch (e) {
+            if (acceptance !== undefined)
+                await deps.userInputLedger.withdraw(acceptance);
             const code = e.code;
             if (code === "steering.invalid_content") {
                 sendError(res, 422, "steering.invalid_content", e instanceof Error ? e.message : "invalid steering content");
@@ -1133,6 +1155,7 @@ export async function handleRunVerbs(req, res, match, ctx) {
         }
         const handle = resolution?.handle;
         if (handle) {
+            let acceptance;
             try {
                 if (verb === "resume") {
                     if (!handle.resume) {
@@ -1148,11 +1171,23 @@ export async function handleRunVerbs(req, res, match, ctx) {
                     sendJson(res, 200, { taskId: runId, target, status: "running", delivery: "applied", marker, note: `Message queued for delivery to ${handle.agentName ?? target}; it will continue in the background.` });
                     return;
                 }
+                const messageId = uuidv7();
+                const accepted = await acceptLiveUserInput(deps, res, { messageId, sessionId: run.sessionId, taskId: runId, leg: handle });
+                if (accepted === "refused")
+                    return;
+                acceptance = accepted;
                 const marker = await handle.steer(redacted);
-                sendJson(res, 200, { taskId: runId, target, status: "running", delivery: "applied", marker, note: `Message queued for delivery to ${handle.agentName ?? target} at its next tool round.` });
+                if (acceptance !== undefined) {
+                    const ledger = deps.userInputLedger;
+                    const settle = () => ledger.settleLeg(handle);
+                    void handle.settled.then(settle, settle);
+                }
+                sendJson(res, 200, { taskId: runId, target, status: "running", delivery: "applied", messageId, marker, note: `Message queued for delivery to ${handle.agentName ?? target} at its next tool round.` });
                 return;
             }
             catch (e) {
+                if (acceptance !== undefined)
+                    await deps.userInputLedger.withdraw(acceptance);
                 const code = e.code;
                 if (code === "steering.not_running") {
                     send409(code, "sub-agent just finished — no longer accepting steers");

package/dist/http/routes/sessions.js

@@ -618,8 +618,18 @@ export async function handleSessions(req, res, match, ctx) {
             const tail = qi("tail");
             const before = qi("before");
             const blobCap = qi("blobCap");
+            let undrained;
+            if (deps.userInputLedger) {
+                try {
+                    undrained = await deps.userInputLedger.readSession(match.params.sessionId);
+                }
+                catch (e) {
+                    recordFailOpen("server.user-input-ledger.read-failed", `op=session-view ${e instanceof Error ? e.message : String(e)}`);
+                }
+            }
+            const undrainedKey = undrained !== undefined ? { userInputUndrained: undrained } : {};
             if (tail === undefined && before === undefined && blobCap === undefined) {
-                sendJson(res, 200, audit);
+                sendJson(res, 200, { ...audit, ...undrainedKey });
                 return;
             }
             let messages = audit.messages;
@@ -631,7 +641,7 @@ export async function handleSessions(req, res, match, ctx) {
             }
             if (blobCap !== undefined && blobCap > 0)
                 messages = truncateMessageBlobs(messages, blobCap);
-            sendJson(res, 200, { ...audit, messages, ...(window ? { window } : {}) });
+            sendJson(res, 200, { ...audit, messages, ...(window ? { window } : {}), ...undrainedKey });
             return;
         }
     }

package/dist/http/routes/tasks.js

@@ -28,6 +28,7 @@ import { failOpenTagForDroppedFrame, recordFailOpen } from "../../observability/
 import { buildSyncSubmitBody } from "../sync-submit-body.js";
 import { assertNever } from "../route-ctx.js";
 import { withModelReachScope } from "../../model-reach-scope.js";
+import { createInstructionSelectionLeg } from "../../instruction-selection.js";
 const DISCONNECT_PARK_GRACE_MS = 10_000;
 function sseData(res, payload) {
     const anchor = payload.eventId;
@@ -114,6 +115,7 @@ export async function handleTasks(req, res, match, ctx) {
         const principal = prepared.auth?.principal;
         const wiringOperatorFace = explicitOperatorOk(gatedPrincipal(req, deps.config), deps.config.operatorPrincipals);
         let wiringReceipt;
+        const instructionLeg = createInstructionSelectionLeg();
         const withRunReceipt = (out) => wiringReceipt !== undefined ? { ...out, wiringManifest: wiringReceipt } : out;
         if (liveStream) {
             if (prepared.verify || prepared.cascade) {
@@ -261,7 +263,7 @@ export async function handleTasks(req, res, match, ctx) {
                 if (durableTaskId && deps.runStore) {
                     const rs = deps.runStore;
                     const tid = durableTaskId;
-                    ledgerSink = createLedgerSink({ appendEvent: (seq, type, data) => rs.appendEvent(tid, seq, type, data), persistThinking: deps.config.traceThinking, onActivity: (kind, statusData) => recordTurnActivity(tid, kind, statusData) });
+                    ledgerSink = createLedgerSink({ appendEvent: (seq, type, data) => rs.appendEvent(tid, seq, type, data), persistThinking: deps.config.traceThinking, onActivity: (kind, statusData) => recordTurnActivity(tid, kind, statusData), instructionsSegment: instructionLeg.segment });
                     usageKey = tid;
                     deps.modelUsage?.register(tid);
                     const owner = principal ?? null;
@@ -333,10 +335,12 @@ export async function handleTasks(req, res, match, ctx) {
                     },
                     ...(noticeLedger
                         ? {
-                            durable: (row) => void noticeLedger.append("engine_notice", row).catch(() => recordFailOpen("server.engine-notice.durable-append-failed", `leg=sync code=${row.code} task=${durableTaskId ?? ""}`)),
+                            durable: (row) => noticeLedger.append("engine_notice", row).then(() => true, () => (recordFailOpen("server.engine-notice.durable-append-failed", `leg=sync code=${row.code} task=${durableTaskId ?? ""}`), false)),
                         }
                         : {}),
                 });
+                if (deps.userInputLedger && durableTaskId && prepared.spec.sessionId)
+                    await deps.userInputLedger.announceUndrained({ sessionId: prepared.spec.sessionId, taskId: durableTaskId });
                 try {
                     const streamBody = async () => {
                         await withPrincipal(principal, async () => {
@@ -502,7 +506,7 @@ export async function handleTasks(req, res, match, ctx) {
                                     sseData(res, { type: "compaction_outcome", ...compactionOutcomeEventData(ev) });
                                 }
                                 else if (ev.type === "wiring_manifest") {
-                                    const wiringFace = wiringManifestFaceEventData(ev, wiringOperatorFace);
+                                    const wiringFace = wiringManifestFaceEventData(ev, wiringOperatorFace, instructionLeg.segment());
                                     wiringReceipt ??= wiringFace;
                                     sseData(res, { type: "wiring_manifest", ...wiringFace });
                                 }
@@ -645,7 +649,7 @@ export async function handleTasks(req, res, match, ctx) {
                             });
                     }
                     const withApproval = () => approvalCtx && deps.toolApproval ? deps.toolApproval.runWithContext(approvalCtx, withQuestion) : withQuestion();
-                    await withModelReachScope(prepared.spec.sessionId, () => deps.sendUserFile
+                    await instructionLeg.run(prepared.spec.sessionId, () => withModelReachScope(prepared.spec.sessionId, () => deps.sendUserFile
                         ? deps.sendUserFile.runWithContext({
                             taskId: askTaskId,
                             emit: async (f) => {
@@ -656,7 +660,7 @@ export async function handleTasks(req, res, match, ctx) {
                                 }
                             },
                         }, withApproval)
-                        : withApproval());
+                        : withApproval()));
                     if (durableTaskId && deps.runStore) {
                         const finalPlane = finalResult ? outwardPlane(finalResult.terminal) : undefined;
                         if (finalResult && finalPlane?.status === "suspended" && deps.checkpointStore)
@@ -700,6 +704,8 @@ export async function handleTasks(req, res, match, ctx) {
                         clearInterval(durableHeartbeat);
                     if (durableTaskId && steerableRuns.get(durableTaskId) === liveStreamRef)
                         steerableRuns.delete(durableTaskId);
+                    if (liveStreamRef !== undefined)
+                        await deps.userInputLedger?.settleLeg(liveStreamRef);
                     if (durableTaskId && inflightRuns.get(durableTaskId) === ac) {
                         inflightRuns.delete(durableTaskId);
                         cancelledViaVerb.delete(durableTaskId);
@@ -832,7 +838,7 @@ export async function handleTasks(req, res, match, ctx) {
                 const observeSyncLegEvent = (ev) => {
                     if (ev.type !== "wiring_manifest" || wiringReceipt !== undefined)
                         return;
-                    wiringReceipt = wiringManifestFaceEventData(ev, wiringOperatorFace);
+                    wiringReceipt = wiringManifestFaceEventData(ev, wiringOperatorFace, instructionLeg.segment());
                 };
                 let result;
                 let cancelVerbLabel = false;
@@ -846,7 +852,7 @@ export async function handleTasks(req, res, match, ctx) {
                             observeSyncLegEvent(ev);
                         return stream.result();
                     };
-                    result = await withPrincipal(principal, () => prepared.verify ? verifyLeg(prepared.verify) : prepared.cascade ? cascadeLeg() : plainLeg());
+                    result = await instructionLeg.run(prepared.spec.sessionId, () => withPrincipal(principal, () => prepared.verify ? verifyLeg(prepared.verify) : prepared.cascade ? cascadeLeg() : plainLeg()));
                 }
                 finally {
                     counters.uncountedBillableInflight--;

package/dist/http/server.d.ts

@@ -217,6 +217,11 @@ export interface ServiceStoreDeps {
     /** SendUserFile 账本(多租户治理面):scope↔object 映射的读面 GET /v1/sendfile-links。present ⇔ 签发面
      *  已配 AND 有 store backend(main.ts 建;写点在两条 send lane 的 withLedgerRecording)。 */
     sendFileLedger?: import("../plugins/send-file-ledger.js").SendFileLedger;
+    /** S-928 用户输入受理账本(「200 applied」受理的影子;单写者 = `src/user-input-ledger.ts` 的活对象,boot 装配在 stage-07 并跑一次收敛)。
+     *  在场 ⇔ 有 store backend(生产恒与 `runStore` 同源于 backend)。消费点:steer 的 live 腿 / interrupt{text} / 同步子代的 steer(S-966)受理前写 `accepted`(写不进 ⇒ 503
+     *  `steering.ledger_unavailable`)、三条 run 腿开通告口那一拍铸 `crashed` 通告并在收场时 settle、`GET /v1/sessions/:id` 的
+     *  `userInputUndrained` 读面。缺席只出现在不接 backend 的 stub-harness 上(那时没有这一面,行为与修前逐字相同)。 */
+    userInputLedger?: import("../user-input-ledger.js").UserInputLedger;
     /** 2c session-sync (P1d) — the WHOLE durable backend, so the `/v1/sessions/:id/sync/*` routes can fan out across
      *  ALL four session subsystems (session entries + fileSnapshot blobs/manifests + sessionPolicy + resumeAnchor)
      *  in the §8 fail-closed atomic order.

package/dist/index.d.ts

@@ -28,4 +28,6 @@ export { createSideQueryLane, createPerModelKeyBrain, type KeyResolver, type Sid
 export { createKeyResolver, resolveModelApiKey, type ModelKeyRef } from "./key-resolver.js";
 export { isModelKeyPoison, ModelKeyPoisonedError, type ModelKeyPoison, type ModelKeyPoisonReason } from "./key-resolver.js";
 export { RETIRED_ENVS, type RetiredEnv, type RetiredEnvKind, type RetiredEnvWire } from "./config.js";
+export { CATALOG_ENTRY_HEADER_LANES, CATALOG_ENTRY_HEADER_NAMES, type CatalogEntryHeaderName } from "./model-entry-headers.js";
+export type { UserInputLedgerStore, UserInputAcceptance, NewUserInputAcceptance, OpenScanCursor, OpenScanPage, SettleHow, WriterGoneEvidence } from "./user-input-ledger.js";
 //# sourceMappingURL=index.d.ts.map

package/dist/index.js

@@ -25,4 +25,5 @@ export { createSideQueryLane, createPerModelKeyBrain } from "./boot/side-query-l
 export { createKeyResolver, resolveModelApiKey } from "./key-resolver.js";
 export { isModelKeyPoison, ModelKeyPoisonedError } from "./key-resolver.js";
 export { RETIRED_ENVS } from "./config.js";
+export { CATALOG_ENTRY_HEADER_LANES, CATALOG_ENTRY_HEADER_NAMES } from "./model-entry-headers.js";
 //# sourceMappingURL=index.js.map

package/dist/instruction-selection.d.ts

@@ -0,0 +1,34 @@
+import type { InstructionChainMember } from "./project-memory.js";
+/** wire 段 `wiring_manifest.instructions` 的形。`selected` 的成员拼写 = `INSTRUCTION_FILE_CHAIN` 的成员(相对 cwd)。 */
+export interface InstructionsSegment {
+    readonly selected: readonly InstructionChainMember[];
+}
+/**
+ * 一次 loader 调用对**腿**说了什么:
+ *  · `stated: false` —— 没有陈述(走链之前的门拦下了:无手 / cwd 不是本机绝对目录;或这是委派子代的 prepare);
+ *  · `stated: true`  —— 走了链,`file` = 选中的链成员,`null` = 一个都没有。
+ * 判别式显式写出来(不拿 `undefined` / `null` 两个空值各代表一件事 —— O6 那条教训:「不适用」不是「来源 = 无」)。
+ */
+export type LegInstructionStatement = {
+    readonly stated: false;
+} | {
+    readonly stated: true;
+    readonly file: InstructionChainMember | null;
+};
+/** 一条腿的指令文件选择:开作用域 + 读段。每条投 `wiring_manifest` 的腿(流式 / 非流式 / bg / 续跑)各建一只。 */
+export interface InstructionSelectionLeg {
+    /** 在这条腿的作用域里跑它的模型驱动(引擎的 prepare 在里面调 loader)。`sessionId` = 这条腿的会话 —— 作用域里只有**同会话**的 loader 调用
+     *  才算这条腿自己的 prepare([ref] opus 腿 F1:wake 续跑在腿自己的 prepare 之前同步跑部署 `userPromptSubmit` 的 agent 型 hook,hook agent 是另一只
+     *  会话、却与本进程共用同一只 loader ⇒ 只按「第一次调用」会被它抢先封槽)。嵌套时内层覆盖外层 —— 每条腿说自己的。 */
+    run<T>(sessionId: string | undefined, fn: () => T): T;
+    /** 这条腿的 `instructions` 段;`undefined` ⇒ 段缺席。在投帧那一刻读:core 在推帧之前已经 await 过 loader。 */
+    segment(): InstructionsSegment | undefined;
+}
+export declare function createInstructionSelectionLeg(): InstructionSelectionLeg;
+/**
+ * loader 侧唯一写口:当前作用域里、**同会话的**第一次调用封槽(`sessionId` = loader ctx 带的会话;不等于腿的会话 —— hook agent / 子代 /
+ * 别的嵌套 run 的 prepare —— 一律不算,也不封槽,等这条腿自己的那一次);作用域外(run-local、leader、council 子任务 …)无效。
+ * 「身份 = 作用域 ∧ 同会话」两条都要:只靠作用域会被同进程共用 loader 的别的 Runner 抢先(F1);只靠会话会让同会话的并发腿 / 快速续跑串值。
+ */
+export declare function settleLegInstructionStatement(statement: LegInstructionStatement, sessionId: string | undefined): void;
+//# sourceMappingURL=instruction-selection.d.ts.map

package/dist/instruction-selection.js

@@ -0,0 +1,23 @@
+import { AsyncLocalStorage } from "node:async_hooks";
+const legScope = new AsyncLocalStorage();
+export function createInstructionSelectionLeg() {
+    let slot;
+    return {
+        run: (sessionId, fn) => {
+            slot = { sessionId, settled: false };
+            return legScope.run(slot, fn);
+        },
+        segment: () => slot?.segment,
+    };
+}
+export function settleLegInstructionStatement(statement, sessionId) {
+    const slot = legScope.getStore();
+    if (slot === undefined || slot.settled)
+        return;
+    if (slot.sessionId !== undefined && sessionId !== slot.sessionId)
+        return;
+    slot.settled = true;
+    if (statement.stated)
+        slot.segment = { selected: statement.file === null ? [] : [statement.file] };
+}
+//# sourceMappingURL=instruction-selection.js.map

package/dist/instruction-source-notice.d.ts

@@ -28,9 +28,9 @@
  * sessionId / phase)—— 与 `mcp.injection_dropped`「装配期铸、无 runId」同形,run 归属由投递腿承载(这条 run 的 SSE /
  * 这条 run 的账本)。向 core 要 ctx 加 runId 已登记为未闭环项。
  */
-import type { EngineNotice } from "@sema-agent/core";
-import type { ServerNoticeCode } from "./trace/engine-notice-wire.js";
-export declare const INSTRUCTION_SOURCE_CHANGED: ServerNoticeCode;
+import type { EngineNotice, EngineNoticeCode } from "@sema-agent/core";
+/** 码常量型 = core 码册(#1240 入册:受众 user、铸者 `NOTICE_MINTER` = `"server"`)。 */
+export declare const INSTRUCTION_SOURCE_CHANGED: EngineNoticeCode;
 /** 基线读数。`recorded: false` = 这个会话还没有任何 run 记过基线(首 run ⇒ 只写不发);`source: null` = 记过,且那一次
  *  没有项目指令文件被选中。两态必须可判别:把「没记过」读成「记过没有」会让新会话首 run 发一帧 `null → CLAUDE.md`。 */
 export type InstructionSourceBaseline = {

package/dist/memory-layer-legacy-lock.d.ts

@@ -1,6 +1,6 @@
-import type { EngineNotice } from "@sema-agent/core";
-import type { ServerNoticeCode } from "./trace/engine-notice-wire.js";
-export declare const MEMORY_LAYER_LOCKED_LEGACY: ServerNoticeCode;
+import type { EngineNotice, EngineNoticeCode } from "@sema-agent/core";
+/** 码常量型 = core 码册(#1240 入册:受众 operator、铸者 `NOTICE_MINTER` = `"server"`;不上会话流,只落转发体的运维日志)。 */
+export declare const MEMORY_LAYER_LOCKED_LEGACY: EngineNoticeCode;
 /** 探测读数:锁住的层名(排序)+ 看不全的目录条数。挂载面不存在(新数据根)⇒ 两者皆空。 */
 export interface LockedLegacyLayerProbe {
     readonly layers: readonly string[];

package/dist/model-entry-headers.d.ts

@@ -1,10 +1,13 @@
 /**
  * 白名单 = 名字 → 读它的线路(闭集;**加一个名字 = 加一行并写明哪条线路读它、为什么是部署的事**)。
  * `anthropic-beta`:Anthropic Messages 的 beta 开关(逗号分隔的 beta 名;core anthropic 腿会把自己的 beta 并进同一个头)。
+ *
+ * S-963:本表与 {@link CATALOG_ENTRY_HEADER_NAMES} / {@link CatalogEntryHeaderName} 从包根 `src/index.ts` 原对象导出(web-admin 目录编辑页构建期取白名单,
+ * 不手抄;`RETIRED_ENVS` 同族)—— 它是**本进程准入判据的活表**,所以三只(表 / 每行线路数组 / 名字数组)在这里一次冻结:导出面上的嵌入方改不了它。
  */
-export declare const CATALOG_ENTRY_HEADER_LANES: {
+export declare const CATALOG_ENTRY_HEADER_LANES: Readonly<{
     readonly "anthropic-beta": readonly ["anthropic-messages"];
-};
+}>;
 export type CatalogEntryHeaderName = keyof typeof CATALOG_ENTRY_HEADER_LANES;
 export declare const CATALOG_ENTRY_HEADER_NAMES: readonly CatalogEntryHeaderName[];
 /** 判过的袋(只含白名单里的名字,值逐字)。 */

package/dist/model-entry-headers.js

@@ -1,8 +1,8 @@
 import { redactSecrets } from "./trace/redact.js";
-export const CATALOG_ENTRY_HEADER_LANES = {
-    "anthropic-beta": ["anthropic-messages"],
-};
-export const CATALOG_ENTRY_HEADER_NAMES = Object.keys(CATALOG_ENTRY_HEADER_LANES);
+export const CATALOG_ENTRY_HEADER_LANES = Object.freeze({
+    "anthropic-beta": Object.freeze(["anthropic-messages"]),
+});
+export const CATALOG_ENTRY_HEADER_NAMES = Object.freeze(Object.keys(CATALOG_ENTRY_HEADER_LANES));
 export const MAX_HEADER_VALUE_CHARS = 1024;
 const HEADER_VALUE_SHAPE = /^[\x21-\x7e](?:[\x20-\x7e]*[\x21-\x7e])?$/;
 const HEADER_NAME_TOKEN = /^[A-Za-z0-9!#$%&'*+.^_`|~-]{1,64}$/;

package/dist/model-unreachable-notice.d.ts

@@ -5,8 +5,8 @@
  * ## 病
  * 运营用户看不到日志 / 诊断面:VPN 中途切换之后模型网关建连超时,用户只拿到一句 undici 原句(`fetch failed (connect …)`),
  * 分不清是网络断了还是起服时读进的代理已经失效,也没有「查 VPN / 代理、代理变过就重启」这条出路。只落运维日志不算闭环
- * (test 立案原话)。core 没有现成的「模型不可达」用户通告码(`ENGINE_NOTICE_CODES` 亲查零命中)⇒ 本仓自铸,走既有的
- * `SERVER_NOTICE_AUDIENCE` 族(S-690 形:白名单 / 归属 / 消毒 / 隔离四件判据一个不绕),不开第二条通道。
+ * (test 立案原话)。core 没有现成的「模型不可达」用户通告码 ⇒ 本仓铸,走既有的本仓铸码族(S-690 形:白名单 / 归属 / 消毒 / 隔离四件判据
+ * 一个不绕),不开第二条通道。core 7.38.0(#1240)起本码在 core 码册里:受众 `NOTICE_AUDIENCE` = user、铸者 `NOTICE_MINTER` = `"server"`。
  *
  * ## 判据(一句):**这一次模型调用的终局是 `stopReason: "error"`,且它发出的最后一条请求在建连时就失败了**
  * 「最后一条请求落在哪」由出网观察者记在调用作用域上(`model-reach-scope.ts`,undici 诊断通道,见 `outbound-dispatcher.ts`)——

package/dist/observability/corrupt-read-seat.d.ts

@@ -150,6 +150,30 @@ export declare const JSONL_REPLAY_SEATS: {
         readonly tag: "server.send-file-ledger.corrupt-record-skipped";
         readonly note: "F: a skipped ledger row means that issued link is missing from its tenant's listing (the stored object itself is untouched).";
     };
+    readonly "approval-ask-audit": {
+        readonly direction: "fail-open";
+        readonly event: "approval_ask_audit_corrupt_read";
+        readonly tag: "server.approval-ask-audit.corrupt-record-skipped";
+        readonly note: "F: a skipped ask-audit record is one audit row missing from the boot crash-convergence read (an ask / settle / leg-close fact gone ⇒ that orphan is listed on a thinner basis or not at all, never a gate — the audit store gates nothing and the approval path never reads it back).";
+    };
+    readonly "workflow-notify-journal": {
+        readonly direction: "fail-open";
+        readonly event: "workflow_notify_journal_corrupt_read";
+        readonly tag: "server.workflow-notify-journal.corrupt-record-skipped";
+        readonly note: "F: a skipped notify-journal record is one run's pending entry (or its ack) missing from the boot replay. The recovery sweep walks the journal, so a lost pending line means that run's completion notify is not re-derived after a crash (the live in-process notify and the WorkflowStatus poll floor are untouched); a lost ack line means one extra idempotent re-delivery (the receiver dedups on runId). It gates no permission and changes no run.";
+    };
+    readonly "workflow-agent-session-index": {
+        readonly direction: "fail-open";
+        readonly event: "workflow_agent_session_ledger_line_rejected";
+        readonly tag: "server.workflow-agent-session-index.corrupt-record-skipped";
+        readonly note: "F: a skipped index line leaves that run on its previous known-good snapshot; a /decide for a park the line should have indexed finds no row and falls back to the legacy lane (an honest miss, never a mis-route — the redeem key is compared verbatim on the run record, not read from this index).";
+    };
+    readonly "user-input-ledger": {
+        readonly direction: "fail-open";
+        readonly event: "user_input_ledger_corrupt_read";
+        readonly tag: "server.user-input-ledger.corrupt-record-skipped";
+        readonly note: "F: a skipped user-input ledger record can only bend the crash-loss ANNOUNCEMENT (a lost settle announces one steer that was handled; a lost accept leaves a real loss unannounced; a lost announce repeats it once) — it gates nothing and changes no run.";
+    };
 };
 /** 登记名(闭集)。 */
 export type JsonlReplaySeat = keyof typeof JSONL_REPLAY_SEATS;

package/dist/observability/corrupt-read-seat.js

@@ -93,6 +93,30 @@ export const JSONL_REPLAY_SEATS = {
         tag: "server.send-file-ledger.corrupt-record-skipped",
         note: "F: a skipped ledger row means that issued link is missing from its tenant's listing (the stored object itself is untouched).",
     },
+    "approval-ask-audit": {
+        direction: "fail-open",
+        event: "approval_ask_audit_corrupt_read",
+        tag: "server.approval-ask-audit.corrupt-record-skipped",
+        note: "F: a skipped ask-audit record is one audit row missing from the boot crash-convergence read (an ask / settle / leg-close fact gone ⇒ that orphan is listed on a thinner basis or not at all, never a gate — the audit store gates nothing and the approval path never reads it back).",
+    },
+    "workflow-notify-journal": {
+        direction: "fail-open",
+        event: "workflow_notify_journal_corrupt_read",
+        tag: "server.workflow-notify-journal.corrupt-record-skipped",
+        note: "F: a skipped notify-journal record is one run's pending entry (or its ack) missing from the boot replay. The recovery sweep walks the journal, so a lost pending line means that run's completion notify is not re-derived after a crash (the live in-process notify and the WorkflowStatus poll floor are untouched); a lost ack line means one extra idempotent re-delivery (the receiver dedups on runId). It gates no permission and changes no run.",
+    },
+    "workflow-agent-session-index": {
+        direction: "fail-open",
+        event: "workflow_agent_session_ledger_line_rejected",
+        tag: "server.workflow-agent-session-index.corrupt-record-skipped",
+        note: "F: a skipped index line leaves that run on its previous known-good snapshot; a /decide for a park the line should have indexed finds no row and falls back to the legacy lane (an honest miss, never a mis-route — the redeem key is compared verbatim on the run record, not read from this index).",
+    },
+    "user-input-ledger": {
+        direction: "fail-open",
+        event: "user_input_ledger_corrupt_read",
+        tag: "server.user-input-ledger.corrupt-record-skipped",
+        note: "F: a skipped user-input ledger record can only bend the crash-loss ANNOUNCEMENT (a lost settle announces one steer that was handled; a lost accept leaves a real loss unannounced; a lost announce repeats it once) — it gates nothing and changes no run.",
+    },
 };
 function corruptRefusalSentence(seat, path, reason) {
     const entry = JSONL_REPLAY_SEATS[seat];

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

@@ -291,7 +291,7 @@ export declare const FAIL_OPEN_TAGS: {
     };
     readonly "server.approval-card.closed-word-out-of-set": {
         readonly cls: "F";
-        readonly note: "S-249(`approval-card.ts` 的边界窄读族;今天三个成员:`readRuleOffersAbsence`、S-934 ② 起的 `readAskClassPair`(core 7.37.0 #1214 的类对 `askClass` / `classes`,活卡帧 / 呈卡帧的卡 / 运维队列行同一只,成员筛 = core `isAskClass`,两键同在同缺,半对 / 首员不符同样算读不出;detail 前缀 `askClass=` / `classes=`),与 S-721 起的 `readClosedWordSeat` —— 一座一只 core 成员筛,座是参数:`mandate`(core 7.32.0 #1092,活卡帧 / 活挂起行 / 运维队列行同一只,闭集筛 = core `isPersistedRuleMandate`)与 S-755 起的 `origin`(运维队列行读 park 行孪生座,闭集筛 = core `isAskOrigin`,与 inbox 行 core 投影处同一只筛);detail 前缀 `ruleOffersAbsence=` / `mandate=` / `origin=` 判别是哪一座):活卡帧 / `card_json` / (S-700 起)运维队列行(`parkRowFacts` 读寄存行上的 park 孪生座;队列是热读面 ⇒ 同一行每读一次计一次)的一个**闭集词**座上,键在场而词不在本仓认得的那张表里(世代差,或第三方 producer)⇒ 该座**按缺席**处置。放行的最坏后果=卡上少一行「为什么这次没有规则候选」的解释(壳退回不显示该行),它**不改变任何裁决**——门在引擎里早已判完,本座是展示/观测面;反方向(把一个消费端词表外的值原样上卡)更坏:下游按闭集写的分支会落进 default 臂或渲染出生词。本臂存在的全部理由是**判别**:修前「上游发了个生词」与「上游根本没发这个键」在遥测上同形,而前者意味着本仓的词表该跟着 core 加词了(型面另有两向编译围栏,但那只在**重新编译**时说话,跑在线上的那一版不会自己红)。detail 带座名与那个词(经 redactSecrets 截 40);数 / 布尔等原始值原样,对象 / 数组 / 函数 / null 只报形名(`<object>` / `<array>` / `<function>` / `<null>`,S-700 codex r1:格式化从不调用值自己的转换方法 —— 持久层里一格 `{\"toString\":null}` 曾让诊断本身抛出、打掉整只队列)。";
+        readonly note: "S-249(`approval-card.ts` 的边界窄读族;今天三个成员:`readRuleOffersAbsence`、S-934 ② 起的 `readAskClassPair`(core 7.37.0 #1214 的类对 `askClass` / `classes`,活卡帧 / 呈卡帧的卡 / 运维队列行同一只,判法 = core 屏 `screenAskClassMembers`(S-955 ⑥ / core 7.38.0 #1249,本仓零自写对判),两键同在同缺,半对 / 集外 / 首员不符 / 重复员 = 屏拒 = 读不出;detail 前缀 `askClass=` / `classes=`),与 S-721 起的 `readClosedWordSeat` —— 一座一只 core 成员筛,座是参数:`mandate`(core 7.32.0 #1092,活卡帧 / 活挂起行 / 运维队列行同一只,闭集筛 = core `isPersistedRuleMandate`)与 S-755 起的 `origin`(运维队列行读 park 行孪生座,闭集筛 = core `isAskOrigin`,与 inbox 行 core 投影处同一只筛);detail 前缀 `ruleOffersAbsence=` / `mandate=` / `origin=` 判别是哪一座):活卡帧 / `card_json` / (S-700 起)运维队列行(`parkRowFacts` 读寄存行上的 park 孪生座;队列是热读面 ⇒ 同一行每读一次计一次)的一个**闭集词**座上,键在场而词不在本仓认得的那张表里(世代差,或第三方 producer)⇒ 该座**按缺席**处置。放行的最坏后果=卡上少一行「为什么这次没有规则候选」的解释(壳退回不显示该行),它**不改变任何裁决**——门在引擎里早已判完,本座是展示/观测面;反方向(把一个消费端词表外的值原样上卡)更坏:下游按闭集写的分支会落进 default 臂或渲染出生词。本臂存在的全部理由是**判别**:修前「上游发了个生词」与「上游根本没发这个键」在遥测上同形,而前者意味着本仓的词表该跟着 core 加词了(型面另有两向编译围栏,但那只在**重新编译**时说话,跑在线上的那一版不会自己红)。detail 带座名与那个词(经 redactSecrets 截 40);数 / 布尔等原始值原样,对象 / 数组 / 函数 / null 只报形名(`<object>` / `<array>` / `<function>` / `<null>`,S-700 codex r1:格式化从不调用值自己的转换方法 —— 持久层里一格 `{\"toString\":null}` 曾让诊断本身抛出、打掉整只队列)。";
     };
     readonly "server.pg-pool.idle-client-error": {
         readonly cls: "F";
@@ -317,6 +317,30 @@ export declare const FAIL_OPEN_TAGS: {
         readonly cls: "F";
         readonly note: "S-582(`plugins/send-file-ledger.ts`,local 车道的发文件账本):一条账行读不出形(`42` / 缺 id·scope·objectKey 三元组 / 中间半截 JSON)⇒ 跳过它继续。最坏后果 = 那条已签发的链接在它租户的列表里**看不见**(对象本身没动;账本本来就不存 URL)。治理面少一行是可见性损失,不是放行 ⇒ F;但它恰是治理面要看的那一类事实,所以必须留痕 —— 修前零披露。";
     };
+    readonly "server.approval-ask-audit.corrupt-record-skipped": {
+        readonly cls: "F";
+        readonly note: "S-967(`approval-ask-audit-store.ts`,local 车道 File ask 审计店的 boot 重放;登记名 `approval-ask-audit`):账本**中间**一行读不出形(`42` / 数组 / 缺键 / 词表外 `kind`·`outcome`·`orphanState` / 半截 JSON;撕尾不走本 tag)⇒ 跳过它继续。最坏后果按行种:丢 `ask` ⇒ 那只孤儿在崩溃收敛读面缺席(无身份可列);丢 `settle` ⇒ 该组按 pending 臂收(审批门在执行之前 ⇒ 若这条 settle 其实是 `allowed` 且工具已执行,`resumeSafe:true` 是错的 —— 与头注「双故障窗」同族);丢 `leg_closed` ⇒ decided 臂多收一行(保守方向);丢 `crash_converged` ⇒ 下一次 boot 重收(幂等);丢 `interrupted_by_shutdown` / `late_settle` ⇒ 成因注退回 `crashed_before_park` / 少一行取证。审计店不开门、不改任何审批结算 ⇒ F。修前:重放坏行只计入 `convergeCrashedAsks().corruptLines`(boot 日志一个数),**无逐条披露、无 tag**。";
+    };
+    readonly "server.workflow-notify-journal.corrupt-record-skipped": {
+        readonly cls: "F";
+        readonly note: "S-977(`orchestration/workflow-notify-journal.ts`,local 车道 File notify journal 的 boot 重放;登记名 `workflow-notify-journal`):账本**中间**一行读不出形(`42` / 数组 / 缺 runId·scope / `acked` 非布尔 / 半截 JSON;撕尾不走本 tag)⇒ 跳过它继续。最坏后果按行种:丢 `pending` 行(`record` 写下的那条)⇒ 那条 run 不在恢复积压里,崩溃丢掉的终态通告 boot 恢复扫描不再重导(live 进程内通告与 `WorkflowStatus` 轮询地板不受影响);丢 `acked` 行 ⇒ 该 run 读回 pending(或前一份已知良好的条目),多一次幂等重投(接收方按 runId 去重)。账本不开门、不改任何 run 的执行或授权 ⇒ F。修前:坏行 / 缺键行**静默**(解析失败 `continue`、只判 `typeof runId === \"string\"`)。";
+    };
+    readonly "server.workflow-agent-session-index.corrupt-record-skipped": {
+        readonly cls: "F";
+        readonly note: "S-977(`orchestration/workflow-agent-session-index.ts`,local 车道 workflow 出身 park 的 join 索引账本的 boot 重放;登记名 `workflow-agent-session-index`):账本**中间**一行读不出形(`42` / 数组 / 缺 `runId`·`rows` / 任一行成员缺身份位 / 半截 JSON;撕尾不走本 tag)⇒ **整行**跳过,那条 run 保留上一份已知良好的快照(不做「丢坏成员、留好成员」—— 那会铸出比真相少几条 park 的行集)。最坏后果 = 该 run 的 park 在索引里缺行 ⇒ `/decide` 找不到它、退回 legacy 腿(409 `conflict.resume_context_unavailable`):诚实 miss,不是错配 —— 赎回键由记录上的 `parks[]` 逐字比对,不读本索引。索引不开门 ⇒ F。修前:形不对的整行响亮(`workflow_agent_session_ledger_line_rejected`,同事件名保留)但**无 tag**,带换行的半截 JSON 静默 `continue`。";
+    };
+    readonly "server.user-input-ledger.append-failed": {
+        readonly cls: "F";
+        readonly note: "S-928(`src/user-input-ledger.ts`):200 承诺**之后**的一次账本写失败 —— detail 的 `op=` 点名是哪一种:`settle`(腿在本进程收场)/ `withdraw`(引擎没收下这次 steer)/ `converge`(收敛器判孤儿)/ `announce`(通告已投出,记「告知过」)。放行的最坏后果逐个说清:settle / withdraw 漏写 ⇒ 这次受理在账上仍是 open —— 本进程下一次收敛扫描补结清(本进程写的、已不在活腿上 ⇒ leg_over);进程在那之前就崩了 ⇒ 下一次 boot 的收敛读 run 店判(S-969 L8 起两车道同一只判词:承载它的 run 正常翻面 / 已 park ⇒ leg_over 补结清、不告知;落款死亡判决或写者已死仍 running ⇒ crashed)—— 仍会多说一句的只剩两形:withdraw 漏写后那条腿崩了(一次没变成 200 的受理被告知一次);settle 漏写后本进程续跑了同一条 run、续跑腿崩了(run 行说的是同一 taskId 上**最新**那条腿)。方向都是多说,不漏;converge 漏写 ⇒ 留在 open,下一次扫描再判(延迟,不丢);announce 漏写 ⇒ 下一条 run 再说一遍(至多一次退化成至少一次)。都是**告知面**的偏差,不开任何门、不改任何 run 的执行 ⇒ F。计数非零 = 这台机器的账本写不动了(local:数据根盘满 / 只读;SQL:库不可达),steer 此刻多半也在回 503。";
+    };
+    readonly "server.user-input-ledger.read-failed": {
+        readonly cls: "F";
+        readonly note: "S-928(`src/user-input-ledger.ts` / `http/routes/sessions.ts`):一次账本**读**失败 —— `op=converge`(收敛扫描读不出 open 受理 ⇒ 本轮不收敛,下一个 tick 再来)/ `op=judge`(判词要读 run 店 —— S-969 L8 起两车道都读;一趟内同一 taskId 只读一次,读失败 ⇒ 同 run 的每一行各记一笔、留在 open、下一次扫描再判)/ `op=announce`(新 run 首拍读不出本会话的待告知受理 ⇒ 这一拍不告知,run 照跑,下一条 run 再试)/ `op=session-view`(`GET /v1/sessions/:id` 的 additive 键 `userInputUndrained` 读不出 ⇒ 键缺席、会话视图照常 200)。放行的最坏后果 = 一次「你的输入因崩溃丢了」的告知被推迟,或会话视图上这一格读作零条;不阻断任何 run、不改任何回执。反方向(读失败就拒跑 run / 整只会话视图 500)是拿一个告知面的抖动去打掉主路径,方向更坏。";
+    };
+    readonly "server.user-input-ledger.corrupt-record-skipped": {
+        readonly cls: "F";
+        readonly note: "S-928(`plugins/user-input-ledger-file.ts`,local 车道 File 孪生的 boot 重放;登记名 `user-input-ledger`):账本中间一行读不出形(`42` / 缺键 / 词表外的 `kind`·`input`·`how`·`cause` / 半截 JSON;撕尾不走本 tag)⇒ 跳过它继续。S-969 L6 起 SQL 孪生(`plugins/user-input-ledger-sql.ts` `readRows`)同一只 tag:三只读口取到的行上读不出的列(`input_kind` 词表外 —— 新版本写的输入族 / 手改;收敛行缺 `state_at_ms`)⇒ 逐行跳过、其余照交,`listOpen` 的续翻游标按原始行推进(修前整页抛:收敛断点不前进、同会话通告与读面一并失效);坏行留在表里 ⇒ 每读一次计一次,非零 = 表里有本版本读不懂的行。最坏后果按行种:丢 `accepted` ⇒ 那次受理若真随崩溃丢了,不会被告知(= 本账之前的状态);丢 `settled` ⇒ 该受理在账上仍 open,下一趟收敛按 run 行判(S-969 L8,两车道同一只判词):本进程写的 / run 行已正常收场、已 park、易手 ⇒ 补结清、不告知;只有 run 行仍 `running` 且持有者是写者(local)、带死亡落款且持有者是写者、或行不在(local:File 店藏了读不出的行)⇒ 当成崩溃丢失告知一次;丢 `converged` ⇒ 下一次 boot 重收一次(幂等);丢 `announced` ⇒ 再告知一次;丢 `erased`(S-965,7.111.0 起的会话级墓碑;缺 `sessionId` 的那一行**不**读成「擦全部」)⇒ 被删会话的受理行在本进程的折叠里复现 —— 只有身份 + 时刻(无用户文本),读面 / 通告按 sessionId 取,同一个 id 被重新登记时新住客可见上一位的 `crashed` 告知(= 7.110.x 无级联时的状态);撕尾的 `erased` 不在此列:墓碑写在会话本体删除**之前**,撕掉 ⇒ DELETE 没有成功、会话还在,幂等重试重写。全在告知面,不开门 ⇒ F。修前不存在(本账本 S-928 新立)。";
+    };
     readonly "server.outbound.connect-observer-threw": {
         readonly cls: "F";
         readonly note: "S-925(`outbound-dispatcher.ts` 的 undici 诊断通道订阅者:`undici:request:create` / `:headers` / `:error`):一只订阅回调抛了。通道在发布方的调用栈里同步回调订阅者,抛出去在 Node 上是未捕获异常(整进程倒),所以每只回调整体 try、落本 tag。最坏后果 = 这一条请求的建连失败没被记下:少一行 `outbound_connect_failed`、诊断段 `outbound.lastConnectFailure` 不更新、那次模型调用不铸 `server.model_unreachable` 用户通告 —— 请求本身、它的错误、run 的终态一个字节不受影响(观察只读)。计数恒零是证据;非零 = undici 通道载荷的形变了,去看 detail 的 site。";