@sema-agent/server 7.70.0 → 7.72.0

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

@@ -3,7 +3,7 @@ import { redactErrorMessage, redactHead } from "../observability/run-terminal-lo
 import { once } from "node:events";
 import { createHash } from "node:crypto";
 import { uuidv7, isThinkingLevel, expandTiers, resumeWithVerification, CheckpointError, defaultTaskRegistry, validatePendingSteer, subscribeWorkflow, GLOBAL_USAGE_KEY, usageRetryAfterMs, terminalProjection, PAUSE_REGISTRY } from "@sema-agent/core";
-import { decideParkedAgent, findParkOrigin, planWorkflowParkedDecide } from "../parked-decide.js";
+import { decideParkedAgent, denyWorkflowParkIdentityLost, findParkOrigin, planWorkflowParkedDecide } from "../parked-decide.js";
 import { isModelAllowlisted, matchCatalogModel } from "../model-select.js";
 import {} from "../config-center/facade.js";
 import { HttpError, principalFrom, verifiedPrincipal, setSsoPrincipal, ssoVerifiedPrincipal, setSsoScope, isUuidV7, isDestructiveSessionWrite, decodeCheckpointScope, CHECKPOINT_PUBLIC_SCOPE, PRINCIPAL_TOKEN_HEADER, APPROVAL_MAC_HEADER, APPROVAL_MAC_KID_HEADER } from "../security.js";
@@ -33,7 +33,7 @@ import { TERMINAL_PARK_GATE_KINDS } from "../plugins/checkpoint-store-sql.js";
 import { createWallClockJumpGuard } from "../wall-clock-jump-guard.js";
 import {} from "../observability/rate-limit.js";
 import { withPrincipal } from "../observability/principal-context.js";
-import { turnEndEventData, contextUsageEventData, toolStartEventData, toolEndEventData, taskProgressEventData, taskNotificationEventData, compactedEventData, diagnosticsEventData, brainStatusEventData, steeringInjectedEventData, compactionOutcomeEventData, workspaceChangedEventData, wiringManifestEventData, humanInputEventData, appendModelUsageDelta, appendPromptManifest, attachModelUsage } from "../trace/project.js";
+import { turnEndEventData, contextUsageEventData, toolStartEventData, toolEndEventData, taskProgressEventData, taskNotificationEventData, compactedEventData, diagnosticsEventData, brainStatusEventData, steeringInjectedEventData, compactionOutcomeEventData, workspaceChangedEventData, wiringManifestEventData, toolRosterDeltaEventData, humanInputEventData, appendModelUsageDelta, appendPromptManifest, attachModelUsage } from "../trace/project.js";
 import { redactSecrets } from "../trace/redact.js";
 import { createLedgerSink, createSerialLedgerAppend } from "../trace/ledger-sink.js";
 import { registerEngineNoticeLeg } from "../trace/engine-notice-wire.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";
@@ -85,6 +87,7 @@ export { coarseStatusForState, errorCodeForExit };
 import { sendJson, sendError, httpErrorCode, msg, isSseResponse } from "./send.js";
 import { authorized, systemFor, gatedPrincipal, explicitOperatorOk, isOperator } from "./principal-gate.js";
 import { buildActiveRunConflict, resumeEntryForGate } from "./active-run-conflict.js";
+import { ASK_USER_QUESTION_TOOL_NAME } from "../approval-content-kind.js";
 export { explicitOperatorOk, isOperator };
 export function flattenServiceDeps(deps) {
     const { stores, coordinators, seams, observability, governance, deployment, knobs, ...flat } = deps;
@@ -1143,7 +1146,7 @@ export function createHttpServer(rawDeps) {
             };
         }
         const paForGrant = cp.pendingAction.kind === "tool_approval" ? cp.pendingAction : undefined;
-        const loadedGrantTool = paForGrant !== undefined && paForGrant.toolName && paForGrant.toolName !== "AskUserQuestion"
+        const loadedGrantTool = paForGrant !== undefined && paForGrant.toolName && paForGrant.toolName !== ASK_USER_QUESTION_TOOL_NAME
             ? paForGrant.toolName
             : null;
         const boundGrant = onResumeCommitted
@@ -1208,27 +1211,23 @@ export function createHttpServer(rawDeps) {
                 noteLateSettleIfAccepted(parked);
                 return parked;
             }
+            if (origin?.kind === "workflow_identity_lost") {
+                void ctxPromise.catch(() => { });
+                return denyWorkflowParkIdentityLost(origin);
+            }
             if (origin?.kind === "workflow") {
                 void ctxPromise.catch(() => { });
                 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;
@@ -1256,10 +1255,10 @@ export function createHttpServer(rawDeps) {
             throw e;
         }
         const pendingTool = cp.pendingAction.toolName;
-        if (decision === "approve" && pendingTool === "AskUserQuestion" && !answer) {
+        if (decision === "approve" && pendingTool === ASK_USER_QUESTION_TOOL_NAME && !answer) {
             return { status: 400, body: { error: "pending action is AskUserQuestion — approve must carry body.answer ({ answers: [{ header, selected: string[], note? }] })", errorCode: "request.field_conflict" } };
         }
-        if (answer && (decision !== "approve" || pendingTool !== "AskUserQuestion")) {
+        if (answer && (decision !== "approve" || pendingTool !== ASK_USER_QUESTION_TOOL_NAME)) {
             return { status: 400, body: { error: `body.answer is only valid when approving a pending AskUserQuestion (decision: "${decision}", pending: "${pendingTool ?? "unknown"}")`, errorCode: "request.field_conflict" } };
         }
         const { objective: resumeObjective, sessionId: _sessionId, ...taskConfig } = spec;
@@ -1281,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) {
@@ -1633,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);
@@ -1691,6 +1692,13 @@ export function createHttpServer(rawDeps) {
                                 await flush();
                                 await append("wiring_manifest", wiringManifestEventData(ev));
                                 break;
+                            case "tool_roster_delta": {
+                                await flush();
+                                const rosterDelta = toolRosterDeltaEventData(ev);
+                                if (rosterDelta !== undefined)
+                                    await append("tool_roster_delta", rosterDelta);
+                                break;
+                            }
                             case "human_input":
                                 await flush();
                                 await append("human_input", humanInputEventData(ev));
@@ -1820,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)" });
                         });
@@ -1975,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));
@@ -2046,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/index.d.ts

@@ -1,7 +1,7 @@
 export { loadConfig, type ServiceConfig } from "./config.js";
 export { createBrain } from "./brain.js";
 export { createSessionStore } from "./plugins/session-store.js";
-export { createStoreBackend, type StoreBackend } from "./plugins/store-backend.js";
+export { createStoreBackend, type StoreBackend, type SessionCaptureRecordSource } from "./plugins/store-backend.js";
 export { CachingSessionStore, type CachingOptions } from "./plugins/caching-session-store.js";
 export type { RunRecord, RunEvent } from "./plugins/store-contracts.js";
 export { runInBackground } from "./runs.js";

package/dist/leader/wire.js

@@ -6,6 +6,7 @@ import { join } from "node:path";
 import { tmpdir } from "node:os";
 import { Runner, combinePolicies, createDurableQuestionPolicy, QUESTION_AWAITS_RESUME, delimitUntrusted, hasDestroy, } from "@sema-agent/core";
 import { RemoteContainerExecutionEnv } from "../plugins/remote-env-e2b.js";
+import { E2B_SANDBOX_HOME } from "../execution-lane-caps.js";
 import { createDurableAskPolicy } from "../approval.js";
 import { presignS3Url } from "../plugins/s3-presign.js";
 import { buildUploadScript, uploadStepSuffix, fetchUploadedDiff, withStaging } from "./diffup.js";
@@ -376,7 +377,7 @@ export function createLeaderRunner(cfg) {
             }
             if (!cfg.e2bApiKey)
                 throw new Error("leader wire: no envFactory+s3 (factory mode) and no e2bApiKey (static mode)");
-            const env = new RemoteContainerExecutionEnv({ apiKey: cfg.e2bApiKey, timeoutMs: leaderTimeoutMs });
+            const env = new RemoteContainerExecutionEnv({ apiKey: cfg.e2bApiKey, timeoutMs: leaderTimeoutMs, homeDir: E2B_SANDBOX_HOME });
             if (!(await env.connect()).ok)
                 throw new Error(`connect failed for ${sub.workerId}`);
             await sh(env)(`${body.seedCmd}; cd ${repo}; git checkout -q -b ${sub.branch}`);
@@ -410,7 +411,7 @@ export function createLeaderRunner(cfg) {
             }
             if (!cfg.e2bApiKey)
                 throw new Error("leader wire: no envFactory and no e2bApiKey");
-            const env = new RemoteContainerExecutionEnv({ apiKey: cfg.e2bApiKey, timeoutMs: leaderTimeoutMs });
+            const env = new RemoteContainerExecutionEnv({ apiKey: cfg.e2bApiKey, timeoutMs: leaderTimeoutMs, homeDir: E2B_SANDBOX_HOME });
             if (!(await env.connect()).ok) {
                 await env.destroy().catch(() => { });
                 throw new Error("integ connect failed");
@@ -449,7 +450,7 @@ export function createLeaderRunner(cfg) {
             else {
                 if (!cfg.e2bApiKey)
                     throw new Error("leader wire: repair-loop grader needs an envFactory or e2bApiKey");
-                const e2b = new RemoteContainerExecutionEnv({ apiKey: cfg.e2bApiKey, timeoutMs: leaderTimeoutMs });
+                const e2b = new RemoteContainerExecutionEnv({ apiKey: cfg.e2bApiKey, timeoutMs: leaderTimeoutMs, homeDir: E2B_SANDBOX_HOME });
                 if (!(await e2b.connect()).ok) {
                     await e2b.destroy().catch(() => { });
                     throw new Error("repair-loop grader connect failed");

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,9 +129,13 @@ 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 sessionCaptureRecordStore = backend?.sessionCaptureRecords();
+    const sessionCaptureRecords = backend?.sessionCaptureRecords();
+    const sessionCaptureRecordStore = sessionCaptureRecords?.();
     const memoryBundleFaces = memoryEngine ? createMemoryBundleFaces(memoryEngine, { ...(sessionCaptureRecordStore !== undefined ? { captureRecordStore: sessionCaptureRecordStore } : {}) }) : undefined;
     const memoryComplianceFaces = memoryEngine
         ? createMemoryComplianceFaces(memoryEngine, {
@@ -271,7 +275,7 @@ async function main() {
         sessionShellGateExplicitlyOff: sessionShellGateRegistry.explicitlyOff,
         config, logger, metrics, localRoot, promptSource: configCenter.promptSource, rosterStore, backgroundAgentStore, mailboxStore, usageWindowStore, brain,
         pricing, tracer, outcomeSink, elicitation, question, toolApproval, sessionStore, memoryEngine,
-        sessionCaptureRecordStore,
+        sessionCaptureRecords,
         memorySyncRunner, toolResultStore: runnerOffloadStore, checkpointStore, sessionPolicyStore, runtimeCapsResolver, fileHistoryStore,
         legacyRewindBoundaryProbe: backend?.legacyRewindBoundaryProbe ? backend.legacyRewindBoundaryProbe.bind(backend) : undefined,
         permissionRuleStore: permissionRuleProvider,
@@ -330,6 +334,7 @@ async function main() {
     const subRunnerSessions = new ForkRoutingSessionStore(sessionStore, new TtlSessionStore({ defaultTtlDays: 1 / 24 }));
     const subRunnerDeps = {
         ...createSharedRunnerDeps({
+            metrics,
             config,
             logger,
             hands: commitHands,

package/dist/memory-operator-faces.d.ts

@@ -227,7 +227,7 @@ export interface SessionMemoryStatusFace {
  *
  * `captureRecordStore` = [ref]② 的 SQL 载体(main.ts 单实例,与 Runner/其余引擎同源 —— 全站同批注入律,
  * 机器钉 capture-optout-lane ②):`captureOptedOut` / `optOutSource` 两键经它读,多副本部署上答的才是
- * 跨副本的真记录。缺席(local 车道)⇒ core 文件三腿,单机字节不变。
+ * 跨副本的真记录。S-215 起 local 车道在引擎接线时也供(core 文件三腿,同一只控制面,单机字节不变);缺席 ⇒ 记忆面暗。
  *
  * 面**不抛**(core 契约:sessionMemoryStatus never throws —— 每个事实源各自 catch 折缺席键);
  * 不接 onIncident:这条只读路径上今天零 sink 站点,而且缺席键本身就是它的披露形。

package/dist/memory-scope.d.ts

@@ -104,6 +104,30 @@ export declare function memoryEngineRootFor(config: Pick<ServiceConfig, "memoryE
  *  所以它的根必须走这条链而不是 `memoryEngineRootFor` 的分派(codex 修复验证轮 [medium]:分派会把 run-local 的
  *  记忆搬到 `<localDataRoot>/memory-work`,存量记忆与控制面升级后隐形)。 */
 export declare function fileMemoryEngineRoot(config: Pick<ServiceConfig, "memoryEngineDir">, fallbackRoot?: string): string;
+/** 本部署 file 记忆引擎的**平面三坐标**(根 / 记忆目录 / 控制面目录)—— {@link fileMemoryPlaneFor} 一次算齐。 */
+export interface FileMemoryPlane {
+    readonly root: string;
+    readonly memoryDir: string;
+    readonly controlDir: string;
+}
+/**
+ * S-215(B-085)—— **file 记忆引擎平面的单铸点**,兼这条腿的**接线门**。
+ *
+ * 为什么是一只函数而不是两处各自推导:平面坐标有**两个**消费者 —— ① {@link memoryEngineBackendFor}
+ * 钉给 `FileMemoryEngineBackend` 的 `memoryDir` + `controlDir`;② local 车道的 capture opt-out **记录店**
+ * (`StoreBackend.sessionCaptureRecords()` 喂 core 的 `fileSessionCaptureRecordStore(controlDir)`)。
+ * 两者必须是**同一只目录**,否则声明写进 A、引擎读 B ⇒ 一条被「受理」的隐私声明在引擎面根本不存在,
+ * 那比一句诚实的 409 更坏。两处各写一份推导链 = 哪天根链改了只改一处的必然漂移,所以推导(根 → 记忆目录 →
+ * 控制面目录,三步都在这里、只写一遍)与门合并在此(合并复审 R37:此前 `join(root, "memory")` 在本函数与
+ * `memoryEngineBackendFor` 各写一份 —— 记忆目录规则有了第二个写者,现已收回一处)。
+ *
+ * 返回 `undefined` ⇔ 本部署上 file 记忆引擎**不接线**(多租户 / `MEMORY_ENGINE=off` / 平面分裂车道未 allow)。
+ * 门与 `memoryEngineBackendFor` 逐字同源(它就读本函数),所以「有引擎 ⇔ 有控制面 ⇔ 供记录店」三者
+ * 在构造上不可能分家。
+ */
+export declare function fileMemoryPlaneFor(config: ServiceConfig, fallbackRoot?: string): FileMemoryPlane | undefined;
+/** 控制面目录那一坐标(local 车道 capture 记录店的依托)—— 只是 {@link fileMemoryPlaneFor} 的投影,不是第二条推导。 */
+export declare function fileMemoryControlDirFor(config: ServiceConfig, fallbackRoot?: string): string | undefined;
 export declare function memoryEngineBackendFor(config: ServiceConfig, fallbackRoot?: string): {
     backend: FileMemoryEngineBackend;
     root: string;

package/dist/memory-scope.js

@@ -68,14 +68,23 @@ export function memoryEngineRootFor(config, fallbackRoot) {
 export function fileMemoryEngineRoot(config, fallbackRoot) {
     return resolveMemoryEngineRoot(config.memoryEngineDir ?? fallbackRoot);
 }
-export function memoryEngineBackendFor(config, fallbackRoot) {
+export function fileMemoryPlaneFor(config, fallbackRoot) {
     if (config.requirePrincipal === true || !config.memoryEngineEnabled)
         return undefined;
     if (memoryEngineRemoteLanePosture(config)?.posture === "dark")
         return undefined;
     const root = fileMemoryEngineRoot(config, fallbackRoot);
-    const dir = join(root, "memory");
-    return { backend: new FileMemoryEngineBackend(dir, { controlDir: deriveControlPlaneDir(root, dir) }), root };
+    const memoryDir = join(root, "memory");
+    return { root, memoryDir, controlDir: deriveControlPlaneDir(root, memoryDir) };
+}
+export function fileMemoryControlDirFor(config, fallbackRoot) {
+    return fileMemoryPlaneFor(config, fallbackRoot)?.controlDir;
+}
+export function memoryEngineBackendFor(config, fallbackRoot) {
+    const plane = fileMemoryPlaneFor(config, fallbackRoot);
+    if (plane === undefined)
+        return undefined;
+    return { backend: new FileMemoryEngineBackend(plane.memoryDir, { controlDir: plane.controlDir }), root: plane.root };
 }
 export function memorySpecForRequest(scope, memoryWrite, defaultScopes, originPolicy, memoryCapture) {
     if (!scope)

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.d.ts

@@ -45,6 +45,10 @@ export interface MetricsSummary {
     rateLimited: number;
     costQuotaRejected: number;
     budgetExceeded: Record<string, number>;
+    /** 答后撞顶(walltime/turns)的计数。⚠️ 与 {@link budgetExceeded} **口径不同**:本枚在 deps 级通告席上铸,
+     *  覆盖**每一条**引擎 run(后台子代 / 委派嵌套腿 / leader 车道);`budgetExceeded` 只由 HTTP 提交腿的
+     *  `finalizeTaskResult` 递增(= 顶层 HTTP 提交的 run)。两枚相加只在后者那个较窄的总体里成立。 */
+    limitCeilingAfterAnswer: Record<string, number>;
     degraded: Record<string, number>;
     degenerate: Record<string, number>;
     memoryConsolidationOps: Record<string, number>;

package/dist/observability/metrics.js

@@ -174,6 +174,7 @@ export class Metrics {
             rateLimited: ctotal("rate_limited_total"),
             costQuotaRejected: ctotal("cost_quota_rejected_total"),
             budgetExceeded: cby("budget_exceeded_total", "code"),
+            limitCeilingAfterAnswer: cby("limit_ceiling_after_answer_total", "origin"),
             degraded: cby("degraded_total", "reason"),
             degenerate: cby("degenerate_total", "class"),
             memoryConsolidationOps: cby("memory_consolidation_ops_total", "op"),
@@ -215,6 +216,7 @@ export function createMetrics() {
     ]);
     m.counter("tool_calls_total", "Tool invocations by name and outcome");
     m.counter("budget_exceeded_total", "Tasks failed by a budget/limit ceiling, by errorCode");
+    m.counter("limit_ceiling_after_answer_total", "Runs where a walltime/turns ceiling fired AFTER the run had already answered (engine 7.13.0: these end completed with NO limits.* code). Dual of budget_exceeded_total, but NOT over the same population: this one is minted on the deps-level notice sink so it sees EVERY engine run (background children, delegated/nested legs, leader lanes); budget_exceeded_total is incremented only by the HTTP submit legs finalizeTaskResult, i.e. top-level HTTP-submitted runs. Sum them only within that narrower population; see the forwarder comment, by origin");
     m.counter("cost_quota_rejected_total", "Tasks refused because the principal is over its cumulative cost quota");
     m.counter("degraded_total", "Tasks degraded to a cheaper model (1.40), by reason (budget/rate_limit/breaker_open)");
     m.counter("task_model_not_allowlisted_resume_total", "Resumed legs whose model/compactionModel is outside the @-mention allowlist (allowed to keep running by design — the allowlist gates fresh picks only)");
@@ -261,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");

package/dist/observability/run-terminal-log.d.ts

@@ -1,4 +1,4 @@
-import type { RunRecord } from "../plugins/store-contracts.js";
+import { type RunRecord } from "../plugins/store-contracts.js";
 /** 一次终局写口交给观测面的原料(store 侧装配,**未脱敏** —— 脱敏在本模块内做,见 {@link notifyRunTerminal})。 */
 export interface RunTerminalRecord {
     /** 这条 run 的账本 id = `GET /v1/runs/:id` 的 id(本仓 run 行主键名为 taskId,同一个值)。 */
@@ -20,8 +20,9 @@ export type RunTerminalObserver = (level: "error" | "info", fields: Record<strin
 /**
  * 终局行的级别判据。`undefined` = 不打行。
  *
- * `blocked` 刻意不打:它是**治理判决**(门拒绝了这次执行),不是失败——它有自己的门遥测与
- * `GET /v1/runs/:id` 读面,混进 `run_failed` 会把「模型/网络出事了」这条读法冲淡。
+ * 一句话:**非成功终局才出声**(`failed` / `blocked`),用户主动取消降 `info`。词的分类不在本模块做 ——
+ * 它的唯一属主是 `plugins/store-contracts.ts` 的 `RUN_STATUS_CLASS` 表(S-213③:本模块此前手抄了一张
+ * 穷举 switch,并在 `blocked` 那一格给出与 fleet 读面互斥的答案)。表的编译期双向钉在属主处。
  */
 export declare function runTerminalLogLevel(status: RunRecord["status"], errorCode: string | undefined): "error" | "info" | undefined;
 /** 装配点(`main.ts` 唯一)。传 `undefined` 卸载(测试隔离)。 */

package/dist/observability/run-terminal-log.js

@@ -1,25 +1,14 @@
 import { createHash } from "node:crypto";
 import { redactSecrets } from "../trace/redact.js";
 import { isParkLedgerEventType } from "../trace/ledger-events.js";
+import { isUnsuccessfulRunStatus } from "../plugins/store-contracts.js";
 import { errorText } from "./err-text.js";
 import { recordFailOpen } from "./fail-open.js";
 const MESSAGE_CAP = 1024;
 export function runTerminalLogLevel(status, errorCode) {
-    switch (status) {
-        case "failed":
-            return errorCode === "cancelled" ? "info" : "error";
-        case "blocked":
-        case "completed":
-        case "running":
-        case "suspended":
-        case "needs_review":
-            return undefined;
-        default: {
-            const unhandled = status;
-            void unhandled;
-            return undefined;
-        }
-    }
+    if (!isUnsuccessfulRunStatus(status))
+        return undefined;
+    return errorCode === "cancelled" ? "info" : "error";
 }
 let observer;
 export function setRunTerminalObserver(fn) {

package/dist/observability/tool-trace.d.ts

@@ -15,7 +15,8 @@ import type { Metrics } from "./metrics.js";
  * (`policy/hook/safety/shellGate/planMode/classifier/org`)换成八词
  * (`policy/hook/org/classifier/plan_mode/compliance/write_protection/ask_resolution`)。仪表盘/告警规则要改。
  *
- * 🔴 **第二个计数器 `auto_mode_classifier_unavailable_total{cause}`(server 7.70.0,core 7.12.0 [ref])**
+ * 🔴 **第二个计数器 `auto_mode_classifier_deny_cause_total{cause}`(server 7.70.0 生为
+ * `auto_mode_classifier_unavailable_total`,core 7.12.0 [ref];**7.72.0 / core 7.14.0 [ref] 改名、换座、换词**,见本段末)**
  * —— 分类器**停摆**的常开信号。7.12.0 之前这件事有两条可观测路:熔断跳闸时的
  * `auto_mode_breaker_open_total`,以及「`unavailable` 的 ask 会走到人面前」(审批 inbox 里看得见)。
  * 该版把熔断族整族退役、又把 `unavailable` 改成**当场 deny** ⇒ 两条路同时没了,而
@@ -26,6 +27,22 @@ import type { Metrics } from "./metrics.js";
  * 两个计数刻意**不合并成一个标签**:它们答两个问题(「谁拒的」vs「这次拒是不是因为分类器停摆、哪一类」),
  * 而运维对停摆要立刻动手(改配置 / 等重试 / 看后端),对安全拦截不要。
  * ⛔ 纯计量:不改任何裁决、不新开观察面、事实缺席时**不铸**(缺席 ≠ 「分类器好着呢」,只是这次拒不是它)。
+ *
+ * 🔴 **7.72.0(core 7.14.0 [ref] C-a)—— 同一只计数器换了名、换了座、也换了词表,运维面 BREAKING**:
+ *  · **名**(合并复审 R2):`auto_mode_classifier_unavailable_total` ⇒ `auto_mode_classifier_deny_cause_total`,
+ *    **无别名** —— 一只也数 `parse_error`(分类器跑了、答得出格)的计数器再叫 unavailable 就是名不副实;
+ *    与下面两条是同一次运维 BREAKING,只痛一次。
+ *  · **座**:`payload.classifierUnavailable.cause`(整族退役)⇒ `payload.gate.disposition.cause`。同一条
+ *    门记录的三张脸(`tool_end.gate` / 本观察者的 `payload.gate` / 行的 `resolvedOutcome`)core 一次铸、
+ *    三处投,所以这一位与 `deniedBy` 现在**读自同一只对象**——两个标签不可能再各说各话。
+ *  · **词表**:`AUTO_MODE_UNAVAILABLE_CAUSES`(`error` / `timeout` = 分类器**为什么**没跑成)
+ *    ⇒ `CLASSIFIER_DENY_CAUSES`(`unavailable` / `parse_error` = **这次 deny 是什么形**)。
+ *    ⚠️ 两代不是同一个问题的两组词:`unavailable` 覆盖了旧的 error+timeout 两格(「为什么」降级成散文,
+ *    只在 deny 句与 `auto_mode.classified` 诊断帧上),而 `parse_error`(分类器跑了、但答得出格 ⇒ 为安全
+ *    起见拦下)是**旧计数器根本数不到**的一格。看板/告警的 `cause=` 过滤要改,按旧词 by-cause 分组的
+ *    历史序列与新序列**不可直接拼**。
+ *  · **计数总量方向**:新座只在「分类器那一轮没有裁决」时在场(`<block>yes` 的真裁决恒缺席),与旧座的
+ *    「分类器停摆」同向;多出来的那一格是 `parse_error`,它也确实是「分类器没正常工作」的一种。
  */
 export declare function createPermissionDeniedMeter(metrics: Pick<Metrics, "inc">): Hooks;
 /**