@sema-agent/server 7.79.0 → 7.79.2

package/dist/http/admission.js

@@ -0,0 +1,560 @@
+import { isThinkingLevel, expandTiers } from "@sema-agent/core";
+import { isModelAllowlisted, matchCatalogModel } from "../model-select.js";
+import { HttpError } from "../security.js";
+import { MAX_SETTINGS_OUTPUT_STYLE_CHARS, MAX_SETTINGS_PERMISSION_RULES, MAX_SETTINGS_ENV_VARS, MAX_SETTINGS_ENV_KEY_CHARS, MAX_SETTINGS_ENV_VALUE_CHARS, parseTaskSettings, skillListingBudgetFractionOk, skillListingMaxDescOk, taskSettingsKeyIssue } from "../task-settings.js";
+import { taskBodyKeyIssue } from "../request-key-closure.js";
+import { selfOrchestrationDenial } from "../task-workflow.js";
+import { centerEntitlementSourceWired } from "../runtime-caps-resolver.js";
+import { parseHooksConfig } from "../hooks/hook-runner.js";
+import { normalizeApproachNotice, unknownTaskAgentModelRef, validateTaskAgents } from "../spec-fields.js";
+import { isValidCwd, MAX_ADDITIONAL_DIRS } from "../task-cwd.js";
+import { verifyRoundsFromBody } from "./verify-rounds.js";
+import { sendError, httpErrorCode } from "./send.js";
+export const MAX_SKILL_CONTENT_CHARS = 1_048_576;
+export const MAX_SYSTEM_PROMPT_CHARS = 16_384;
+export const MAX_OUTPUT_SCHEMA_CHARS = 32_768;
+export function validateUserSkills(skills) {
+    if (skills === undefined)
+        return null;
+    if (!Array.isArray(skills))
+        return "skills must be an array of { name, description, content }";
+    for (const s of skills) {
+        if (s === null || typeof s !== "object")
+            return "each skill must be an object { name, description, content }";
+        if (typeof s["name"] !== "string" || s["name"].length === 0)
+            return "skill.name must be a non-empty string";
+        if (typeof s["description"] !== "string")
+            return "skill.description must be a string";
+        if (typeof s["content"] !== "string" || s["content"].length === 0 || s["content"].length > MAX_SKILL_CONTENT_CHARS)
+            return `skill.content must be a non-empty string of at most ${MAX_SKILL_CONTENT_CHARS} characters (the engine rejects skills over this size outright at load time)`;
+    }
+    return null;
+}
+const MAX_IMAGES_PER_REQUEST = 20;
+const MAX_IMAGE_BASE64_BYTES = 6 * 1024 * 1024;
+function mentionableNames(config, catalog) {
+    const allowlist = config.atModelAllowlist ?? [];
+    return Object.keys(catalog).filter((n) => n !== "default" && isModelAllowlisted(n, catalog, allowlist));
+}
+export function createAdmission(ctx) {
+    const { deps, readJson, runnerFor } = ctx;
+    async function prepareSpec(req, res, bodyIn, onTypedFailure, legFacts) {
+        const body = bodyIn ?? (await readJson(req));
+        if (!body || typeof body.objective !== "string") {
+            sendError(res, 400, "request.field_invalid", "missing 'objective' string");
+            return null;
+        }
+        if (body.objective.trim().length === 0) {
+            sendError(res, 400, "request.field_invalid", "objective must not be empty or whitespace-only (an empty user message poisons the session history on strict providers)");
+            return null;
+        }
+        {
+            const bodyKeyIssue = taskBodyKeyIssue(body);
+            if (bodyKeyIssue) {
+                sendError(res, 400, "request.body_shape", bodyKeyIssue.message, { unknownKeys: bodyKeyIssue.unknownKeys, unsupportedKeys: bodyKeyIssue.unsupportedKeys });
+                return null;
+            }
+        }
+        if (body.jobId !== undefined && (typeof body.jobId !== "string" || body.jobId.length === 0 || body.jobId.length > 64)) {
+            sendError(res, 400, "request.field_invalid", "jobId must be a non-empty string of at most 64 characters");
+            return null;
+        }
+        if (typeof body.sessionId === "string" && body.sessionId.length > 64) {
+            sendError(res, 400, "request.field_invalid", "sessionId must be at most 64 characters");
+            return null;
+        }
+        if (typeof body.systemPrompt === "string" && body.systemPrompt.length > MAX_SYSTEM_PROMPT_CHARS) {
+            sendError(res, 400, "request.field_invalid", `systemPrompt must be at most ${MAX_SYSTEM_PROMPT_CHARS} characters`);
+            return null;
+        }
+        if (body.appendSystemPrompt !== undefined) {
+            if (typeof body.appendSystemPrompt !== "string" || body.appendSystemPrompt.length === 0) {
+                sendError(res, 400, "request.field_invalid", "appendSystemPrompt must be a non-empty string");
+                return null;
+            }
+            if (body.appendSystemPrompt.length > MAX_SYSTEM_PROMPT_CHARS) {
+                sendError(res, 400, "request.field_invalid", `appendSystemPrompt must be at most ${MAX_SYSTEM_PROMPT_CHARS} characters`);
+                return null;
+            }
+        }
+        if (body.cwd !== undefined && !isValidCwd(body.cwd)) {
+            sendError(res, 400, "request.field_invalid", "cwd must be a non-empty absolute host path");
+            return null;
+        }
+        const addDirsRaw = body.additionalDirectories;
+        if (addDirsRaw !== undefined) {
+            if (!Array.isArray(addDirsRaw)) {
+                sendError(res, 400, "request.field_invalid", "additionalDirectories must be an array of absolute host paths");
+                return null;
+            }
+            if (addDirsRaw.length > MAX_ADDITIONAL_DIRS) {
+                sendError(res, 400, "request.field_invalid", `additionalDirectories must have at most ${MAX_ADDITIONAL_DIRS} entries`);
+                return null;
+            }
+            const bad = addDirsRaw.find((d) => !isValidCwd(d));
+            if (bad !== undefined) {
+                sendError(res, 400, "request.field_invalid", "each additionalDirectories entry must be a non-empty absolute host path (no '..' segments)");
+                return null;
+            }
+        }
+        const addReadDirsRaw = body.additionalReadDirectories;
+        if (addReadDirsRaw !== undefined) {
+            if (!Array.isArray(addReadDirsRaw)) {
+                sendError(res, 400, "request.field_invalid", "additionalReadDirectories must be an array of absolute host paths");
+                return null;
+            }
+            if (addReadDirsRaw.length > MAX_ADDITIONAL_DIRS) {
+                sendError(res, 400, "request.field_invalid", `additionalReadDirectories must have at most ${MAX_ADDITIONAL_DIRS} entries`);
+                return null;
+            }
+            const badRead = addReadDirsRaw.find((d) => !isValidCwd(d));
+            if (badRead !== undefined) {
+                sendError(res, 400, "request.field_invalid", "each additionalReadDirectories entry must be a non-empty absolute host path (no '..' segments)");
+                return null;
+            }
+        }
+        const settingsRaw = body.settings;
+        if (settingsRaw !== undefined && settingsRaw !== null) {
+            if (typeof settingsRaw !== "object" || Array.isArray(settingsRaw)) {
+                sendError(res, 400, "request.field_invalid", "settings must be an object");
+                return null;
+            }
+            const st = settingsRaw;
+            {
+                const keyIssue = taskSettingsKeyIssue(st);
+                if (keyIssue) {
+                    sendError(res, 400, "request.body_shape", keyIssue.message, { unknownKeys: keyIssue.unknownKeys, unsupportedKeys: keyIssue.unsupportedKeys });
+                    return null;
+                }
+            }
+            if (typeof st.outputStyle === "string" && st.outputStyle.length > MAX_SETTINGS_OUTPUT_STYLE_CHARS) {
+                sendError(res, 400, "request.field_invalid", `settings.outputStyle must be at most ${MAX_SETTINGS_OUTPUT_STYLE_CHARS} characters`);
+                return null;
+            }
+            if (typeof st.outputStyle === "string" &&
+                st.outputStyle.length > 0 &&
+                typeof body.appendSystemPrompt === "string" &&
+                body.appendSystemPrompt.length + 2 + st.outputStyle.length > MAX_SYSTEM_PROMPT_CHARS) {
+                sendError(res, 400, "request.field_conflict", `appendSystemPrompt + settings.outputStyle fold into one system-prompt block — combined they must be at most ${MAX_SYSTEM_PROMPT_CHARS} characters (including the 2-char joiner)`);
+                return null;
+            }
+            const perms = st.permissions;
+            if (perms !== undefined && perms !== null && (typeof perms !== "object" || Array.isArray(perms))) {
+                sendError(res, 400, "request.field_invalid", "settings.permissions must be an object");
+                return null;
+            }
+            if (perms !== null && typeof perms === "object" && !Array.isArray(perms)) {
+                for (const k of ["allow", "deny", "ask"]) {
+                    const arr = perms[k];
+                    if (Array.isArray(arr) && arr.length > MAX_SETTINGS_PERMISSION_RULES) {
+                        sendError(res, 400, "request.field_invalid", `settings.permissions.${k} must have at most ${MAX_SETTINGS_PERMISSION_RULES} entries`);
+                        return null;
+                    }
+                }
+            }
+            const envRaw = st.env;
+            if (envRaw !== undefined && envRaw !== null) {
+                if (typeof envRaw !== "object" || Array.isArray(envRaw)) {
+                    sendError(res, 400, "request.field_invalid", "settings.env must be an object of string→string");
+                    return null;
+                }
+                const entries = Object.entries(envRaw);
+                if (entries.length > MAX_SETTINGS_ENV_VARS) {
+                    sendError(res, 400, "request.field_invalid", `settings.env must have at most ${MAX_SETTINGS_ENV_VARS} variables`);
+                    return null;
+                }
+                for (const [k, val] of entries) {
+                    if (k.length > MAX_SETTINGS_ENV_KEY_CHARS || (typeof val === "string" && val.length > MAX_SETTINGS_ENV_VALUE_CHARS)) {
+                        sendError(res, 400, "request.field_invalid", `settings.env keys must be ≤${MAX_SETTINGS_ENV_KEY_CHARS} chars and values ≤${MAX_SETTINGS_ENV_VALUE_CHARS} chars`);
+                        return null;
+                    }
+                }
+            }
+            if (st.ultracode !== undefined && typeof st.ultracode !== "boolean") {
+                sendError(res, 400, "request.field_invalid", "settings.ultracode must be a boolean");
+                return null;
+            }
+            if (st.skillListingBudgetFraction !== undefined && !skillListingBudgetFractionOk(st.skillListingBudgetFraction)) {
+                sendError(res, 400, "request.field_invalid", "settings.skillListingBudgetFraction must be a number greater than 0 and at most 1");
+                return null;
+            }
+            if (st.skillListingMaxDescChars !== undefined && !skillListingMaxDescOk(st.skillListingMaxDescChars)) {
+                sendError(res, 400, "request.field_invalid", "settings.skillListingMaxDescChars must be a positive integer");
+                return null;
+            }
+            if (st.hooks !== undefined && st.hooks !== null) {
+                const hooksParsed = parseHooksConfig(st.hooks);
+                if (!hooksParsed.config) {
+                    sendError(res, 400, "request.field_invalid", hooksParsed.error ?? "settings.hooks: invalid shape");
+                    return null;
+                }
+            }
+        }
+        const skillsErr = validateUserSkills(body.skills);
+        if (skillsErr) {
+            sendError(res, 400, "request.field_invalid", skillsErr);
+            return null;
+        }
+        if (Array.isArray(body.images)) {
+            if (body.images.length > MAX_IMAGES_PER_REQUEST) {
+                sendError(res, 413, "request.payload_too_large", `at most ${MAX_IMAGES_PER_REQUEST} images per request`);
+                return null;
+            }
+            for (const img of body.images) {
+                const data = img.data;
+                if (typeof data === "string" && Buffer.byteLength(data, "utf8") > MAX_IMAGE_BASE64_BYTES) {
+                    sendError(res, 413, "request.payload_too_large", `each inline image must be at most ${MAX_IMAGE_BASE64_BYTES} base64 bytes`);
+                    return null;
+                }
+            }
+        }
+        if (body.clientContext !== undefined) {
+            const cc = body.clientContext;
+            if (typeof cc !== "object" || cc === null || Array.isArray(cc)) {
+                sendError(res, 400, "request.field_invalid", "clientContext must be an object");
+                return null;
+            }
+            if (cc.timeZone !== undefined && (typeof cc.timeZone !== "string" || cc.timeZone.length > 64)) {
+                sendError(res, 400, "request.field_invalid", "clientContext.timeZone must be a string of at most 64 characters");
+                return null;
+            }
+            if (cc.userEmail !== undefined && (typeof cc.userEmail !== "string" || cc.userEmail.length > 256)) {
+                sendError(res, 400, "request.field_invalid", "clientContext.userEmail must be a string of at most 256 characters");
+                return null;
+            }
+        }
+        if (body.sandboxImageProfile !== undefined && (typeof body.sandboxImageProfile !== "string" || body.sandboxImageProfile.length === 0 || body.sandboxImageProfile.length > 128)) {
+            sendError(res, 400, "request.field_invalid", "sandboxImageProfile must be a non-empty string of at most 128 characters");
+            return null;
+        }
+        if (body.capabilitiesNeeded !== undefined && (!Array.isArray(body.capabilitiesNeeded) || body.capabilitiesNeeded.some((c) => typeof c !== "string"))) {
+            sendError(res, 400, "request.field_invalid", "capabilitiesNeeded must be an array of strings");
+            return null;
+        }
+        if (Array.isArray(body.capabilitiesNeeded) && body.capabilitiesNeeded.length > 0 && (typeof body.sandboxImageProfile !== "string" || body.sandboxImageProfile.length === 0)) {
+            sendError(res, 400, "request.field_conflict", "capabilitiesNeeded requires sandboxImageProfile (it constrains the selected image)");
+            return null;
+        }
+        if (typeof body.sandboxImageProfile === "string" && body.sandboxImageProfile.length > 0 && (body.cascade === true || body.verify === true)) {
+            sendError(res, 400, "request.field_conflict", "sandboxImageProfile is not supported together with cascade/verify in v1 (the per-task image would not bind to the cascade rungs / verifier sub-run)");
+            return null;
+        }
+        if (body.outputSchema !== undefined) {
+            if (typeof body.outputSchema !== "object" || body.outputSchema === null || Array.isArray(body.outputSchema)) {
+                sendError(res, 400, "request.field_invalid", "outputSchema must be a JSON Schema object");
+                return null;
+            }
+            if (JSON.stringify(body.outputSchema).length > MAX_OUTPUT_SCHEMA_CHARS) {
+                sendError(res, 400, "request.field_invalid", `outputSchema must serialize to at most ${MAX_OUTPUT_SCHEMA_CHARS} characters`);
+                return null;
+            }
+        }
+        if (body.reasoningEffort !== undefined && !isThinkingLevel(body.reasoningEffort)) {
+            sendError(res, 400, "request.field_invalid", "reasoningEffort must be one of: off, minimal, low, medium, high, xhigh, max");
+            return null;
+        }
+        if (body.resumeAt !== undefined) {
+            if (typeof body.resumeAt !== "string" || body.resumeAt.length === 0 || body.resumeAt.length > 64) {
+                sendError(res, 400, "request.field_invalid", "resumeAt must be a non-empty message eventId string (≤64 chars)");
+                return null;
+            }
+            if (body.verify === true || body.cascade === true) {
+                sendError(res, 400, "request.field_conflict", "resumeAt is not supported with verify or cascade (those start a fresh/replaced session)");
+                return null;
+            }
+        }
+        if (body.resumeAtMode !== undefined) {
+            if (body.resumeAtMode !== "at" && body.resumeAtMode !== "before") {
+                sendError(res, 400, "request.field_invalid", 'resumeAtMode must be "at" or "before"');
+                return null;
+            }
+            if (body.resumeAt === undefined) {
+                sendError(res, 400, "request.field_conflict", "resumeAtMode requires resumeAt (it qualifies the rewind target)");
+                return null;
+            }
+        }
+        if (body.suggestNextPrompts !== undefined && typeof body.suggestNextPrompts !== "boolean") {
+            const s = body.suggestNextPrompts;
+            if (typeof s !== "object" || s === null || Array.isArray(s)) {
+                sendError(res, 400, "request.field_invalid", "suggestNextPrompts must be a boolean or an object { count?, role? }");
+                return null;
+            }
+            const o = s;
+            if (o.count !== undefined && (typeof o.count !== "number" || !Number.isFinite(o.count) || o.count < 1)) {
+                sendError(res, 400, "request.field_invalid", "suggestNextPrompts.count must be a positive number");
+                return null;
+            }
+            if (o.role !== undefined && typeof o.role !== "string") {
+                sendError(res, 400, "request.field_invalid", "suggestNextPrompts.role must be a string (a model role name)");
+                return null;
+            }
+        }
+        if (body.rewindFiles !== undefined && typeof body.rewindFiles !== "boolean") {
+            sendError(res, 400, "request.field_invalid", "rewindFiles must be a boolean");
+            return null;
+        }
+        if (body.restoreFiles !== undefined && typeof body.restoreFiles !== "boolean") {
+            sendError(res, 400, "request.field_invalid", "restoreFiles must be a boolean");
+            return null;
+        }
+        if (body.acceptPartialRestore !== undefined && typeof body.acceptPartialRestore !== "boolean") {
+            sendError(res, 400, "request.field_invalid", "acceptPartialRestore must be a boolean");
+            return null;
+        }
+        if (body.memoryWrite !== undefined && typeof body.memoryWrite !== "boolean") {
+            sendError(res, 400, "request.field_invalid", "memoryWrite must be a boolean (false = pause memory writes for this run)");
+            return null;
+        }
+        if (body.memoryCapture !== undefined && body.memoryCapture !== "off") {
+            sendError(res, 400, "request.field_invalid", "memoryCapture must be the string 'off' when present (the session-level memory-capture opt-out declaration; absent = capture as usual — there is no 'on' spelling)");
+            return null;
+        }
+        if (body.requireExistingSession !== undefined && typeof body.requireExistingSession !== "boolean") {
+            sendError(res, 400, "request.field_invalid", "requireExistingSession must be a boolean");
+            return null;
+        }
+        if (body.enableFork !== undefined && typeof body.enableFork !== "boolean") {
+            sendError(res, 400, "request.field_invalid", "enableFork must be a boolean");
+            return null;
+        }
+        if (body.selfOrchestration !== undefined && typeof body.selfOrchestration !== "boolean") {
+            sendError(res, 400, "request.field_invalid", "selfOrchestration must be a boolean");
+            return null;
+        }
+        {
+            const denial = selfOrchestrationDenial({ selfOrchestrationEnabled: deps.config.selfOrchestrationEnabled, requirePrincipal: deps.config.requirePrincipal }, centerEntitlementSourceWired(deps.config));
+            const wantsSelfOrchestration = body.selfOrchestration === true
+                || parseTaskSettings(body.settings).settings?.ultracode === true;
+            if (denial !== null && wantsSelfOrchestration) {
+                sendError(res, 501, "capability.self_orchestration_required", "self-orchestration is enabled on this worker (SELF_ORCHESTRATION_ENABLED) but it is multi-tenant (REQUIRE_PRINCIPAL) and wires NO per-principal entitlement source, so the engine's allowWorkflows gate — which is tighten-only, meaning an absent resolver leaves it UNGATED — is fail-closed for every principal: no request can ever get the workflow engine here (GET /v1/capabilities reports workflows:false with workflowsGate.denial \"entitlement_resolver_absent\"). Wire a config center (SEMA_REGISTRY_URL + token, not dry-run) to gate it per principal, or set SELF_ORCHESTRATION_ENABLED=false — the honest posture for a worker that cannot grant it. To submit this task without the workflow engine, drop selfOrchestration / settings.ultracode; ultracode's other half (the max thinking tier) is available as reasoningEffort: \"max\"");
+                return null;
+            }
+        }
+        if (body.resilience !== undefined) {
+            const r = body.resilience;
+            if (typeof r !== "object" || r === null || Array.isArray(r)) {
+                sendError(res, 400, "request.field_invalid", "resilience must be an object { allowDegrade?, allowFailover?, bypassBreaker? } (booleans)");
+                return null;
+            }
+            for (const k of ["allowDegrade", "allowFailover", "bypassBreaker"]) {
+                const v = r[k];
+                if (v !== undefined && typeof v !== "boolean") {
+                    sendError(res, 400, "request.field_invalid", `resilience.${k} must be a boolean`);
+                    return null;
+                }
+            }
+        }
+        if (body.finalVerification !== undefined && typeof body.finalVerification !== "boolean") {
+            sendError(res, 400, "request.field_invalid", "finalVerification must be a boolean");
+            return null;
+        }
+        if (body.limits !== undefined) {
+            const l = body.limits;
+            if (typeof l !== "object" || l === null || Array.isArray(l)) {
+                sendError(res, 400, "request.field_invalid", "limits must be an object { maxWalltimeMs?, maxOutputTokens?, maxTurns? } (positive integers)");
+                return null;
+            }
+            if (l.timeoutSec !== undefined) {
+                sendError(res, 400, "request.field_invalid", "limits.timeoutSec was retired in core 5.8.0 — use limits.maxWalltimeMs (milliseconds; opt-in wall clock)");
+                return null;
+            }
+            if (l.deadlineNudge !== undefined) {
+                sendError(res, 400, "request.field_invalid", "limits.deadlineNudge was retired in core 5.8.0 — use limits.approachNotice (default on at 80%/95%; false turns it off, {at: [r1, r2]} tunes thresholds)");
+                return null;
+            }
+            for (const k of ["callCapByDeadline", "gracefulFinalize"]) {
+                if (l[k] !== undefined) {
+                    sendError(res, 400, "request.field_invalid", `limits.${k} was retired in core 5.8.0 (the deadline-pacing mechanism family is gone; there is no replacement key — remove it)`);
+                    return null;
+                }
+            }
+            for (const k of ["maxCostUsd", "maxTokens"]) {
+                if (l[k] !== undefined) {
+                    sendError(res, 400, "request.field_invalid", `limits.${k} is not read from limits here — send it at the request body top level (${k}); it is capped by the operator ceiling ${k === "maxCostUsd" ? "MAX_TASK_COST_USD" : "MAX_TASK_TOKENS"}`);
+                    return null;
+                }
+            }
+            if (l.degrade !== undefined) {
+                sendError(res, 400, "request.field_invalid", "limits.degrade is operator-controlled (env MODEL_DEGRADE_TO / MODEL_DEGRADE_AT_COST_FRACTION), not caller-settable — remove it");
+                return null;
+            }
+            if (l.budgetStreamCancel !== undefined) {
+                sendError(res, 400, "request.field_invalid", "limits.budgetStreamCancel is not caller-settable here — the engine default applies (armed whenever a cost budget is present); remove it");
+                return null;
+            }
+            for (const k of ["maxWalltimeMs", "maxOutputTokens", "maxTurns"]) {
+                const v = l[k];
+                if (v !== undefined && (typeof v !== "number" || !Number.isInteger(v) || v < 1)) {
+                    sendError(res, 400, "request.field_invalid", `limits.${k} must be a positive integer${k === "maxWalltimeMs" ? " (milliseconds)" : ""}`);
+                    return null;
+                }
+            }
+            {
+                const v = l.approachNotice;
+                if (v !== undefined && normalizeApproachNotice(v) === undefined) {
+                    sendError(res, 400, "request.field_invalid", "limits.approachNotice accepts false (turn off) or {at?: [r1, r2]} with fractions in (0, 1], r1 <= r2 (default on at 80%/95%)");
+                    return null;
+                }
+            }
+        }
+        if (body.agents !== undefined) {
+            const agentsErr = validateTaskAgents(body.agents);
+            if (agentsErr) {
+                sendError(res, 400, "request.field_invalid", agentsErr);
+                return null;
+            }
+            const agentsBare = deps.config.models ?? {};
+            const agentsCatalog = expandTiers(agentsBare, deps.config.tiers ?? {}) ?? agentsBare;
+            const um = unknownTaskAgentModelRef(body.agents, agentsCatalog);
+            if (um !== undefined) {
+                sendError(res, 400, "request.unknown_reference", `unknown agents[${um.index}].model "${um.ref.slice(0, 120)}" — not in the configured catalog (a catalog name or tier word)`, { available: mentionableNames(deps.config, agentsCatalog) });
+                return null;
+            }
+        }
+        if (body.interactiveTools !== undefined && typeof body.interactiveTools !== "boolean") {
+            sendError(res, 400, "request.field_invalid", "interactiveTools must be a boolean");
+            return null;
+        }
+        if (body.oneShot !== undefined && typeof body.oneShot !== "boolean") {
+            sendError(res, 400, "request.field_invalid", "oneShot must be a boolean");
+            return null;
+        }
+        if (body.retainBackgroundProcesses !== undefined && typeof body.retainBackgroundProcesses !== "boolean") {
+            sendError(res, 400, "request.field_invalid", "retainBackgroundProcesses must be a boolean");
+            return null;
+        }
+        for (const key of ["excludeTools", "deferTools"]) {
+            const v = body[key];
+            if (v !== undefined && (!Array.isArray(v) || v.some((n) => typeof n !== "string" || n.length === 0))) {
+                sendError(res, 400, "request.field_invalid", `${key} must be an array of non-empty tool-name strings`);
+                return null;
+            }
+        }
+        {
+            const v = body.promptProfile;
+            if (v !== undefined && v !== "simple" && v !== "classic") {
+                sendError(res, 400, "request.field_invalid", 'promptProfile must be "simple" or "classic"');
+                return null;
+            }
+        }
+        {
+            const v = body.toolMaterializeStrategy;
+            if (v !== undefined && v !== "static" && v !== "swap") {
+                sendError(res, 400, "request.field_invalid", 'toolMaterializeStrategy must be "static" or "swap"');
+                return null;
+            }
+        }
+        {
+            const v = body.permissionMode;
+            if (v !== undefined && v !== "default" && v !== "acceptEdits" && v !== "plan" && v !== "bypassPermissions" && v !== "auto") {
+                sendError(res, 400, "request.field_invalid", 'permissionMode must be one of "default" | "acceptEdits" | "plan" | "bypassPermissions" | "auto"');
+                return null;
+            }
+        }
+        {
+            const s = body.settings;
+            if (s !== null && typeof s === "object" && !Array.isArray(s)) {
+                const p = s.permissions;
+                if (p !== null && typeof p === "object" && !Array.isArray(p)) {
+                    const m = p.defaultMode;
+                    if (m !== undefined && m !== "default" && m !== "acceptEdits" && m !== "plan" && m !== "bypassPermissions" && m !== "auto") {
+                        sendError(res, 400, "request.field_invalid", 'settings.permissions.defaultMode must be one of "default" | "acceptEdits" | "plan" | "bypassPermissions" | "auto"');
+                        return null;
+                    }
+                    const d = p.disableAutoMode;
+                    if (d !== undefined && d !== "disable" && d !== true && d !== false) {
+                        sendError(res, 400, "request.field_invalid", 'settings.permissions.disableAutoMode must be the literal "disable" or a boolean when present (omit it to leave auto mode available)');
+                        return null;
+                    }
+                }
+            }
+        }
+        if (body.model !== undefined) {
+            if (typeof body.model !== "string" || body.model.length === 0) {
+                sendError(res, 400, "request.field_invalid", "model must be a non-empty string (a configured catalog name, tier word, or model id)");
+                return null;
+            }
+            const bare = deps.config.models ?? {};
+            const catalog = expandTiers(bare, deps.config.tiers ?? {}) ?? bare;
+            if (matchCatalogModel(body.model, catalog) === undefined) {
+                sendError(res, 400, "request.unknown_reference", `unknown model "${body.model.slice(0, 120)}" — not in the configured catalog (name, tier word, or id)`, { available: mentionableNames(deps.config, catalog) });
+                return null;
+            }
+        }
+        if (body.compactionModel !== undefined) {
+            if (typeof body.compactionModel !== "string" || body.compactionModel.length === 0) {
+                sendError(res, 400, "request.field_invalid", "compactionModel must be a non-empty string (a configured catalog name, tier word, or model id)");
+                return null;
+            }
+            const bare = deps.config.models ?? {};
+            const catalog = expandTiers(bare, deps.config.tiers ?? {}) ?? bare;
+            if (matchCatalogModel(body.compactionModel, catalog) === undefined) {
+                sendError(res, 400, "request.unknown_reference", `unknown compactionModel "${body.compactionModel.slice(0, 120)}" — not in the configured catalog (name, tier word, or id)`, { available: mentionableNames(deps.config, catalog) });
+                return null;
+            }
+        }
+        if (body.attachments !== undefined) {
+            const a = body.attachments;
+            if (typeof a !== "object" || a === null || Array.isArray(a)) {
+                sendError(res, 400, "request.field_invalid", "attachments must be an object { todoReminder?, todoReminderMode?, changedFiles?, planModeReminder?, budgetUsd?, backgroundTasks?, toolsDelta?, agentListing?, skillsListing?, mcpInstructions? }");
+                return null;
+            }
+            const rec = a;
+            for (const k of ["todoReminder", "planModeReminder", "budgetUsd", "backgroundTasks", "toolsDelta", "agentListing", "skillsListing", "mcpInstructions"]) {
+                if (rec[k] !== undefined && typeof rec[k] !== "boolean") {
+                    sendError(res, 400, "request.field_invalid", `attachments.${k} must be a boolean`);
+                    return null;
+                }
+            }
+            if (rec.todoReminderMode !== undefined && rec.todoReminderMode !== "baseline" && rec.todoReminderMode !== "off") {
+                sendError(res, 400, "request.field_invalid", 'attachments.todoReminderMode must be "baseline" | "off"');
+                return null;
+            }
+            const cf = rec.changedFiles;
+            if (cf !== undefined && typeof cf !== "boolean") {
+                if (typeof cf !== "object" || cf === null || Array.isArray(cf)) {
+                    sendError(res, 400, "request.field_invalid", "attachments.changedFiles must be a boolean or { maxFiles?: number }");
+                    return null;
+                }
+                const mf = cf.maxFiles;
+                if (mf !== undefined && (typeof mf !== "number" || !Number.isFinite(mf) || mf < 1)) {
+                    sendError(res, 400, "request.field_invalid", "attachments.changedFiles.maxFiles must be a number ≥ 1");
+                    return null;
+                }
+            }
+        }
+        const verify = verifyRoundsFromBody(body);
+        const cascade = body.cascade === true;
+        if (cascade && verify) {
+            sendError(res, 400, "request.field_conflict", "verify and cascade are mutually exclusive (verify = adversarial gate; cascade = cheap→strong ladder)");
+            return null;
+        }
+        if (body.suggestNextPrompts && (verify || cascade)) {
+            sendError(res, 400, "request.field_conflict", "suggestNextPrompts is not supported with verify or cascade (those return a result, not a streamed run)");
+            return null;
+        }
+        if (cascade && deps.config.cascadeLadder.length === 0) {
+            sendError(res, 400, "request.precondition_unmet", "cascade requested but no ladder configured — set MODEL_CASCADE_LADDER (catalog model names, cheapest→strongest)");
+            return null;
+        }
+        try {
+            const auth = deps.authorize ? await deps.authorize({ req, body }) : undefined;
+            const engineNotices = [];
+            const spec = await deps.resolveSpec(body, req, auth, { leg: "fresh", ...(legFacts?.liveStream === true ? { liveStream: true } : {}), onNotice: (n) => engineNotices.push(n) });
+            return { spec, runner: runnerFor(spec), auth, verify, cascade, jobId: body.jobId, body, ...(engineNotices.length > 0 ? { engineNotices } : {}) };
+        }
+        catch (err) {
+            if (err instanceof HttpError) {
+                if (onTypedFailure) {
+                    onTypedFailure(err);
+                    return null;
+                }
+                sendError(res, err.status, httpErrorCode(err.status, err.code), err.message, { ...(err.extra ?? {}) });
+                return null;
+            }
+            throw err;
+        }
+    }
+    return { prepareSpec };
+}
+//# sourceMappingURL=admission.js.map

package/dist/http/approval-sweeps.d.ts

@@ -0,0 +1,21 @@
+/**
+ * 审批扫腿(S-147 切片:`http/server.ts` 5196–5488 逐字搬家,正文一字未改)——两条不经 HTTP 路由的赎回口:
+ * ①`denyExpiredApprovals`([ref] D-D,SLA 到期的 deny-sweep,main.ts 的 reaper 按拍调);
+ * ②`redeemParkedAsk`([ref],live 回决腿的 PARKED 赎回席,装配层接进协调器的晚绑座)。
+ * 两者都走 resume 家族的 `resumeCheckpoint`,所以它们的属主是「谁在无 HTTP 请求的情况下替人做决定」这件事,
+ * 不是请求流水线。`createWallClockJumpGuard` 建的 `denySweepClockGuard` 是 ① 的私有件,随它同居。
+ * ctx 字段 3 只(`deps` / `resumeCheckpoint` / `mayDiscloseRowError`),机器算(closure-free-vars)与手抄一致。
+ */
+import { type ParkedAskRedeemRequest } from "../tool-approval.js";
+import type { createResumeLegs } from "./resume-legs.js";
+import type { FlatServiceDeps } from "./server.js";
+export declare function createApprovalSweeps(ctx: {
+    deps: FlatServiceDeps;
+} & Pick<ReturnType<typeof createResumeLegs>, "resumeCheckpoint" | "mayDiscloseRowError">): {
+    denyExpiredApprovals: (now: number) => Promise<void>;
+    redeemParkedAsk: (req: ParkedAskRedeemRequest) => Promise<{
+        status: number;
+        body: Record<string, unknown>;
+    }>;
+};
+//# sourceMappingURL=approval-sweeps.d.ts.map