@sema-agent/server 7.71.0 → 7.73.0

package/dist/http/durable-run-leg.d.ts

@@ -0,0 +1,64 @@
+/**
+ * **一条 durable run 的「建行 + 驱动」单一属主**(S-218 提取;此前整段住在 `routes/runs.ts` 的
+ * `createDurableRun` 里,只服务 HTTP/A2A 两条提交门)。
+ *
+ * 🔴 为什么提成模块:`/decide` 的 workflow 第三条车道在**宿主不在 park 上**时,同样要在宿主会话上起
+ * 一跑新 turn 把决定交给宿主的模型(S-218)。这条链上挂着 `createRun` 的会话 claim(以及它唯一诚实的
+ * 409 出路)、checkpoint ctx 落库、fleet 行发布、resume/rewind 两族锚点捕获、审批 ALS、通告投递……
+ * 手抄第二份 = 把这十来件事复制成两份会漂的实现,而漂开的那天没有任何东西会说话(`createDurableRun`
+ * 当年从路由体里提取出来时,头注写的就是同一条判词)。方向:`routes/runs.ts` 与 `http/server.ts`
+ * 都 import 本模块,本模块谁都不 import —— 与 `http/run-meta.ts` 同一条「两个域共用一件 ⇒ 单独成文件」。
+ *
+ * 边界(本腿**不**含的东西,留给各自的门):`body.taskId` 幂等重放、`Idempotency-Key` 内存去重、
+ * lease / 治理窗 pre-admission、属主门。它们是**提交面**的判据(读请求、写响应),而本腿只吃已经备好的
+ * `PreparedTaskSubmission` 并交回一份收据 —— 这正是它能被一条没有 `ServerResponse` 的内部车道复用的原因。
+ */
+import { type RunInternals } from "@sema-agent/core";
+import type { RunStore } from "../plugins/store-backend.js";
+import type { PreparedTaskSubmission, RouteCtxBase } from "./route-ctx.js";
+/**
+ * 🔴 **TRUSTED run internals** —— 由**部署方**(不是模型、不是请求体、不是工具参数)铸给这一跑的
+ * core 内部席位。今天唯一成员 `workflowParkedResume` = 人对一条 parked workflow 子代的决定
+ * (语义属主 = core `RunInternals.workflowParkedResume` 的 d.ts 顶注:「A host that decided a workflow
+ * child's parked checkpoint launches the run that re-invokes `Workflow({resumeFromRunId})` with the
+ * decision here」)。
+ *
+ * 为什么单独命名而不是直接摊 `RunInternals`:`RunInternals` 里绝大多数席位是**执行腿自己**铸的
+ * (onForwardEvent / onTaskNotification / onActivity …),把整只类型开给调用方等于邀请第二个写者;
+ * 本类型只开「部署方可以决定的那一格」,新增一格时**必须**在这里显式点名,编译期看得见。
+ * 缺席 ⇒ 对两条腿都是完整 no-op。
+ */
+export type TrustedRunInternals = Pick<RunInternals, "workflowParkedResume">;
+export interface DurableRunLegArgs {
+    /** `prepareSpec` 的产物,或内部车道按同一条 `resolveSpec` 装配出来的等价形。 */
+    prepared: PreparedTaskSubmission;
+    /** 调用方自带的 taskId(`POST /v1/runs` 的 `body.taskId` 幂等键);缺席 ⇒ 本腿铸 uuidv7。 */
+    clientTaskId?: string;
+    /** 🔒 这条 run 的 **fleet 行 scope** —— 必须与 `GET /v1/fleet/stream` 过滤用的是同一个身份,且绝不是
+     *  自报的 `x-agent-principal` 头(自报头会把行打到受害者的 scope 上,或打到 `default` 而真属主的流把它
+     *  过滤掉)。提交门传 `gatedPrincipal(req) ?? "default"`;`/decide` 的第三条车道传 resume 家族的
+     *  `resumeFleetScope(req, auth)`(同一条 wire 上两条腿因此同答)。 */
+    fleetScope: string;
+    /** 🔒 这条 run 的 **elicit / question 应答方**(E23:与 respond 门读的是同一个已验身份,不是自报头)。
+     *  提交门传 `gatedPrincipal(req) ?? null` = 提交者本人;`/decide` 的第三条车道传**卡属主**(= 原提交者,
+     *  不是代为按下按钮的 operator —— 与 resume 腿那条成文口径逐字同源)。`null` = 匿名/开放部署。 */
+    elicitOwner: string | null;
+    /** run 行元数据的 `source` 列(调用方的系统身份;内部车道传自己的车道名)。 */
+    source: string | null;
+    /** 见 {@link TrustedRunInternals}。缺席 ⇒ 与本位存在之前逐字相同。 */
+    trustedInternals?: TrustedRunInternals;
+}
+/**
+ * 建行 + 驱动。返回 `202` = 新行已建并在跑(体带 `taskId`/`sessionId`);`409` = 会话被别的 run 占着,
+ * **没有**建行(体 = `buildActiveRunConflict` 的既有形,含 `errorCode: "conflict.session_active_run"`)。
+ * 协议渲染归调用方(HTTP `sendJson` / A2A 协议对象 / `/decide` 的受理体)。
+ */
+export declare function mintAndDriveDurableRun(ctx: RouteCtxBase, runStore: RunStore, args: DurableRunLegArgs): Promise<{
+    status: number;
+    body: {
+        taskId: string;
+        sessionId: string;
+        status: string;
+    } | object;
+}>;
+//# sourceMappingURL=durable-run-leg.d.ts.map

package/dist/http/durable-run-leg.js

@@ -0,0 +1,63 @@
+import { uuidv7 } from "@sema-agent/core";
+import { runInBackground } from "../runs.js";
+import { fleetRunPublisher, fleetRunLabels } from "../fleet/fleet-bus.js";
+import { cascadeConfig, runMeta } from "./run-meta.js";
+import { resolveStreamApprovalGate } from "../tool-approval.js";
+import { buildActiveRunConflict } from "./active-run-conflict.js";
+import { clearTurnActivity, readTurnActivityMs } from "../turn-activity.js";
+import { recordResourceWindow } from "../resource-window.js";
+export async function mintAndDriveDurableRun(ctx, runStore, args) {
+    const { deps } = ctx;
+    const { inflightRuns, preemptableRuns, steerableRuns } = ctx.registry;
+    const sessionId = args.prepared.spec.sessionId ?? uuidv7();
+    const taskId = args.clientTaskId ?? uuidv7();
+    const created = await runStore.createRun(taskId, sessionId, args.prepared.auth?.principal ?? null, deps.instanceId ?? "default", runMeta(args.prepared, args.source));
+    if (created.ok)
+        clearTurnActivity(taskId);
+    if (created.ok)
+        recordResourceWindow(taskId, args.prepared.spec.resourceSuspend);
+    if (created.ok)
+        deps.sessionTitler?.maybeTitle(sessionId, args.prepared.spec.objective, typeof args.prepared.spec.model === "string" ? args.prepared.spec.model : args.prepared.spec.model?.id);
+    if (!created.ok) {
+        if (args.clientTaskId && created.activeTaskId === args.clientTaskId) {
+            return { status: 202, body: { taskId: args.clientTaskId, sessionId, status: "running" } };
+        }
+        return { status: 409, body: await buildActiveRunConflict({ runStore, checkpointStore: deps.checkpointStore, governance: deps.config, runStaleSec: deps.config.runStaleSec, turnActivity: readTurnActivityMs }, sessionId, created.activeTaskId) };
+    }
+    if (deps.checkpointStore) {
+        await deps.checkpointStore.putCtx(sessionId, { body: args.prepared.body, memoryScope: args.prepared.auth?.memoryScope });
+    }
+    const anchorOwner = args.prepared.auth?.principal ?? null;
+    const getLeafId = deps.sessionStorage?.getLeafId?.bind(deps.sessionStorage);
+    const captureTurnAnchor = deps.resumeAnchorStore && getLeafId
+        ? async (eventId) => {
+            const leaf = await getLeafId(sessionId);
+            if (leaf)
+                await deps.resumeAnchorStore.put(sessionId, eventId, leaf, anchorOwner);
+        }
+        : undefined;
+    const captureUserMessageAnchor = deps.resumeAnchorStore
+        ? async (entryId) => { await deps.resumeAnchorStore.put(sessionId, taskId, entryId, anchorOwner); }
+        : undefined;
+    const fleetPub = fleetRunPublisher(deps.fleetBus, {
+        runId: taskId,
+        scope: args.fleetScope,
+        rootTaskId: taskId,
+        ...fleetRunLabels(args.prepared.spec.objective),
+    });
+    void runInBackground(args.prepared.runner, { ...args.prepared.spec, sessionId }, runStore, taskId, deps.metrics, args.prepared.auth?.principal, args.prepared.verify, args.prepared.cascade ? cascadeConfig(deps.config.cascadeLadder, args.prepared.spec.limits?.maxCostUsd) : undefined, deps.instrumentDegenerate, deps.planCacheProbe, deps.config.traceThinking, inflightRuns, preemptableRuns, steerableRuns, deps.modelUsage, deps.elicitation, args.elicitOwner, captureTurnAnchor, fleetPub, captureUserMessageAnchor, deps.question, deps.workflowCompletionInbox, deps.subagentSteerRegistry, (m, x) => deps.logger?.info?.(m, x), deps.sendUserFile, deps.promptManifests, deps.toolApproval
+        ? {
+            coordinator: deps.toolApproval,
+            streamApprovalOn: resolveStreamApprovalGate({
+                toolApprovalEnabled: true,
+                streamApprovalEnabled: deps.config.streamApproval?.enabled === true,
+                backend: deps.backend,
+                parkFacility: deps.checkpointStore !== undefined,
+            }).active,
+            windowMs: deps.config.streamApproval?.windowMs,
+            windowMarginMs: deps.config.streamAskWindowMarginMs,
+        }
+        : undefined, deps.checkpointStore, args.prepared.engineNotices, args.trustedInternals);
+    return { status: 202, body: { taskId, sessionId, status: "running" } };
+}
+//# sourceMappingURL=durable-run-leg.js.map

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

@@ -438,6 +438,20 @@ export interface RouteMiss {
  * 两臂逐字节同形,指路价值不丢。钉=audit-fixes-http「[ref]」格(两臂全文比对);文案变更走
  * api-error-text-freeze 基线流程。
  */
+/**
+ * **「决定/续跑已受理」那一枚 200 收据的单一铸点**(S-218)。
+ *
+ * 两条腿投同一份体:①resume 家族的受理点(`driveResumeLeg`,宿主停在 park 上时);②`/decide` 的
+ * workflow 第三条车道在宿主**不在** park 上时新铸的那一跑。契约上这两条腿说的是同一句话 ——
+ * 「决定已被受理,拿 `taskId` 去 poll `GET /v1/runs/:id` / `/events` 跟终态」——所以消费端**一条分支
+ * 都不该加**;写成两份字面量,漂开的那天没有任何东西会说话。
+ *
+ * `bindingEnforced` 的语义不因铸点而变(「这次决定按绑定坐标受理,不是盲目放行」),故两腿同带。
+ */
+export declare function acceptedResumingReceipt(taskId: string, sessionId: string): {
+    status: number;
+    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)";
 /** [ref] 前缀=域判别子既成契约:a\* 与 wa\* 形 id 给 TaskOutput/journal 指路;其余给 {@link RUN_NOT_FOUND_MESSAGE}。 */
 export declare function runNotFoundMessage(id: string): string;

package/dist/http/route-ctx.js

@@ -17,6 +17,9 @@ export function sendResumeOutcome(res, out, logger, extraBody) {
         res.setHeader("retry-after", String(Math.ceil(wait)));
     sendJson(res, out.status, extraBody === undefined ? out.body : { ...out.body, ...extraBody });
 }
+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 function runNotFoundMessage(id) {
     const aStar = /^(?:a|wa)[0-9a-f]{4,}$/i.test(id);

package/dist/http/routes/approvals-assistant.js

@@ -1,4 +1,4 @@
-import { screenedGate } from "../../trace/project.js";
+import { screenedStoredGate } from "../../trace/project.js";
 import { personDecision } from "../../host-decision.js";
 import { sameExecutionRecord } from "@sema-agent/core";
 import { DECIDED_REPLAY_SCAN_CAP, approvalPayloadFingerprint } from "../../plugins/checkpoint-store-sql.js";
@@ -87,7 +87,7 @@ async function decideIdempotentReplay(cs, args) {
                 return undefined;
             }
         }
-        return screenedGate(first);
+        return screenedStoredGate(first);
     })();
     return {
         status: 200,
@@ -200,7 +200,7 @@ async function handleApprovalsAssistantBody(req, res, url, ctx, miss) {
                     ...(s.requiresRealApproval === true ? { requiresRealApproval: true } : {}),
                     ...(s.denialLimitFallback !== undefined ? { denialLimitFallback: s.denialLimitFallback } : {}),
                     ...(s.origin !== undefined ? { origin: s.origin } : {}),
-                    ...(s.classifierUnavailable !== undefined ? { classifierUnavailable: s.classifierUnavailable } : {}),
+                    ...(s.ruleStoreUnreadable !== undefined ? { ruleStoreUnreadable: s.ruleStoreUnreadable } : {}),
                     objective: ctx?.body?.objective ?? null,
                     input,
                 };

package/dist/http/routes/capabilities.js

@@ -1,4 +1,4 @@
-import { DEFAULT_EFFORT_LEVELS, expandTiers, routePairingStatus } from "@sema-agent/core";
+import { expandTiers, reasoningEffortLevelsOf, routePairingStatus } from "@sema-agent/core";
 import { isModelAllowlisted } from "../../model-select.js";
 import { resolveModelApiKey } from "../../key-resolver.js";
 import { isSealedKeyPoison } from "../../sealed-key.js";
@@ -194,7 +194,7 @@ async function handleCapabilitiesBody(req, res, url, ctx, miss) {
             vision: Array.isArray(m.input) ? m.input.includes("image") : false,
             ...(m.contextWindow ? { contextWindow: m.contextWindow } : {}),
             ...(m.maxTokens ? { maxOutputTokens: m.maxTokens } : {}),
-            ...(m.reasoning ? { supportedEffortLevels: [...DEFAULT_EFFORT_LEVELS] } : {}),
+            ...((levels) => (levels !== undefined ? { supportedEffortLevels: [...levels] } : {}))(reasoningEffortLevelsOf(m)),
             ...(m.compat !== undefined ? { compat: m.compat } : {}),
             ...(atAllowlist.length > 0 ? { atMentionable: isModelAllowlisted(name, atCatalog, atAllowlist) } : {}),
             routePairing: routePairingOf(deps, name, m),

package/dist/http/routes/runs.js

@@ -6,13 +6,10 @@ import { isTerminalRunStatus, isParkedRunStatus } from "../../plugins/store-cont
 import { LIVE_RUN_GATE_KINDS, TERMINAL_PARK_GATE_KINDS } from "../../plugins/checkpoint-store-sql.js";
 import { redactSecrets } from "../../trace/redact.js";
 import { HttpError, verifiedPrincipal, isUuidV7, encodeCheckpointScope } from "../../security.js";
-import { runInBackground } from "../../runs.js";
 import { redactSteerIn, STEER_IN_MAX_CHARS, STEER_IN_MAX_REQUEST_CHARS } from "../../orchestration/workflow-agent-steer.js";
 import { defaultSubagentTailBus } from "../../fleet/subagent-tail-bus.js";
-import { fleetRunPublisher, fleetRunLabels } from "../../fleet/fleet-bus.js";
 import { composeSupervisorCost, infraCost, infraUsageFromEvents, hasInfraPricing } from "../../observability/cost-taxonomy.js";
 import { recordFailOpen } from "../../observability/fail-open.js";
-import { cascadeConfig, runMeta } from "../run-meta.js";
 import { createHash } from "node:crypto";
 import { scopedIdempotencyKey } from "../idempotency.js";
 import { streamSseLog } from "../sse-log.js";
@@ -20,14 +17,14 @@ import { bindSseLifecycle } from "../sse-lifecycle.js";
 import { buildApprovalPreamble, buildApprovalPreambleSseFrames } from "../../approval-card.js";
 import { ASK_DECISION_CONSUMER_ABSENT, resolveStreamApprovalGate } from "../../tool-approval.js";
 import { MAX_DECISION_NOTE_CHARS } from "../../approval-ask-machine.js";
-import { normalizeRunEventType } from "../../trace/project.js";
+import { normalizeRunEventType, screenedStoredEventData } from "../../trace/project.js";
 import { sendJson, sendError, httpErrorCode, sseHeaders } from "../send.js";
-import { buildActiveRunConflict } from "../active-run-conflict.js";
-import { clearTurnActivity, readTurnActivityMs } from "../../turn-activity.js";
+import { readTurnActivityMs } from "../../turn-activity.js";
 import { mintCancelledResult } from "../../run-cancel-context.js";
-import { buildCrossSliceUsage, readResourceWindow, recordResourceWindow } from "../../resource-window.js";
+import { buildCrossSliceUsage, readResourceWindow } from "../../resource-window.js";
 import { headerStr, gatedPrincipal, explicitOperatorOk } from "../principal-gate.js";
 import { ActorAssertionWire } from "@sema-agent/settings-schema";
+import { mintAndDriveDurableRun } from "../durable-run-leg.js";
 import { RUN_NOT_FOUND_MESSAGE, runNotFoundMessage } from "../route-ctx.js";
 import { withPrincipal } from "../../observability/principal-context.js";
 export const RUN_ID_RE = /^\/v1\/runs\/([^/]+)(\/events)?$/;
@@ -140,9 +137,10 @@ async function streamRunEvents(req, res, deps, runStore, taskId, staleMs) {
         retainedFrom: (id) => runStore.retainedFrom(id),
         formatEvent: (ev) => {
             const type = normalizeRunEventType(ev.type);
-            const data = type === "done" && ev.data && typeof ev.data === "object" && ev.data.result && typeof ev.data.result === "object"
+            const redacted = type === "done" && ev.data && typeof ev.data === "object" && ev.data.result && typeof ev.data.result === "object"
                 ? { ...ev.data, result: memoRedactTerminalResult("ev.done.result", ev.data.result) }
                 : type === "failed" ? memoRedactedRead("ev.failed", ev.data, (d) => redactLedgerEventData(type, d)) : redactLedgerEventData(type, ev.data);
+            const data = screenedStoredEventData(type, redacted);
             return { id: ev.seq, event: type, data: { type, ...(data ?? {}) } };
         },
         staleFrame: () => ({ event: "failed", data: { type: "failed", errorMessage: "run stalled (instance lost?)" } }),
@@ -265,6 +263,8 @@ async function handleRunsBody(req, res, url, ctx, miss) {
                 error: stale ? "run stalled (instance lost?)" : isTerminalRunStatus(run.status) ? memoRedactedRead("run.error", run.error ?? undefined, redactErrorMessage) : redactErrorMessage(run.error ?? undefined),
                 jobId: run.jobId ?? undefined,
                 source: run.source ?? undefined,
+                heldBy: run.instanceId ?? null,
+                cancelRequested: run.cancelRequested,
             });
         }
         return;
@@ -305,7 +305,7 @@ async function handleRunsBody(req, res, url, ctx, miss) {
                             sendError(res, 409, "conflict.approval_settled", "pending approval was settled concurrently (decided or expired) — re-check the run and retry cancel if it is still active", { taskId, status: st });
                         }
                         else {
-                            sendJson(res, 202, { taskId, status: st ?? "failed", note: "run already terminal — cancel is a no-op" });
+                            sendJson(res, 202, { taskId, status: st ?? "failed", cancelRequested: now?.cancelRequested ?? false, note: "run already terminal — cancel is a no-op" });
                         }
                         return;
                     }
@@ -319,7 +319,7 @@ async function handleRunsBody(req, res, url, ctx, miss) {
                             sendError(res, 409, "conflict.approval_settled", "pending approval was settled concurrently (decided or expired) — re-check the run and retry cancel if it is still active", { taskId, status: st });
                         }
                         else {
-                            sendJson(res, 202, { taskId, status: st ?? "failed", note: "run already terminal — cancel is a no-op" });
+                            sendJson(res, 202, { taskId, status: st ?? "failed", cancelRequested: now?.cancelRequested ?? false, note: "run already terminal — cancel is a no-op" });
                         }
                         return;
                     }
@@ -355,10 +355,10 @@ async function handleRunsBody(req, res, url, ctx, miss) {
             }
             const finalRow = await rs.getRun(taskId).catch(() => undefined);
             if (finalRow && finalRow.errorCode !== "cancelled" && isTerminalRunStatus(finalRow.status)) {
-                sendJson(res, 202, { taskId, status: finalRow.status, errorCode: finalRow.errorCode ?? null, note: `session unlocked; the run was terminalized concurrently (${finalRow.errorCode ?? finalRow.status}) before this cancel's write — reporting the actual ledger state` });
+                sendJson(res, 202, { taskId, status: finalRow.status, errorCode: finalRow.errorCode ?? null, cancelRequested: finalRow.cancelRequested, note: `session unlocked; the run was terminalized concurrently (${finalRow.errorCode ?? finalRow.status}) before this cancel's write — reporting the actual ledger state` });
                 return;
             }
-            sendJson(res, 202, { taskId, status: "failed", errorCode: "cancelled", note });
+            sendJson(res, 202, { taskId, status: "failed", errorCode: "cancelled", cancelRequested: false, note });
         };
         if (run.status === "running") {
             let flagged = await deps.runStore.requestCancel(taskId, run.owner);
@@ -374,23 +374,23 @@ async function handleRunsBody(req, res, url, ctx, miss) {
                     continue;
                 }
                 if (now?.status === "running") {
-                    sendError(res, 409, "conflict.approval_settled", "pending approval was settled concurrently (decided or expired) — re-check the run and retry cancel if it is still active", { taskId, status: now.status });
+                    sendError(res, 409, "conflict.run_not_running", "the cancel flag could not be set: this run was not in 'running' state at the moment of each attempt (it keeps flipping between running and a park) — retry cancel", { taskId, status: now.status });
                     return;
                 }
-                sendJson(res, 202, { taskId, status: now?.status ?? "failed", note: "run already terminal — cancel is a no-op" });
+                sendJson(res, 202, { taskId, status: now?.status ?? "failed", cancelRequested: now?.cancelRequested ?? false, note: "run already terminal — cancel is a no-op" });
                 return;
             }
             if (inflightRuns.has(taskId)) {
                 cancelledViaVerb.add(taskId);
                 inflightRuns.get(taskId).abort();
             }
-            sendJson(res, 202, { taskId, status: "cancelling" });
+            sendJson(res, 202, { taskId, status: "cancelling", cancelRequested: true });
         }
         else if (isParkedRunStatus(run.status)) {
             await cancelSuspended();
         }
         else {
-            sendJson(res, 202, { taskId, status: run.status, note: "run already terminal — cancel is a no-op" });
+            sendJson(res, 202, { taskId, status: run.status, cancelRequested: run.cancelRequested, note: "run already terminal — cancel is a no-op" });
         }
         return;
     }
@@ -1559,58 +1559,13 @@ export async function createDurableRun(req, res, ctx, prepared, idemKey) {
     }
     if ((await leaseDenied(req, res)) || (await usageWindowDenied(req, res)))
         return null;
-    const resp = await idemCache.run(idemKey, async () => {
-        const sessionId = prepared.spec.sessionId ?? uuidv7();
-        const taskId = clientTaskId ?? uuidv7();
-        const created = await runStore.createRun(taskId, sessionId, prepared.auth?.principal ?? null, deps.instanceId ?? "default", runMeta(prepared, source));
-        if (created.ok)
-            clearTurnActivity(taskId);
-        if (created.ok)
-            recordResourceWindow(taskId, prepared.spec.resourceSuspend);
-        if (created.ok)
-            deps.sessionTitler?.maybeTitle(sessionId, prepared.spec.objective, typeof prepared.spec.model === "string" ? prepared.spec.model : prepared.spec.model?.id);
-        if (!created.ok) {
-            if (clientTaskId && created.activeTaskId === clientTaskId) {
-                return { status: 202, body: { taskId: clientTaskId, sessionId, status: "running" } };
-            }
-            return { status: 409, body: await buildActiveRunConflict({ runStore, checkpointStore: deps.checkpointStore, governance: deps.config, runStaleSec: deps.config.runStaleSec, turnActivity: readTurnActivityMs }, sessionId, created.activeTaskId) };
-        }
-        if (deps.checkpointStore) {
-            await deps.checkpointStore.putCtx(sessionId, { body: prepared.body, memoryScope: prepared.auth?.memoryScope });
-        }
-        const anchorOwner = prepared.auth?.principal ?? null;
-        const getLeafId = deps.sessionStorage?.getLeafId?.bind(deps.sessionStorage);
-        const captureTurnAnchor = deps.resumeAnchorStore && getLeafId
-            ? async (eventId) => {
-                const leaf = await getLeafId(sessionId);
-                if (leaf)
-                    await deps.resumeAnchorStore.put(sessionId, eventId, leaf, anchorOwner);
-            }
-            : undefined;
-        const captureUserMessageAnchor = deps.resumeAnchorStore
-            ? async (entryId) => { await deps.resumeAnchorStore.put(sessionId, taskId, entryId, anchorOwner); }
-            : undefined;
-        const fleetPub = fleetRunPublisher(deps.fleetBus, {
-            runId: taskId,
-            scope: gatedPrincipal(req, deps.config) ?? "default",
-            rootTaskId: taskId,
-            ...fleetRunLabels(prepared.spec.objective),
-        });
-        void runInBackground(prepared.runner, { ...prepared.spec, sessionId }, runStore, taskId, deps.metrics, prepared.auth?.principal, prepared.verify, prepared.cascade ? cascadeConfig(deps.config.cascadeLadder, prepared.spec.limits?.maxCostUsd) : undefined, deps.instrumentDegenerate, deps.planCacheProbe, deps.config.traceThinking, inflightRuns, preemptableRuns, steerableRuns, deps.modelUsage, deps.elicitation, gatedPrincipal(req, deps.config) ?? null, captureTurnAnchor, fleetPub, captureUserMessageAnchor, deps.question, deps.workflowCompletionInbox, deps.subagentSteerRegistry, (m, x) => deps.logger?.info?.(m, x), deps.sendUserFile, deps.promptManifests, deps.toolApproval
-            ? {
-                coordinator: deps.toolApproval,
-                streamApprovalOn: resolveStreamApprovalGate({
-                    toolApprovalEnabled: true,
-                    streamApprovalEnabled: deps.config.streamApproval?.enabled === true,
-                    backend: deps.backend,
-                    parkFacility: deps.checkpointStore !== undefined,
-                }).active,
-                windowMs: deps.config.streamApproval?.windowMs,
-                windowMarginMs: deps.config.streamAskWindowMarginMs,
-            }
-            : undefined, deps.checkpointStore, prepared.engineNotices);
-        return { status: 202, body: { taskId, sessionId, status: "running" } };
-    }, (r) => r.status === 202);
+    const resp = await idemCache.run(idemKey, async () => await mintAndDriveDurableRun({ deps, registry: ctx.registry, helpers: ctx.helpers, local: ctx.local, legs: ctx.legs }, runStore, {
+        prepared,
+        ...(clientTaskId !== undefined ? { clientTaskId } : {}),
+        fleetScope: gatedPrincipal(req, deps.config) ?? "default",
+        elicitOwner: gatedPrincipal(req, deps.config) ?? null,
+        source,
+    }), (r) => r.status === 202);
     return resp;
 }
 //# sourceMappingURL=runs.js.map

package/dist/http/routes/workflows.js

@@ -338,6 +338,7 @@ function summarizeWorkflowDetail(run) {
         durationMs: durationOf(run),
         rev: run.rev,
         ...(run.error !== undefined ? { error: redactErrorMessage(run.error) ?? "" } : {}),
+        ...(run.errorCode !== undefined ? { errorCode: run.errorCode } : {}),
         ...(run.result !== undefined ? { result: redactSecrets(run.result) } : {}),
         phases,
         ...(unphasedView ? { unphased: unphasedView } : {}),

package/dist/http/server.js

@@ -43,6 +43,8 @@ import { IdempotencyCache, scopedIdempotencyKey } from "./idempotency.js";
 export { scopedIdempotencyKey };
 import { streamSseLog } from "./sse-log.js";
 import { verifyRoundsFromBody } from "./verify-rounds.js";
+import { acceptedResumingReceipt } from "./route-ctx.js";
+import { mintAndDriveDurableRun } from "./durable-run-leg.js";
 import { RUN_NOT_FOUND_MESSAGE } from "./route-ctx.js";
 import { handleCapabilities } from "./routes/capabilities.js";
 import { handleObservability } from "./routes/observability.js";
@@ -1218,22 +1220,14 @@ export function createHttpServer(rawDeps) {
                 const plan = planWorkflowParkedDecide(origin, parkedReq);
                 if (!plan.ok)
                     return plan.deny;
+                const parkedResume = { workflowParkedResume: [{ runId: plan.runId, token, outcome: plan.outcome }] };
                 const hostToken = await cs
                     .findPendingTokenBySession(plan.hostSessionId, undefined, { gateKinds: TERMINAL_PARK_GATE_KINDS, pick: "oldest" })
                     .catch(() => undefined);
-                if (!hostToken) {
-                    return {
-                        status: 409,
-                        body: {
-                            error: "the workflow's originating session is not parked awaiting this run — the deployment can only deliver the decision on the host's next turn; retry once the host session parks, or resume the workflow run yourself",
-                            errorCode: "decide.workflow_host_not_parked",
-                            runId: plan.runId,
-                        },
-                    };
-                }
-                return await resumeWake(plan.hostSessionId, plan.message, decider?.principal, req, acceptEarly, [
-                    { runId: plan.runId, token, outcome: plan.outcome },
-                ]);
+                const admittedPayer = decodeCheckpointScope(cp.scope);
+                return hostToken
+                    ? await resumeWake(plan.hostSessionId, plan.message, decider?.principal, req, acceptEarly, parkedResume.workflowParkedResume, admittedPayer)
+                    : await startFreshHostTurn(plan.hostSessionId, plan.message, admittedPayer, req, parkedResume, plan.runId);
             }
         }
         let ctx;
@@ -1286,9 +1280,11 @@ export function createHttpServer(rawDeps) {
         noteLateSettleIfAccepted(driven);
         return driven;
     }
+    const ONE_SHOT_HISTORY_KEYS = ["resumeAt", "restoreFiles", "acceptPartialRestore", "rewindFilesTo", "rewindFiles"];
+    const ONE_SHOT_HISTORY_STRIP = Object.fromEntries(ONE_SHOT_HISTORY_KEYS.map((k) => [k, undefined]));
     const resolveResumeSpec = async (body, req, auth) => {
         const engineNotices = [];
-        const spec = await deps.resolveSpec({ ...body, resumeAt: undefined }, req, auth, { leg: "resume", onNotice: (n) => engineNotices.push(n) });
+        const spec = await deps.resolveSpec({ ...body, ...ONE_SHOT_HISTORY_STRIP }, req, auth, { leg: "resume", onNotice: (n) => engineNotices.push(n) });
         return { spec, engineNotices };
     };
     async function driveResumeIntoRunLog(args) {
@@ -1638,7 +1634,7 @@ export function createHttpServer(rawDeps) {
                         steerableRuns.set(taskId, stream);
                     if (!taskId || !rs)
                         return await stream.result();
-                    onAccepted?.({ status: 200, body: { taskId, sessionId, status: "resuming", bindingEnforced: true } });
+                    onAccepted?.(acceptedResumingReceipt(taskId, sessionId));
                     for await (const ev of stream) {
                         recordTurnActivity(taskId);
                         fleetPub?.onEvent(ev);
@@ -1832,7 +1828,7 @@ export function createHttpServer(rawDeps) {
                     (e.code === "checkpoint.unsupported_version" && checkpointRowRedeemableElsewhere(e.detail?.reason));
                 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 } };
+                        const c = { taskId, sessionId, terminal: { kind: "failed", code: e.code, message: e.message }, stats: { turns: 0, tokens: 0, usageMissing: true } };
                         await deps.runStore.setTerminal(taskId, "failed", c, e.message).catch((err) => {
                             deps.logger?.warn?.("wake_synthetic_run_release_failed", { taskId, sessionId, errorCode: e.code, error: err instanceof Error ? err.message : String(err), note: "the synthetic run row for this refused fresh-run resume could not be settled — its task_active claim is still held and the next attempt on this session will 409 conflict.session_active_run until reapStale collects it (runStaleSec)" });
                         });
@@ -1987,7 +1983,51 @@ export function createHttpServer(rawDeps) {
         const verifyRounds = verifyRoundsFromBody(ctx.body);
         return driveResumeIntoRunLog({ runner: runnerFor(spec), token, sessionId: cp.sessionId, principal: auth.principal, fleetScope: resumeFleetScope(req, auth), taskConfig, resumeObjective, outcome: { gate: "resource_limit", decision: "continue" }, verifyRounds, ...(engineNotices.length > 0 ? { engineNotices } : {}), ...(acceptEarly === true ? { acceptEarly: true } : {}), ...(req !== undefined ? { callerInitiated: true } : {}) });
     }
-    async function resumeWake(sessionId, message, caller, req, acceptEarly, workflowParkedResume) {
+    async function startFreshHostTurn(sessionId, objective, principal, req, trustedInternals, runId) {
+        const cs = deps.checkpointStore;
+        if (!deps.runStore) {
+            return { status: 501, body: { error: "delivering a workflow decision on the host's next turn requires a durable run store (DB_BACKEND=mysql|pg|local)", errorCode: "capability.run_store_required" } };
+        }
+        const ctx = await cs.getCtx(sessionId).catch(() => null);
+        if (!ctx) {
+            return {
+                status: 409,
+                body: {
+                    error: "the workflow's originating session no longer has the rebuild inputs for a new turn: a session's resume context is garbage-collected once it is stale AND that session itself has no pending checkpoint and no active run (REAP_RUN_STALE_SEC, default 120s) — a workflow CHILD's park does not hold the HOST session's row open. Raise REAP_RUN_STALE_SEC to cover how long approvals may sit before someone decides them, or resume the workflow run yourself with the runId below",
+                    errorCode: "conflict.resume_context_unavailable",
+                    runId,
+                },
+            };
+        }
+        const windowDenial = await usageWindowDenialFor(principal || GLOBAL_USAGE_KEY);
+        if (windowDenial)
+            return { status: windowDenial.status, body: windowDenial.body };
+        const auth = { sessionId, principal, memoryScope: ctx.memoryScope };
+        let spec;
+        let engineNotices = [];
+        try {
+            ({ spec, engineNotices } = await resolveResumeSpec(ctx.body, req, auth));
+        }
+        catch (e) {
+            if (e instanceof HttpError) {
+                return { status: 409, body: { error: `resume blocked by an admission policy change: ${e.message}`, errorCode: "resume_blocked_by_policy", ...(e.code ? { blockedBy: e.code } : {}), ...(e.extra ?? {}) } };
+            }
+            throw e;
+        }
+        const hostSpec = { ...spec, objective, sessionId };
+        const out = await mintAndDriveDurableRun(routeCtxBase, deps.runStore, {
+            prepared: { spec: hostSpec, runner: runnerFor(hostSpec), auth, body: ctx.body, ...(engineNotices.length > 0 ? { engineNotices } : {}) },
+            fleetScope: resumeFleetScope(req, auth),
+            elicitOwner: principal ?? null,
+            source: "workflow_parked_decide",
+            trustedInternals,
+        });
+        if (out.status !== 202)
+            return { status: out.status, body: out.body };
+        const minted = out.body;
+        return acceptedResumingReceipt(minted.taskId, minted.sessionId);
+    }
+    async function resumeWake(sessionId, message, caller, req, acceptEarly, workflowParkedResume, ownerLeaseAdmittedFor) {
         const cs = deps.checkpointStore;
         const wakeBinding = { gateKinds: TERMINAL_PARK_GATE_KINDS, pick: "oldest" };
         const token = (await cs.findPendingTokenBySession(sessionId, undefined, wakeBinding)) ?? (await cs.findPendingTokenBySession(sessionId));
@@ -2058,6 +2098,7 @@ export function createHttpServer(rawDeps) {
             ...(acceptEarly === true ? { acceptEarly: true } : {}),
             ...(req !== undefined ? { callerInitiated: true } : {}),
             ...(workflowParkedResume !== undefined ? { workflowParkedResume } : {}),
+            ...(ownerLeaseAdmittedFor !== undefined && auth.principal === ownerLeaseAdmittedFor ? { ownerLeaseAdmitted: true } : {}),
         });
     }
     async function resumePlanReview(sessionId, decision, editedPlan, reason, req, log, acceptEarly, decider) {
@@ -2222,27 +2263,32 @@ export function createHttpServer(rawDeps) {
         sendError(res, 429, "quota_exhausted", "budget exhausted (quota lease)", { retryAfterSec: adm.retryAfterSec, ...(adm.detail ?? {}) });
         return true;
     }
-    async function usageWindowDenied(req, res) {
+    async function usageWindowDenialFor(key) {
         const store = deps.usageWindowStore;
         const windows = deps.config.usageWindows;
         if (!store || !windows || windows.length === 0)
-            return false;
-        const key = gatedPrincipal(req, deps.config) || GLOBAL_USAGE_KEY;
+            return undefined;
         let retryAfterMs;
         try {
             retryAfterMs = usageRetryAfterMs(await store.read(key, windows, Date.now()));
         }
         catch (e) {
             deps.logger?.warn?.("usage_window_admission_read_failed", { error: e instanceof Error ? e.message : String(e) });
-            return false;
+            return undefined;
         }
         if (retryAfterMs === undefined)
-            return false;
+            return undefined;
         deps.metrics?.inc("usage_window_rejected_total");
         deps.logger?.info?.("usage_window_exhausted", { hasPrincipal: key !== GLOBAL_USAGE_KEY, retryAfterMs });
         const retryAfterSec = Math.max(1, Math.ceil(retryAfterMs / 1000));
-        res.setHeader("retry-after", String(retryAfterSec));
-        sendError(res, 429, "usage.window_exhausted", "usage window exhausted (deployment token governance)", { retryAfterSec });
+        return { status: 429, body: { error: "usage window exhausted (deployment token governance)", errorCode: "usage.window_exhausted", retryAfterSec }, retryAfterSec };
+    }
+    async function usageWindowDenied(req, res) {
+        const denial = await usageWindowDenialFor(gatedPrincipal(req, deps.config) || GLOBAL_USAGE_KEY);
+        if (!denial)
+            return false;
+        res.setHeader("retry-after", String(denial.retryAfterSec));
+        sendError(res, denial.status, denial.body.errorCode, denial.body.error, { retryAfterSec: denial.retryAfterSec });
         return true;
     }
     function rateLimited(req, res) {

package/dist/main.js

@@ -8,6 +8,7 @@ import { selectEnvironmentTool } from "./capabilities/select-environment-tool.js
 import { subagentSendUserFileExtraTools } from "./capabilities/send-user-file-tool.js";
 import { brainSummary } from "./brain.js";
 import { loadConfig, logConfigDiagnostics, resolveBindHost, splitLocalRoots, parseCapEnv, parseNumOrFailNonNegative } from "./config.js";
+import { createUnpricedCeilingVerdict } from "./boot/unpriced-ceiling-verdict.js";
 import { buildWriteProtectionPosture } from "./write-protection.js";
 import { cardRuleScopeRoot } from "./task-cwd.js";
 import { isPricingConfigured } from "./budget.js";
@@ -129,6 +130,8 @@ async function main() {
     }
     const configCenter = await createConfigCenterRuntime({ config, logger, metrics, localRoot });
     await configCenter.applyLocalRemoteExec();
+    const ceilingVerdict = createUnpricedCeilingVerdict({ config, logger });
+    ceilingVerdict.judge();
     const { backend, storeBackendDegraded, memoryEngine, memorySyncCursors, rosterStore, backgroundAgentStore, taskAttachmentStore, mailboxStore, memoryExportBackend, memorySyncRunner, sessionStore, breakerState, usageWindowStore, memoryPosture, taskListLane, sqlEngineFacts, } = await openStores({ config, logger, metrics, localRoot });
     const instanceId = uuidv7();
     const sessionCaptureRecords = backend?.sessionCaptureRecords();
@@ -561,7 +564,7 @@ async function main() {
             }
         }
     };
-    configCenter.startRefreshLoop({ runnerTierFrozen, pricing, limitSync, swapRunnerDeps });
+    configCenter.startRefreshLoop({ runnerTierFrozen, pricing, limitSync, swapRunnerDeps, ceilingVerdict });
     configCenter.initKeyResolver();
     const { ownerAware, sessionAudit, sessionWatchRegistry, purgeSession, instrumentDegenerate, planCacheProbe } = createSessionFaces({
         deviceStore: deviceLane?.store,

package/dist/memory-bundle-engine.d.ts

@@ -53,9 +53,10 @@ export interface MemoryBundleFaces {
 /**
  * 在**已装配的记忆后端**上建 bundle 两面。命名照 CLAUDE.md 工厂律:返回的是带行为的活对象 ⇒ `create*`。
  *
- * `memoryDir` = `boot/stores.ts` 的 `memoryEngine.root`(该部署的记忆工作根)。见文件头:这两条路径
- * 不读它,传它是为了不发明第二个「引擎根」的概念 —— 万一 core 日后真用上,它拿到的也是本部署唯一的
- * 那个根,而不是一个本模块凭空编出来的路径。
+ * `memoryDir` = 引擎的**挂载平面**(`memoryMountRootOf(backend, root)` 单铸点;全仓自构引擎同一条规则,
+ * 由 `test/memory-layout-plane.test.ts` 的归一门咬住)。见文件头:这两条路径**不读它**(机器钉在
+ * `test/memory-bundle-engine.test.ts`:给一个不存在的 `memoryDir` 也照样工作),传对的那一只是为了
+ * 万一 core 日后真用上时,它拿到的是本部署真正的挂载平面,而不是高一层的配置根。
  */
 export declare function createMemoryBundleFaces(store: {
     backend: MemoryBackend;

package/dist/memory-bundle-engine.js

@@ -1,9 +1,10 @@
 import { MemoryEngine } from "@sema-agent/core";
+import { memoryMountRootOf } from "./memory-scope.js";
 export function createMemoryBundleFaces(store, opts) {
     const b = store.backend;
     if (typeof b.exportSnapshotOf !== "function" || typeof b.importBundleCommit !== "function")
         return undefined;
-    const engine = new MemoryEngine({ backend: store.backend, memoryDir: store.root, ...(opts?.captureRecordStore !== undefined ? { captureRecordStore: opts.captureRecordStore } : {}) });
+    const engine = new MemoryEngine({ backend: store.backend, memoryDir: memoryMountRootOf(store.backend, store.root), ...(opts?.captureRecordStore !== undefined ? { captureRecordStore: opts.captureRecordStore } : {}) });
     return {
         exportScopes: (scopes) => engine.exportMemoryScopes(scopes),
         importBundle: (bundle, opts) => engine.importMemoryBundle(bundle, opts),