@sema-agent/server 7.71.0 → 7.72.0

package/dist/config.js

@@ -9,7 +9,7 @@ import { DEFAULT_ELICITATION_THROTTLE } from "./elicitation.js";
 import { isV2ScopeKey } from "./memory-scope.js";
 import { DEFAULT_QUESTION_THROTTLE } from "./question.js";
 import { GIT_API_KINDS, isGitApiKind } from "./git-api-kind.js";
-import { RETENTION_MODES, MEMORY_CONSOLIDATION_MIN_INTERVAL_SEC, MODEL_FIRST_TOKEN_TIMEOUT_MS_DEFAULT } from "./config-types.js";
+import { RETENTION_MODES, MEMORY_CONSOLIDATION_MIN_INTERVAL_SEC, RESILIENCE_DEFAULTS } from "./config-types.js";
 import { buildWriteProtectionPosture } from "./write-protection.js";
 import { normalizeSshFingerprint } from "./ssh-host-key.js";
 import { readFaceForPosture } from "./read-face-posture.js";
@@ -260,16 +260,53 @@ function numEnvOr(name, fallback) {
         return fallback;
     return parseNumOrFail(name, raw);
 }
-function cheapCostEnv(name, mainPrice) {
+function costEnv(name, emptyString) {
     const raw = process.env[name];
     if (raw === undefined)
-        return mainPrice;
+        return undefined;
     if (raw === "") {
+        if (emptyString === "unset")
+            return undefined;
         CONFIG_WARNINGS.push({ env: name, raw: "", used: "0", kind: "empty-preserved" });
         return 0;
     }
     return parseNumOrFail(name, raw);
 }
+function buildCostOrAbsent(read, inherited) {
+    const declared = read.input !== undefined || read.output !== undefined || read.cacheRead !== undefined || read.cacheWrite !== undefined;
+    if (!declared && inherited === undefined)
+        return undefined;
+    return {
+        input: read.input ?? inherited?.input ?? 0,
+        output: read.output ?? inherited?.output ?? 0,
+        cacheRead: read.cacheRead ?? inherited?.cacheRead ?? 0,
+        cacheWrite: read.cacheWrite ?? inherited?.cacheWrite ?? 0,
+    };
+}
+export function buildModelCostKey(cost) {
+    return (cost === undefined ? {} : { cost });
+}
+export function buildUnpricedCeilingNotice(models, limits) {
+    const ceilings = [
+        ...(limits.maxTaskCostUsd > 0 ? ["MAX_TASK_COST_USD"] : []),
+        ...(limits.maxPrincipalCostUsd > 0 ? ["MAX_PRINCIPAL_COST_USD"] : []),
+    ];
+    const entries = Object.values(models);
+    if (ceilings.length === 0 || entries.length === 0 || entries.some((m) => m.cost !== undefined))
+        return undefined;
+    return {
+        event: "cost_ceiling_without_pricing",
+        fields: {
+            ceilings: ceilings.join(","),
+            models: [...new Set(entries.map((m) => m.id))].join(","),
+            note: `${ceilings.join(" / ")} is configured but NO model in the effective catalog declares a price table — an ` +
+                "unpriced model reports NO cost at all (core RB-368), so these $ ceilings can never fire and this deployment " +
+                "has no cost guardrail despite looking like it does. Set MODEL_COST_INPUT / MODEL_COST_OUTPUT / " +
+                "MODEL_COST_CACHE_READ / MODEL_COST_CACHE_WRITE (env lane), or a per-model `cost` on the center roster row. " +
+                "The token ceiling (MAX_TASK_TOKENS) is unaffected and still fires.",
+        },
+    };
+}
 function optNumEnvStrict(name) {
     const raw = process.env[name];
     if (!raw)
@@ -753,12 +790,12 @@ function parseModelDomain() {
         baseUrl: "",
         reasoning: boolEnv("MODEL_REASONING", true),
         input: boolEnv("MODEL_VISION", true) ? ["text", "image"] : ["text"],
-        cost: {
-            input: numEnv("MODEL_COST_INPUT", "0"),
-            output: numEnv("MODEL_COST_OUTPUT", "0"),
-            cacheRead: numEnv("MODEL_COST_CACHE_READ", "0"),
-            cacheWrite: numEnv("MODEL_COST_CACHE_WRITE", "0"),
-        },
+        ...buildModelCostKey(buildCostOrAbsent({
+            input: costEnv("MODEL_COST_INPUT", "unset"),
+            output: costEnv("MODEL_COST_OUTPUT", "unset"),
+            cacheRead: costEnv("MODEL_COST_CACHE_READ", "unset"),
+            cacheWrite: costEnv("MODEL_COST_CACHE_WRITE", "unset"),
+        }, undefined)),
         contextWindow: numEnv("MODEL_CONTEXT_WINDOW", "262144"),
         maxTokens: process.env.MODEL_MAX_TOKENS !== undefined && process.env.MODEL_MAX_TOKENS !== ""
             ? parseNumOrFail("MODEL_MAX_TOKENS", process.env.MODEL_MAX_TOKENS)
@@ -776,12 +813,12 @@ function parseModelDomain() {
             id: cheapId,
             name: cheapId,
             input: ((v) => (v === undefined ? model.input : v ? ["text", "image"] : ["text"]))(parseBoolWord("MODEL_CHEAP_VISION", process.env.MODEL_CHEAP_VISION)),
-            cost: {
-                input: cheapCostEnv("MODEL_CHEAP_COST_INPUT", model.cost.input),
-                output: cheapCostEnv("MODEL_CHEAP_COST_OUTPUT", model.cost.output),
-                cacheRead: cheapCostEnv("MODEL_CHEAP_COST_CACHE_READ", model.cost.cacheRead),
-                cacheWrite: cheapCostEnv("MODEL_CHEAP_COST_CACHE_WRITE", model.cost.cacheWrite),
-            },
+            ...buildModelCostKey(buildCostOrAbsent({
+                input: costEnv("MODEL_CHEAP_COST_INPUT", "declares-zero"),
+                output: costEnv("MODEL_CHEAP_COST_OUTPUT", "declares-zero"),
+                cacheRead: costEnv("MODEL_CHEAP_COST_CACHE_READ", "declares-zero"),
+                cacheWrite: costEnv("MODEL_CHEAP_COST_CACHE_WRITE", "declares-zero"),
+            }, model.cost)),
             contextWindow: numEnvOr("MODEL_CHEAP_CONTEXT_WINDOW", model.contextWindow),
             maxTokens: numEnvOr("MODEL_CHEAP_MAX_TOKENS", model.maxTokens),
             ...(optFinitePositiveEnv("MODEL_CHEAP_CHARS_PER_TOKEN") !== undefined ? { charsPerToken: optFinitePositiveEnv("MODEL_CHEAP_CHARS_PER_TOKEN") } : {}),
@@ -855,12 +892,12 @@ function parseModelDomain() {
             }
             : undefined,
         resilience: {
-            connectTimeoutMs: numEnv("MODEL_CONNECT_TIMEOUT_MS", "30000"),
-            firstTokenTimeoutMs: numEnv("MODEL_FIRST_TOKEN_TIMEOUT_MS", String(MODEL_FIRST_TOKEN_TIMEOUT_MS_DEFAULT)),
-            idleTimeoutMs: numEnv("MODEL_IDLE_TIMEOUT_MS", "300000"),
-            circuitBreaker: boolEnv("MODEL_CIRCUIT_BREAKER", false),
-            failureThreshold: numEnv("MODEL_CB_FAILURE_THRESHOLD", "5"),
-            cooldownMs: numEnv("MODEL_CB_COOLDOWN_MS", "30000"),
+            connectTimeoutMs: numEnv("MODEL_CONNECT_TIMEOUT_MS", String(RESILIENCE_DEFAULTS.connectTimeoutMs.value)),
+            firstTokenTimeoutMs: numEnv("MODEL_FIRST_TOKEN_TIMEOUT_MS", String(RESILIENCE_DEFAULTS.firstTokenTimeoutMs.value)),
+            idleTimeoutMs: numEnv("MODEL_IDLE_TIMEOUT_MS", String(RESILIENCE_DEFAULTS.idleTimeoutMs.value)),
+            circuitBreaker: boolEnv("MODEL_CIRCUIT_BREAKER", RESILIENCE_DEFAULTS.circuitBreaker.value),
+            failureThreshold: numEnv("MODEL_CB_FAILURE_THRESHOLD", String(RESILIENCE_DEFAULTS.failureThreshold.value)),
+            cooldownMs: numEnv("MODEL_CB_COOLDOWN_MS", String(RESILIENCE_DEFAULTS.cooldownMs.value)),
         },
         model,
         envModel: model,

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";
@@ -22,12 +19,12 @@ import { ASK_DECISION_CONSUMER_ABSENT, resolveStreamApprovalGate } from "../../t
 import { MAX_DECISION_NOTE_CHARS } from "../../approval-ask-machine.js";
 import { normalizeRunEventType } 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)?$/;
@@ -1559,58 +1556,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,48 @@ 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 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 +2095,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) {

package/dist/main.js

@@ -7,7 +7,7 @@ import { posIntEnv } from "./session-watch.js";
 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 { buildUnpricedCeilingNotice, loadConfig, logConfigDiagnostics, resolveBindHost, splitLocalRoots, parseCapEnv, parseNumOrFailNonNegative } from "./config.js";
 import { buildWriteProtectionPosture } from "./write-protection.js";
 import { cardRuleScopeRoot } from "./task-cwd.js";
 import { isPricingConfigured } from "./budget.js";
@@ -129,6 +129,9 @@ async function main() {
     }
     const configCenter = await createConfigCenterRuntime({ config, logger, metrics, localRoot });
     await configCenter.applyLocalRemoteExec();
+    const unpricedCeiling = buildUnpricedCeilingNotice(config.models, config);
+    if (unpricedCeiling)
+        logger.warn(unpricedCeiling.event, unpricedCeiling.fields);
     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();

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

@@ -19,7 +19,7 @@ export declare const FAIL_OPEN_TAGS: {
     };
     readonly "server.trace.gate-outcome-defective": {
         readonly cls: "F";
-        readonly note: "S-136(core 7.6.0 design/390 S6-A,`trace/project.ts` 的 `screenedGate`,写腿与两条读腿共用):一条 `tool_end` / 账本行携带的 `GateOutcome` 过不了 core 的 `screenGateOutcome`(I1–I4 不变量,或某一格词出闭集)⇒ **整条 gate 记录不上帧**(report + withhold,core 契约逐字给出的两种响亮形之一;绝不「静默修补」成一条自洽的记录)。放行的最坏后果=这一帧的消费端渲染不出「谁拒的 / 那次等待怎么结束的」,退回到 `isError` + 文案;它**不改变任何裁决**(门早已在 core 里判完,这里只是观测面)。反方向(把一条自相矛盾的记录照发)更坏:消费端按 I2/I3 读出来的结论会是假的。计数让「某个世代的产生者一直在发坏记录」显形。";
+        readonly note: "S-136(core 7.6.0 design/390 S6-A,`trace/project.ts` 的 `screenedGate`:写腿 `toolEndEventData` 直用;两条耐久读腿(账本回放 `toolResultFieldsOf` / `/decide` 幂等回放 `executionOutcome`)经 `screenedStoredGate` 认过退役词旧拼法后同走这一只筛):一条 `tool_end` / 账本行携带的 `GateOutcome` 过不了 core 的 `screenGateOutcome`(I1–I4 不变量,或某一格词出闭集)⇒ **整条 gate 记录不上帧**(report + withhold,core 契约逐字给出的两种响亮形之一;绝不「静默修补」成一条自洽的记录)。放行的最坏后果=这一帧的消费端渲染不出「谁拒的 / 那次等待怎么结束的」,退回到 `isError` + 文案;它**不改变任何裁决**(门早已在 core 里判完,这里只是观测面)。反方向(把一条自相矛盾的记录照发)更坏:消费端按 I2/I3 读出来的结论会是假的。计数让「某个世代的产生者一直在发坏记录」显形。";
     };
     readonly "server.trace.tool-roster-malformed": {
         readonly cls: "F";

package/dist/observability/fail-open.js

@@ -10,7 +10,7 @@ export const FAIL_OPEN_TAGS = {
     },
     "server.trace.gate-outcome-defective": {
         cls: "F",
-        note: "S-136(core 7.6.0 design/390 S6-A,`trace/project.ts` 的 `screenedGate`,写腿与两条读腿共用):一条 `tool_end` / 账本行携带的 `GateOutcome` 过不了 core 的 `screenGateOutcome`(I1–I4 不变量,或某一格词出闭集)⇒ **整条 gate 记录不上帧**(report + withhold,core 契约逐字给出的两种响亮形之一;绝不「静默修补」成一条自洽的记录)。放行的最坏后果=这一帧的消费端渲染不出「谁拒的 / 那次等待怎么结束的」,退回到 `isError` + 文案;它**不改变任何裁决**(门早已在 core 里判完,这里只是观测面)。反方向(把一条自相矛盾的记录照发)更坏:消费端按 I2/I3 读出来的结论会是假的。计数让「某个世代的产生者一直在发坏记录」显形。",
+        note: "S-136(core 7.6.0 design/390 S6-A,`trace/project.ts` 的 `screenedGate`:写腿 `toolEndEventData` 直用;两条耐久读腿(账本回放 `toolResultFieldsOf` / `/decide` 幂等回放 `executionOutcome`)经 `screenedStoredGate` 认过退役词旧拼法后同走这一只筛):一条 `tool_end` / 账本行携带的 `GateOutcome` 过不了 core 的 `screenGateOutcome`(I1–I4 不变量,或某一格词出闭集)⇒ **整条 gate 记录不上帧**(report + withhold,core 契约逐字给出的两种响亮形之一;绝不「静默修补」成一条自洽的记录)。放行的最坏后果=这一帧的消费端渲染不出「谁拒的 / 那次等待怎么结束的」,退回到 `isError` + 文案;它**不改变任何裁决**(门早已在 core 里判完,这里只是观测面)。反方向(把一条自相矛盾的记录照发)更坏:消费端按 I2/I3 读出来的结论会是假的。计数让「某个世代的产生者一直在发坏记录」显形。",
     },
     "server.trace.tool-roster-malformed": {
         cls: "F",

package/dist/observability/metrics.js

@@ -263,7 +263,7 @@ export function createMetrics() {
     m.counter("stale_cache_conflict_total", "Warm session-cache entries evicted by a cross-instance write while cached (S25)");
     m.counter("breaker_writethrough_failed_total", "Circuit-breaker cross-replica write-through failures (LOW), by backend");
     m.counter("web_search_bad_payload_total", "Web-search provider responses whose results field was not an array (LOW), by provider");
-    m.counter("auto_mode_classifier_unavailable_total", "Auto-mode gate denials caused by a classifier OUTAGE, by cause (core AUTO_MODE_UNAVAILABLE_CAUSES: error/timeout; 'other' = this build cannot name the word). Distinct from permission_denied_total{deniedBy=\"classifier\"}, which also counts genuine safety blocks — a spike here means the classifier itself is failing (gateway/credential fault, or too slow), not that the model kept asking for dangerous things");
+    m.counter("auto_mode_classifier_deny_cause_total", "Auto-mode gate denials where the classifier did NOT rule, by the FORM of the deny (core CLASSIFIER_DENY_CAUSES on GateDisposition.cause: 'unavailable' = the classifier could not run at all (threw/rejected/ran past the cap — retryable), 'parse_error' = it ran but answered outside its verdict contract (blocked for safety); 'other' = this build cannot name the word). 🔴 BREAKING in server 7.72.0: this counter was named auto_mode_classifier_unavailable_total through 7.71.0 and is RENAMED with NO alias (a counter that also counts parse_error is not an 'unavailable' counter); its label vocabulary was 'error'/'timeout' (WHY it was unavailable) — those two collapsed into 'unavailable' (the WHY now rides the deny sentence and the auto_mode.classified trace frame), and 'parse_error' is a bucket the old counter could not see, so by-cause series do NOT splice across the upgrade. Distinct from permission_denied_total{deniedBy=\"classifier\"}, which also counts genuine safety blocks (the classifier's own <block> ruling carries NO cause) — a spike here means the classifier itself is not working (gateway/credential fault, too slow, or answering off-contract), not that the model kept asking for dangerous things");
     m.counter("permission_denied_total", "Tool-gate denials by the LAYER whose verdict is the deny (core's DeniedBy: policy/hook/org/classifier/plan_mode/compliance/write_protection/ask_resolution/persisted_rule; 'other' = this build cannot name the layer; label is `deniedBy` since server 7.64.0 — it was `source` over core's retired PermissionDeniedSource; goal B4 always-on deny meter)");
     m.counter("permission_rule_events_total", buildPermissionRuleEventsHelp());
     m.counter("compaction_events_total", "Compaction lifecycle events by outcome (started/completed/failed/skipped) and trigger");