@sema-agent/server 7.112.0 → 7.114.0

package/dist/http/resume-legs.js

@@ -30,7 +30,7 @@ import { errorText } from "../observability/err-text.js";
 import { recordFailOpen } from "../observability/fail-open.js";
 import { verifyRoundsFromBody } from "./verify-rounds.js";
 import { storedBodyPermissionMode } from "../task-settings.js";
-import { acceptedResumingReceipt } from "./route-ctx.js";
+import { acceptedResumingReceipt, buildHostLegOutcome } from "./route-ctx.js";
 import { mintAndDriveDurableRun } from "./durable-run-leg.js";
 import { createSessionsLocal } from "./routes/sessions.js";
 import { createSessionSyncLocal } from "./routes/session-sync.js";
@@ -70,7 +70,63 @@ const WORKER_SWAP_REDEEMABLE = {
 function checkpointRowRedeemableElsewhere(reason) {
     return reason !== undefined && WORKER_SWAP_REDEEMABLE[reason] === true;
 }
-const NON_BINDING_INVALID_OUTCOME_FIELDS = new Set(["hostDecision", "approver"]);
+const CHECKPOINT_ERROR_DISPOSITION = {
+    "checkpoint.resume_aborted": "cancelled",
+    "checkpoint.invalid_outcome": "retriable",
+    "checkpoint.reopen_revote": "retriable",
+    "checkpoint.reopened_concurrently": "retriable",
+    "resume.parent_constraint_missing": "retriable",
+    "resume.parent_constraint_mismatch": "retriable",
+    "resume.constraint_rejected": "retriable",
+    "resume.constraint_unprojectable": "retriable",
+    "resume.usage_window_exhausted": "retriable",
+    "resume.principal_mismatch": "retriable",
+    "resume.placement_mismatch": "retriable",
+    "resume.preflight_rejected": "retriable",
+    "wake.gate_pending": "retriable",
+    "wake.nothing_to_deliver": "retriable",
+    "checkpoint.config_refused": "retriable",
+    "checkpoint.walltime_axis_retired": "retriable",
+    "steering.blocked_by_hook": "retriable",
+    "checkpoint.unsupported_version": "by_reason",
+    "checkpoint.already_resolved": "terminal",
+    "checkpoint.not_found": "terminal",
+    "checkpoint.gate_mismatch": "terminal",
+    "checkpoint.reopen_failed": "terminal",
+    "checkpoint.cwd_conflicts_restore": "terminal",
+    "checkpoint.already_exists": "terminal",
+    "checkpoint.execution_outcome_conflict": "terminal",
+    "steering.duplicate_input_id": "terminal",
+    "steering.invalid_content": "terminal",
+    "steering.queue_full": "terminal",
+};
+export function checkpointErrorDisposition(e) {
+    const word = Object.hasOwn(CHECKPOINT_ERROR_DISPOSITION, e.code) ? CHECKPOINT_ERROR_DISPOSITION[e.code] : undefined;
+    switch (word) {
+        case "cancelled":
+        case "retriable":
+        case "terminal":
+            return word;
+        case "by_reason":
+            return checkpointRowRedeemableElsewhere(e.detail?.reason) ? "retriable" : "terminal";
+        case undefined:
+            return "terminal";
+        default: {
+            const unhandled = word;
+            throw new Error(`unhandled checkpoint-error disposition: ${String(unhandled)}`);
+        }
+    }
+}
+const CHECKPOINT_ERROR_FIELD_ROLE = {
+    boundCallId: "binding",
+    boundInputHash: "binding",
+    answer: "answer",
+    hostDecision: "outcome_cell",
+    approver: "outcome_cell",
+    taskConfig: "config",
+    inheritedGate: "config",
+};
+const NON_BINDING_INVALID_OUTCOME_FIELDS = new Set(Object.keys(CHECKPOINT_ERROR_FIELD_ROLE).filter((f) => CHECKPOINT_ERROR_FIELD_ROLE[f] === "outcome_cell"));
 function notResumableAnswer() {
     return { status: 409, body: { error: "run is not in a resumable (suspended) state (already resumed, decided, or expired)", errorCode: "conflict.not_resumable" } };
 }
@@ -726,6 +782,7 @@ export function createResumeLegs(ctx) {
                             causeAtDone = cancelCtrl.cause();
                         recordTurnActivity(taskId);
                         fleetPub?.onEvent(ev);
+                        await deps.userInputLedger?.observeLegEvent(stream, ev);
                         await appendPromptManifest(append, deps.promptManifests, taskId);
                         switch (ev.type) {
                             case "text_delta":
@@ -891,7 +948,8 @@ export function createResumeLegs(ctx) {
         }
         catch (e) {
             if (e instanceof CheckpointError) {
-                if (e.code === "checkpoint.resume_aborted") {
+                const disposition = checkpointErrorDisposition(e);
+                if (disposition === "cancelled") {
                     const cs2 = deps.checkpointStore;
                     if (cs2) {
                         try {
@@ -917,19 +975,7 @@ export function createResumeLegs(ctx) {
                     settleFleet("failed");
                     return { status: 200, body: { taskId, sessionId, status: "failed", errorCode: "cancelled" } };
                 }
-                const retriable = e.code === "checkpoint.invalid_outcome" ||
-                    e.code === "checkpoint.reopen_revote" ||
-                    e.code === "checkpoint.reopened_concurrently" ||
-                    e.code === "resume.parent_constraint_missing" ||
-                    e.code === "resume.parent_constraint_mismatch" ||
-                    e.code === "resume.constraint_rejected" ||
-                    e.code === "resume.constraint_unprojectable" ||
-                    e.code === "resume.usage_window_exhausted" ||
-                    e.code === "resume.principal_mismatch" ||
-                    e.code === "resume.placement_mismatch" ||
-                    e.code === "resume.preflight_rejected" ||
-                    e.code.startsWith("wake.") ||
-                    (e.code === "checkpoint.unsupported_version" && checkpointRowRedeemableElsewhere(e.detail?.reason));
+                const retriable = disposition === "retriable";
                 if (claimedRow && taskId && deps.runStore) {
                     if (retriable && freshRunClaimed) {
                         const c = { taskId, sessionId, terminal: { kind: "failed", code: e.code, message: e.message }, stats: { turns: 0, tokens: 0, usageMissing: true } };
@@ -1204,7 +1250,7 @@ export function createResumeLegs(ctx) {
             return resolved.answer;
         const { spec, engineNotices } = resolved;
         const { objective: resumeObjective, sessionId: _sessionId, ...taskConfig } = spec;
-        return driveResumeIntoRunLog({
+        return buildHostLegOutcome(await driveResumeIntoRunLog({
             runner: runnerFor(spec),
             token,
             sessionId: cp.sessionId,
@@ -1221,7 +1267,7 @@ export function createResumeLegs(ctx) {
             ...(req !== undefined ? { callerInitiated: true } : {}),
             ...(workflowParkedResume !== undefined ? { workflowParkedResume } : {}),
             ...(ownerLeaseAdmittedFor !== undefined && auth.principal === ownerLeaseAdmittedFor ? { ownerLeaseAdmitted: true } : {}),
-        });
+        }));
     }
     async function preparePlanReview(sessionId, log, decider) {
         const cs = deps.checkpointStore;

package/dist/http/route-ctx.d.ts

@@ -72,8 +72,10 @@ export interface RouteHelpers {
     usageWindowDenied(req: IncomingMessage, res: ServerResponse): Promise<boolean>;
     safeDecode(seg: string): string | null;
     isFleetWide(req: IncomingMessage): boolean;
-    /** 属主门。`notFoundForm` 选 not-yours 臂的 404 拼法:缺省 `"run"`(not_found.run 长文,[ref]);session
-     *  资源面传 `"session"`(not_found.session + "session not found")与其 unknown 臂同码同串(G52 [ref])。 */
+    /** 属主门。`notFoundForm` 选 not-yours 臂的 404 拼法:缺省 `"run"`(not_found.run 长文,[ref]);**每一个 session
+     *  资源面都必须传 `"session"`**(not_found.session + {@link SESSION_NOT_FOUND_MESSAGE})与其 unknown 臂同码同串
+     *  (G52 [ref];S-989 补上了 detail / head / events 三个读口 —— 它们此前吃缺省 "run",单端点内 unknown / not-yours
+     *  两臂码与串都不同)。缺省 `"run"` 的语义不变:run 面不传。 */
     runOwnerOk(req: IncomingMessage, res: ServerResponse, owner: string | null, notFoundForm?: "run" | "session"): boolean;
     sessionOwnerScope(req: IncomingMessage): {
         fleetWide: boolean;
@@ -408,10 +410,7 @@ export interface RouteLegs {
      *  顶注)。HTTP `/wake` 腿**不设**此位 —— 它是 `/decide` 第三条车道的专用席,而两条腿共用这一条驱动
      *  路径正是 `notify-wake.ts` 那条「wake 会烧模型,所以复用 resume 家族的同一条腿、不自建第二条驱动
      *  路径」的成文纪律。 */
-    workflowParkedResume?: DriveResumeArgs["workflowParkedResume"]): Promise<{
-        status: number;
-        body: object;
-    }>;
+    workflowParkedResume?: DriveResumeArgs["workflowParkedResume"]): Promise<HostLegOutcome>;
     /**
      * assistant plan_review 三态腿的**纯读段**(S-609,7.97.0):选卡 → 属主轻读 → 载入 → 行级 scope → 门类 → 这条决断
      * 唯一的一次 ctx 读。任何一步拒 ⇒ `{ok:false, answer}`(不改任何状态;端点在消费一次性 nonce **之前**把它答出去);
@@ -626,7 +625,7 @@ export type RouteDecl = RouteDispatchDecl | RouteGateDecl;
  * api-error-text-freeze 基线流程。
  */
 /**
- * resume 家族一条腿的结局:HTTP 应答(`status` / `body`)+ 一位**进程内**事实(不上 wire)。
+ * resume 家族**引擎腿**的结局:HTTP 应答(`status` / `body`)+ 一位**进程内**事实(不上 wire)。workflow 宿主腿的结局另型({@link HostLegOutcome}),并集 = {@link ResumeLegOutcome}。
  *
  * `decisionCommitted` —— **这条腿的终局是在引擎受理了这次决定之后才结出来的**([ref] X5,7.112.0):本腿走到了「引擎交回结果」那一步
  * (`resumeStream` / `resumeWithVerification` 解析 = core 的全部 pre-CAS 门 + checkpoint resolve CAS 都过了 —— 受理点的判据属主
@@ -640,11 +639,34 @@ export type RouteDecl = RouteDispatchDecl | RouteGateDecl;
  * 读它」(`plugins/store-contracts.ts` `RunCancelContext` 顶注)—— 这两道门正是判定;而且门读的是 `/decide` 的平面体、看不到结果对象。
  * 受理与否是腿自己的控制流事实,在腿上说,零 wire 变更。
  */
-export interface ResumeLegOutcome {
+export interface EngineLegOutcome {
     status: number;
     body: object;
     decisionCommitted?: true;
 }
+/**
+ * **workflow 宿主腿的结局(wake / fresh)—— 型上就没有 `decisionCommitted`**(S-992 ②,7.113.0;`never` 让「这条路径不铸」成为**编译事实**,不是靠人记)。
+ *
+ * 为什么这条路径不该有该位:`/decide` 的 workflow 第三条车道(`resumeCheckpoint` 的 parked 分流,`planWorkflowParkedDecide` 之后)与 `POST /v1/sessions/:id/wake`
+ * 把决定 / 消息交给**宿主会话的下一跑**(`resumeWake` / `startFreshHostTurn`)。它们的 200 只到「已交给宿主的下一跑」—— 子代 checkpoint 的 resolve CAS 发生在
+ * workflow 引擎自己驱动那一步,server 观察不到(`resume-legs.ts` 该分流处「刻意不落 `late_settle`」同源)。「这次决定被引擎受理了」这句话在这里**没有可说的对象**,
+ * 于是 `decisionCommitted` 在这条路径上语义含混(修前:`resumeWake` 的收尾是 `driveResumeIntoRunLog` 的 `ResumeLegOutcome`,非受理点早返形(无 `acceptEarly`)下它会把
+ * 引擎腿的 `decisionCommitted:true` 原样带出去 —— 型被声明返回型 `{status, body}` 擦掉了,运行期仍在)。读者核实:两道提交门(`noteLateSettleIfAccepted` 迟到结算留痕、
+ * `/decide` 的 remember 豁免落店)在这条路径上今天**零读取**(前者该分流直接 `return`、不调;后者的 `pendingGrant` 只由引擎腿的 `onResumeCommitted` 回调置位,宿主腿不调它,且 `planWorkflowParkedDecide` 对 workflow 车道的 `remember` 本就 fail-closed 拒 —— `decide.workflow_remember_unsupported`,`parked-decide.ts`)——
+ * 无读者 ⇒ 剥掉该位,而不是留一个「铸了也没人读、读了不知道什么意思」的位。出口经 {@link buildHostLegOutcome} 只带 `status` / `body`。
+ */
+export interface HostLegOutcome {
+    status: number;
+    body: object;
+    decisionCommitted?: never;
+}
+/** resume 家族一条腿的结局:引擎腿(可带 `decisionCommitted`)∪ workflow 宿主腿(型上没有)。`out.decisionCommitted === true` 同时收窄到引擎腿。 */
+export type ResumeLegOutcome = EngineLegOutcome | HostLegOutcome;
+/** 把任意腿的结局折成宿主腿结局:**只带 `status` / `body`**(丢掉引擎腿的 `decisionCommitted` —— 见 {@link HostLegOutcome})。纯数据。 */
+export declare function buildHostLegOutcome(out: {
+    status: number;
+    body: object;
+}): HostLegOutcome;
 /**
  * **「决定/续跑已受理」那一枚 200 收据的单一铸点**(S-218)。
  *
@@ -660,6 +682,14 @@ export declare function acceptedResumingReceipt(taskId: string, sessionId: strin
     body: object;
 };
 export declare const RUN_NOT_FOUND_MESSAGE = "run not found \u2014 the id belongs to no run in this deployment's run store (a run from another server process, or an in-memory store that did not survive a restart, is not visible here)";
+/**
+ * 会话资源面 404 的**唯一一句**(与 {@link RUN_NOT_FOUND_MESSAGE} 同一冻结纪律,常量锚在 `test/api-error-text-freeze.test.ts`)。
+ *
+ * 为什么是常量不是各点字面量:这句话要在**每一个**会话面的「不存在」臂与「非属主」臂上逐字节同串(G52 [ref] /
+ * S-989 —— 两臂差一个码或一个字就是单端点内的存在性 oracle)。十余个出站点各抄一份,漂开的那天没有任何东西会说话;
+ * 走一只常量 + `runOwnerOk(..., "session")` 的会话拼法,「改一处」就是改全域。
+ */
+export declare const SESSION_NOT_FOUND_MESSAGE = "session not found";
 /** [ref] 前缀=域判别子既成契约:a\* 与 wa\* 形 id 给 TaskOutput/journal 指路;其余给 {@link RUN_NOT_FOUND_MESSAGE}。 */
 export declare function runNotFoundMessage(id: string): string;
 export {};

package/dist/http/route-ctx.js

@@ -21,10 +21,14 @@ export function assertNever(x) {
     throw new Error(`unreachable route id: ${String(x)}`);
 }
 export const ROUTE_METHOD_ORDER = ["GET", "POST", "PUT", "DELETE"];
+export function buildHostLegOutcome(out) {
+    return { status: out.status, body: out.body };
+}
 export function acceptedResumingReceipt(taskId, sessionId) {
     return { status: 200, body: { taskId, sessionId, status: "resuming", bindingEnforced: true } };
 }
 export const RUN_NOT_FOUND_MESSAGE = "run not found — the id belongs to no run in this deployment's run store (a run from another server process, or an in-memory store that did not survive a restart, is not visible here)";
+export const SESSION_NOT_FOUND_MESSAGE = "session not found";
 export function runNotFoundMessage(id) {
     const aStar = /^(?:a|wa)[0-9a-f]{4,}$/i.test(id);
     return aStar

package/dist/http/routes/background.js

@@ -5,7 +5,7 @@ import { redactSecrets } from "../../trace/redact.js";
 import { sendJson, sendError } from "../send.js";
 import { gatedPrincipal, explicitOperatorOk, sendPrincipalRefusal } from "../principal-gate.js";
 import {} from "../route-ctx.js";
-import { assertNever } from "../route-ctx.js";
+import { assertNever, SESSION_NOT_FOUND_MESSAGE } from "../route-ctx.js";
 const LIST_LIMIT = 500;
 export const DESCRIPTION_MAX = 500;
 const ROW_KEY_DISPOSITION = {
@@ -65,7 +65,7 @@ export async function handleBackground(req, res, match, ctx) {
     }
     const owner = await deps.sessionStorage.ownerOf(sessionId);
     if (owner === undefined) {
-        sendError(res, 404, "not_found.session", "session not found");
+        sendError(res, 404, "not_found.session", SESSION_NOT_FOUND_MESSAGE);
         return;
     }
     const isOperator = explicitOperatorOk(principal, deps.config.operatorPrincipals);

package/dist/http/routes/capabilities.js

@@ -24,7 +24,7 @@ import { projectApprovalsStreamLiveCapability } from "../../capabilities/approva
 import { workflowModelAllowlistFor, selfOrchestrationDenial } from "../../task-workflow.js";
 import { centerEntitlementSourceWired } from "../../runtime-caps-resolver.js";
 import { judgeAutoModeArming } from "../../auto-mode-face.js";
-import { coercePermissionModeStrict, SETTINGS_PERMISSION_MODE_WORDS } from "../../task-settings.js";
+import { coercePermissionModeStrict, SETTINGS_PERMISSION_MODE_WORDS, taskHooksHonored } from "../../task-settings.js";
 import { gatedPrincipal, sendPrincipalRefusal } from "../principal-gate.js";
 import { sessionBackgroundFacesAvailable } from "./background.js";
 function routePairingOf(deps, name, m) {
@@ -121,7 +121,7 @@ export async function handleCapabilities(req, res, match, ctx) {
                 scratchpadDir: true,
                 subagentSteer: Boolean(deps.subagentSteerRegistry) && Boolean(deps.runStore),
                 subagentResume: Boolean(deps.subagentSteerRegistry) && Boolean(deps.runStore),
-                taskSettings: { permissions: true, permissionMode: true, model: true, outputStyle: true, env: cwdHonored(deps.config) || deviceCwdHonored(deps.config), hooks: deps.config.requirePrincipal !== true },
+                taskSettings: { permissions: true, permissionMode: true, model: true, outputStyle: true, env: cwdHonored(deps.config) || deviceCwdHonored(deps.config), hooks: taskHooksHonored(deps.config) },
                 permissionModeAuto: {
                     accepted: true,
                     classifierSeat: deps.autoModeFace?.seatMounted === true,

package/dist/http/routes/mcp-reconnect.js

@@ -4,7 +4,7 @@ import { redactSecrets } from "../../trace/redact.js";
 import { sendJson, sendError } from "../send.js";
 import { gatedPrincipal, explicitOperatorOk, sendPrincipalRefusal } from "../principal-gate.js";
 import {} from "../route-ctx.js";
-import { assertNever } from "../route-ctx.js";
+import { assertNever, SESSION_NOT_FOUND_MESSAGE } from "../route-ctx.js";
 const BodySchema = z.object({ server: z.string().min(1).max(190) }).strict();
 const NEUTRALIZED_TEXT_MAX = 200;
 const humanText = (s) => redactSecrets(s).slice(0, NEUTRALIZED_TEXT_MAX);
@@ -82,7 +82,7 @@ export async function handleMcpReconnect(req, res, match, ctx) {
             }
             const owner = await deps.sessionStorage.ownerOf(sessionId);
             if (owner === undefined) {
-                sendError(res, 404, "not_found.session", "session not found");
+                sendError(res, 404, "not_found.session", SESSION_NOT_FOUND_MESSAGE);
                 return;
             }
             const isOperator = explicitOperatorOk(principal, deps.config.operatorPrincipals);

package/dist/http/routes/notify-wake.js

@@ -2,7 +2,7 @@ import { taskNotificationInboxEntry } from "../../orchestration/workflow-complet
 import { sendJson, sendError } from "../send.js";
 import { gatedPrincipal, explicitOperatorOk, sendPrincipalRefusal } from "../principal-gate.js";
 import { sendResumeOutcome } from "../route-ctx.js";
-import { assertNever } from "../route-ctx.js";
+import { assertNever, SESSION_NOT_FOUND_MESSAGE } from "../route-ctx.js";
 export async function handleNotifyWake(req, res, match, ctx) {
     const { deps } = ctx;
     const { steerableRuns } = ctx.registry;
@@ -63,12 +63,12 @@ export async function handleNotifyWake(req, res, match, ctx) {
             }
             const notifyOwner = await deps.sessionStorage.ownerOf(notifySession);
             if (notifyOwner === undefined) {
-                sendError(res, 404, "not_found.session", "session not found");
+                sendError(res, 404, "not_found.session", SESSION_NOT_FOUND_MESSAGE);
                 return;
             }
             const notifyOperator = explicitOperatorOk(principal, deps.config.operatorPrincipals);
             if (!notifyOperator && notifyOwner !== null && notifyOwner !== principal) {
-                sendError(res, 404, "not_found.session", "session not found");
+                sendError(res, 404, "not_found.session", SESSION_NOT_FOUND_MESSAGE);
                 return;
             }
             const payload = {

package/dist/http/routes/runs.js

@@ -146,6 +146,20 @@ async function acceptLiveUserInput(deps, res, at) {
         return "refused";
     }
 }
+async function relayAcceptedInput(deps, acceptance, call) {
+    let out;
+    try {
+        out = await call();
+    }
+    catch (e) {
+        if (acceptance !== undefined)
+            await deps.userInputLedger.withdraw(acceptance);
+        throw e;
+    }
+    if (acceptance !== undefined)
+        await deps.userInputLedger.confirm(acceptance);
+    return out;
+}
 export async function handleRuns(req, res, match, ctx) {
     const { deps } = ctx;
     const { idemCache, inflightRuns, preemptableRuns, steerableRuns, wakeParkMints } = ctx.registry;
@@ -481,13 +495,11 @@ export async function handleRuns(req, res, match, ctx) {
             if (acceptance === "refused")
                 return;
             try {
-                await live.steer(text, { trusted, ...(steerInputId !== undefined ? { inputId: steerInputId } : {}) });
+                await relayAcceptedInput(deps, acceptance, () => live.steer(text, { trusted, inputId: messageId }));
                 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");
@@ -794,11 +806,9 @@ export async function handleRuns(req, res, match, ctx) {
         if (acceptance === "refused")
             return;
         try {
-            await liveStream.steer(text, { trusted, priority: "now", ...(interruptInputId !== undefined ? { inputId: interruptInputId } : {}) });
+            await relayAcceptedInput(deps, acceptance, () => 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");
@@ -1152,7 +1162,6 @@ export async function handleRunVerbs(req, res, match, ctx) {
         }
         const handle = resolution?.handle;
         if (handle) {
-            let acceptance;
             try {
                 if (verb === "resume") {
                     if (!handle.resume) {
@@ -1169,11 +1178,10 @@ export async function handleRunVerbs(req, res, match, ctx) {
                     return;
                 }
                 const messageId = uuidv7();
-                const accepted = await acceptLiveUserInput(deps, res, { messageId, sessionId: run.sessionId, taskId: runId, leg: handle });
-                if (accepted === "refused")
+                const acceptance = await acceptLiveUserInput(deps, res, { messageId, sessionId: run.sessionId, taskId: runId, leg: handle });
+                if (acceptance === "refused")
                     return;
-                acceptance = accepted;
-                const marker = await handle.steer(redacted);
+                const marker = await relayAcceptedInput(deps, acceptance, () => handle.steer(redacted));
                 if (acceptance !== undefined) {
                     const ledger = deps.userInputLedger;
                     const settle = () => ledger.settleLeg(handle);
@@ -1183,8 +1191,6 @@ export async function handleRunVerbs(req, res, match, ctx) {
                 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/session-sync.js

@@ -12,7 +12,7 @@ const SYNC_BLOB_MAX_BYTES = 64 * 1024 * 1024;
 const SYNC_NDJSON_LINE_MAX_BYTES = 8 * 1024 * 1024;
 const SYNC_IMPORT_BATCH = 500;
 import { SHA256_HEX_RE } from "../../digest-form.js";
-import { assertNever } from "../route-ctx.js";
+import { assertNever, SESSION_NOT_FOUND_MESSAGE } from "../route-ctx.js";
 import { readSessionRulesRecords, describeSessionRulesRecordProblem, legacyToolNameProblemOf } from "../../session-policy-wire.js";
 export function createSessionSyncLocal() {
     const pendingStagings = new Map();
@@ -60,18 +60,18 @@ export async function handleSessionSync(req, res, match, ctx) {
             const ownsOrFleet = (o) => scope.fleetWide || o === scope.gateOwner;
             const pullGateOk = () => {
                 if (owner === undefined) {
-                    sendError(res, 404, "not_found.session", "session not found");
+                    sendError(res, 404, "not_found.session", SESSION_NOT_FOUND_MESSAGE);
                     return false;
                 }
                 if (!ownsOrFleet(owner)) {
-                    sendError(res, 404, "not_found.session", "session not found");
+                    sendError(res, 404, "not_found.session", SESSION_NOT_FOUND_MESSAGE);
                     return false;
                 }
                 return true;
             };
             const pushGateOk = () => {
                 if (owner !== undefined && !ownsOrFleet(owner)) {
-                    sendError(res, 404, "not_found.session", "session not found");
+                    sendError(res, 404, "not_found.session", SESSION_NOT_FOUND_MESSAGE);
                     return false;
                 }
                 return true;
@@ -89,7 +89,7 @@ export async function handleSessionSync(req, res, match, ctx) {
                     throw e;
                 }
                 if (out === null) {
-                    sendError(res, 404, "not_found.session", "session not found");
+                    sendError(res, 404, "not_found.session", SESSION_NOT_FOUND_MESSAGE);
                     return;
                 }
                 sendJson(res, 200, { manifest: out.manifest });
@@ -115,7 +115,7 @@ export async function handleSessionSync(req, res, match, ctx) {
                 }
                 const it = await stream(sessionId, afterSeq === undefined ? undefined : { afterSeq });
                 if (it === null) {
-                    sendError(res, 404, "not_found.session", "session not found");
+                    sendError(res, 404, "not_found.session", SESSION_NOT_FOUND_MESSAGE);
                     return;
                 }
                 res.writeHead(200, { "content-type": "application/x-ndjson", "transfer-encoding": "chunked" });

package/dist/http/routes/sessions.js

@@ -9,7 +9,7 @@ import { MAX_SETTINGS_OUTPUT_STYLE_CHARS, MAX_SETTINGS_PERMISSION_RULES, MAX_SET
 import { readWritableSessionPermissionRules, describeSessionPermissionRulesProblem } from "../../session-policy-wire.js";
 import { sendJson, sendError, sendSessionError, sendSessionPolicyError, sseHeaders } from "../send.js";
 import { gatedPrincipal, explicitOperatorOk, runOwnerReadable, sendPrincipalRefusal, sendUnauthorized } from "../principal-gate.js";
-import { assertNever } from "../route-ctx.js";
+import { assertNever, SESSION_NOT_FOUND_MESSAGE } from "../route-ctx.js";
 import { rosterAgentId } from "./agents-roster.js";
 const MCP_STATUS_TTL_MS = 5_000;
 const MCP_MATERIALIZE_TIMEOUT_MS = 10_000;
@@ -68,15 +68,15 @@ async function readLastLegMcp(deps, sessionId, principal) {
 export async function handleSessions(req, res, match, ctx) {
     const { deps } = ctx;
     const { readJson, safeDecode, runOwnerOk, sessionOwnerScope, sessionOwnerScopeForWrite } = ctx.helpers;
-    const readOwnedSessionView = async (sessionAudit, sessionId, notFoundForm) => {
+    const readOwnedSessionView = async (sessionAudit, sessionId) => {
         const ownerOf = deps.sessionStorage?.ownerOf?.bind(deps.sessionStorage);
         if (ownerOf !== undefined) {
             const owner = await ownerOf(sessionId);
             if (owner === undefined) {
-                sendError(res, 404, "not_found.session", "session not found");
+                sendError(res, 404, "not_found.session", SESSION_NOT_FOUND_MESSAGE);
                 return undefined;
             }
-            if (!runOwnerOk(req, res, owner, notFoundForm))
+            if (!runOwnerOk(req, res, owner, "session"))
                 return undefined;
         }
         let audit;
@@ -89,10 +89,10 @@ export async function handleSessions(req, res, match, ctx) {
             throw new Error(`session view read failed before ownership could be established: ${e instanceof Error ? e.message : String(e)}`, { cause: e });
         }
         if (!audit) {
-            sendError(res, 404, "not_found.session", "session not found");
+            sendError(res, 404, "not_found.session", SESSION_NOT_FOUND_MESSAGE);
             return undefined;
         }
-        if (!runOwnerOk(req, res, audit.owner, notFoundForm))
+        if (!runOwnerOk(req, res, audit.owner, "session"))
             return undefined;
         return audit;
     };
@@ -261,21 +261,21 @@ export async function handleSessions(req, res, match, ctx) {
             if (getHead) {
                 const head = await getHead(headSession);
                 if (head === undefined) {
-                    sendError(res, 404, "not_found.session", "session not found");
+                    sendError(res, 404, "not_found.session", SESSION_NOT_FOUND_MESSAGE);
                     return;
                 }
                 owner = head.owner;
-                if (!runOwnerOk(req, res, owner ?? null))
+                if (!runOwnerOk(req, res, owner ?? null, "session"))
                     return;
                 leafId = head.leafId;
             }
             else {
                 owner = await ownerOf(headSession);
                 if (owner === undefined) {
-                    sendError(res, 404, "not_found.session", "session not found");
+                    sendError(res, 404, "not_found.session", SESSION_NOT_FOUND_MESSAGE);
                     return;
                 }
-                if (!runOwnerOk(req, res, owner ?? null))
+                if (!runOwnerOk(req, res, owner ?? null, "session"))
                     return;
                 leafId = await getLeafId(headSession);
             }
@@ -355,10 +355,10 @@ export async function handleSessions(req, res, match, ctx) {
                 }
                 if (owner === undefined) {
                     cleanup();
-                    sendError(res, 404, "not_found.session", "session not found");
+                    sendError(res, 404, "not_found.session", SESSION_NOT_FOUND_MESSAGE);
                     return;
                 }
-                if (!runOwnerOk(req, res, owner ?? null)) {
+                if (!runOwnerOk(req, res, owner ?? null, "session")) {
                     cleanup();
                     return;
                 }
@@ -498,7 +498,7 @@ export async function handleSessions(req, res, match, ctx) {
                 sendError(res, 501, "capability.memory_engine_required", "memory provenance and erasure are not available on this deployment — they require a wired memory engine (MEMORY_ENGINE=on) whose backend owns the engine control plane (controlPlaneRoot); the file memory backend does, the pg/tidb memory backends do not (their control plane would land on a replica's local disk)");
                 return;
             }
-            if ((await readOwnedSessionView(deps.sessionAudit, sessionId, "session")) === undefined)
+            if ((await readOwnedSessionView(deps.sessionAudit, sessionId)) === undefined)
                 return;
             const faces = deps.memoryCompliance;
             if (faces === undefined) {
@@ -550,7 +550,7 @@ export async function handleSessions(req, res, match, ctx) {
                 sendError(res, 501, "capability.memory_engine_required", "session memory status is not available on this deployment — it requires a wired memory engine (MEMORY_ENGINE=on) whose backend owns the engine control plane (controlPlaneRoot); the file memory backend does, the pg/tidb memory backends do not (their control plane would land on a replica's local disk)");
                 return;
             }
-            if ((await readOwnedSessionView(deps.sessionAudit, sessionId, "session")) === undefined)
+            if ((await readOwnedSessionView(deps.sessionAudit, sessionId)) === undefined)
                 return;
             const face = deps.sessionMemoryStatus;
             if (face === undefined) {
@@ -594,7 +594,7 @@ export async function handleSessions(req, res, match, ctx) {
                 sendError(res, 404, "not_found.route", "not found");
                 return;
             }
-            const audit = await readOwnedSessionView(deps.sessionAudit, match.params.sessionId, "run");
+            const audit = await readOwnedSessionView(deps.sessionAudit, match.params.sessionId);
             if (audit === undefined)
                 return;
             const q = new URLSearchParams(match.search);
@@ -665,17 +665,17 @@ export async function handleSessions(req, res, match, ctx) {
             }
             const owner = await ownerOf(sourceId);
             if (owner === undefined) {
-                sendError(res, 404, "not_found.session", "session not found");
+                sendError(res, 404, "not_found.session", SESSION_NOT_FOUND_MESSAGE);
                 return;
             }
             if (!scope.fleetWide && owner !== scope.gateOwner && !legacyUnownedSessionOk(deps.config.requirePrincipal, scope.gateOwner, owner)) {
-                sendError(res, 404, "not_found.session", "session not found");
+                sendError(res, 404, "not_found.session", SESSION_NOT_FOUND_MESSAGE);
                 return;
             }
             const newOwner = scope.fleetWide ? (owner ?? null) : scope.gateOwner;
             const newId = await fork(sourceId, newOwner);
             if (newId === null) {
-                sendError(res, 404, "not_found.session", "session not found");
+                sendError(res, 404, "not_found.session", SESSION_NOT_FOUND_MESSAGE);
                 return;
             }
             sendJson(res, 200, { sessionId: newId });
@@ -747,7 +747,7 @@ export async function handleSessions(req, res, match, ctx) {
             }
             const owner = await ownerOf(sessionId);
             if (owner === undefined) {
-                sendError(res, 404, "not_found.session", "session not found");
+                sendError(res, 404, "not_found.session", SESSION_NOT_FOUND_MESSAGE);
                 return;
             }
             if (owner === null) {
@@ -756,7 +756,7 @@ export async function handleSessions(req, res, match, ctx) {
             }
             const operator = explicitOperatorOk(principal, deps.config.operatorPrincipals);
             if (!operator && owner !== (principal ?? null)) {
-                sendError(res, 404, "not_found.session", "session not found");
+                sendError(res, 404, "not_found.session", SESSION_NOT_FOUND_MESSAGE);
                 return;
             }
             const target = owner;

package/dist/http/routes/tasks.js

@@ -418,6 +418,7 @@ export async function handleTasks(req, res, match, ctx) {
                                 if (ev.type === "message_committed" && ev.role === "user")
                                     userMsgEntryId = ev.entryId;
                                 const causeAtDone = ev.type === "done" ? ac.cause() : undefined;
+                                await deps.userInputLedger?.observeLegEvent(liveStream, ev);
                                 if (ev.type === "done") {
                                     finalResult = await mintSubmitExitResult(ev.result, deps.checkpointStore);
                                     if (durableTaskId && finalResult)

package/dist/http/send.d.ts

@@ -80,7 +80,7 @@ export declare function sendSessionPolicyError(res: ServerResponse, e: unknown):
  * 句子:属主给了固定句就发它(import 面 `invalid_session` 那一句),否则发 core 的原句过既有脱敏(`redactErrorMessage`:
  * 不抛、有上限)。core 的 `corrupt_session` 原句只点名会话 id 与跳过计数(「Session <id> is unreadable: its log has no
  * meta header (N of M records skipped as corrupt)」),SQL 两店的原句点名 `<表>.<列>` 与行号 —— 两者都不含盘上路径
- * (路径只进运维日志:`session_repo_corrupt_read` 行)。
+ * (路径只进运维面:`server.session-repo.corrupt-record-skipped` 的探针行,S-990;SQL 两店走各自的拒绝句)。
  */
 export declare function sendSessionError(res: ServerResponse, e: unknown, face: SessionErrorFace): boolean;
 export declare function msg(e: unknown): string;

package/dist/http/send.js

@@ -43,7 +43,7 @@ export function sendSessionPolicyError(res, e) {
     if (!(e instanceof SessionPolicyError))
         return false;
     const h = sessionPolicyErrorHttp(e.code);
-    sendError(res, h.status, h.errorCode, e.message);
+    sendError(res, h.status, h.errorCode, redactErrorMessage(e.message) ?? "session policy error");
     return true;
 }
 export function sendSessionError(res, e, face) {

package/dist/http/wire-types.d.ts

@@ -233,13 +233,13 @@ export interface TaskRequestBody {
      *  core 默认开列表注入的通道)与三个 deadline opt-out 在类型面失踪。agentListing/skillsListing 是
      *  boolean 透传(core DEFAULT-ON,explicit false 才关);budgetUsd/mcpInstructions 只认 literal true;
      *  limits 三个 opt-out 只认 literal false(normalizer 同判)。 */
+    /** core 7.39.0 #1254:`planModeReminder` 退役(硬破坏,零别名)—— 提交即 400 点名退役;plan 姿态由引擎从 `permissionMode:"plan"` 自己陈述。 */
     attachments?: {
         todoReminder?: boolean;
         todoReminderMode?: "baseline" | "off";
         changedFiles?: boolean | {
             maxFiles?: number;
         };
-        planModeReminder?: boolean;
         budgetUsd?: true;
         backgroundTasks?: boolean;
         toolsDelta?: boolean;