@sema-agent/server 7.131.0 → 7.133.0

package/dist/http/admission.js

@@ -1,52 +1,85 @@
 import { APPROVAL_REACH, MCP_IMAGE_MAX_BASE64, isApprovalReach, isPermissionMode, isThinkingLevel, expandTiers } from "@sema-agent/core";
 import { isAtMentionable, matchCatalogModel, refusedCatalogEntry, selectableCatalog } from "../model-select.js";
-import { modelUnavailableMessage } from "../model-entry-refusal.js";
+import { echoModelRef, modelUnavailableMessage } from "../model-entry-refusal.js";
 import { HttpError, sessionIdShapeIssue } from "../security.js";
 import { MAX_SETTINGS_OUTPUT_STYLE_CHARS, MAX_SETTINGS_ENV_VARS, MAX_SETTINGS_ENV_KEY_CHARS, MAX_SETTINGS_ENV_VALUE_CHARS, PERMISSION_MODE_WORDS, parseTaskSettings, settingsPermissionBucketIssue, skillListingBudgetFractionOk, skillListingMaxDescOk, stampEntryPermissionMode, taskHooksHonored, taskSettingsKeyIssue } from "../task-settings.js";
+import { tightenOnlySeatIssue } from "../tighten-only-seats.js";
 import { buildEntryModeClampNotice } from "../entry-mode-clamp-notice.js";
 import { autonomyModeFloor } from "../runtime-governance.js";
 import { taskBodyKeyIssue } from "../request-key-closure.js";
-import { FILE_HISTORY_DISABLED_NO_RESTORE, fileHistoryRestoreConflict, inheritEnvFieldIssue, singleMemberOffFieldIssue } from "../request-value-closure.js";
+import { FILE_HISTORY_DISABLED_NO_RESTORE, fileHistoryRestoreConflict, fileHistoryRestoreKeysInBody, inheritEnvFieldIssue, singleMemberOffFieldIssue } from "../request-value-closure.js";
 import * as facts from "../capability-facts.js";
-import { buildToolMatcherRefusal, parseHooksConfig, toolMatcherIssue } from "../hooks/hook-runner.js";
+import { buildHooksRefusal, parseHooksConfig, hooksMatcherIssue } from "../hooks/hook-runner.js";
 import { judgeRequestWebSearch } from "../plugins/web-search.js";
-import { normalizeApproachNotice, skillToolListOk, skillToolListRefusal, unknownTaskAgentModelRef, validateTaskAgents } from "../spec-fields.js";
+import { normalizeApproachNotice, skillToolListOk, unknownTaskAgentModelRef, validateTaskAgents } from "../spec-fields.js";
+import { allowSelectorWarningsOf, skillToolListsOverCap } from "../rule-entry-list.js";
+import { limitFacts, limitRefusal } from "../limit-refusal.js";
+import { fieldConflictFacts } from "../field-conflict.js";
+import { echoCallerText, quotedCallerText } from "../caller-text-echo.js";
 import { MAX_ADDITIONAL_DIRS } from "../task-cwd.js";
 import { verifyRoundsFromBody } from "./verify-rounds.js";
 import { skillCarriesRetiredManifest } from "./retired-skill-manifest.js";
 import { resolveDevicePlacementIntent } from "./device-placement.js";
+import { callerTrust, requestTrustRefusal } from "./caller-trust.js";
 import { createRunAcceptance } from "../run-acceptance.js";
 import { sendError, sendHttpError } from "./send.js";
+import { refuseSubmitBody } from "./request-guards.js";
+import { sqlWallsOf } from "../plugins/sql-driver.js";
 import { ABSOLUTE_HOST_PATH_MAX, isAbsoluteHostPath, WEB_ADMIN_ENV } from "@sema-agent/settings-schema";
 const APPROVAL_REACH_WORDS = APPROVAL_REACH.map((word) => JSON.stringify(word)).join(" / ");
 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;
+const MAX_JOB_ID_CHARS = 64;
+const MAX_CLIENT_TIMEZONE_CHARS = 64;
+const MAX_CLIENT_USER_EMAIL_CHARS = 256;
+const MAX_SANDBOX_IMAGE_PROFILE_CHARS = 128;
+const MAX_RESUME_AT_CHARS = 64;
+const overCharsFacts = (field, v, cap) => (typeof v === "string" && v.length > cap ? limitFacts(field, "characters", v.length, cap) : undefined);
+const multiAttemptFields = (body) => {
+    const out = [];
+    if (body.verify === true)
+        out.push("verify");
+    if (body.cascade === true)
+        out.push("cascade");
+    return out;
+};
 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)`;
-        if (s["baseDir"] !== undefined && !isAbsoluteHostPath(s["baseDir"]))
-            return `skill.baseDir must be an absolute path string of at most ${ABSOLUTE_HOST_PATH_MAX} characters with no ".." segment and no NUL byte (it is not resolved or read here — the engine only substitutes it into the skill's own text)`;
-        if (skillCarriesRetiredManifest(s))
-            return SKILL_MANIFEST_RETIRED;
-        for (const key of ["allowedTools", "disallowedTools"]) {
-            if (s[key] !== undefined && !skillToolListOk(s[key]))
-                return `skill.${key} must be an array of strings (permission-rule spellings: a tool name, mcp__<server> / mcp__<server>__*, Bash(<prefix>:*), Read(//<dir>/**))`;
-        }
-        const listRefusal = skillToolListRefusal(s);
-        if (listRefusal !== undefined)
-            return listRefusal;
+        return { message: "skills must be an array of { name, description, content }" };
+    for (let k = 0; k < skills.length; k++) {
+        const shape = userSkillShapeIssue(skills[k], k);
+        if (shape !== null)
+            return shape;
+        const over = skillToolListsOverCap(skills[k], `skills[${k}]`, "top");
+        if (over !== undefined)
+            return { message: over.message, ...(over.extra !== undefined ? { facts: over.extra } : {}) };
+    }
+    return null;
+}
+function userSkillShapeIssue(item, index) {
+    if (item === null || typeof item !== "object")
+        return { message: "each skill must be an object { name, description, content }" };
+    const s = item;
+    if (typeof s["name"] !== "string" || s["name"].length === 0)
+        return { message: "skill.name must be a non-empty string" };
+    if (typeof s["description"] !== "string")
+        return { message: "skill.description must be a string" };
+    if (typeof s["content"] !== "string" || s["content"].length === 0 || s["content"].length > MAX_SKILL_CONTENT_CHARS) {
+        const facts = overCharsFacts(`skills[${index}].content`, s["content"], MAX_SKILL_CONTENT_CHARS);
+        return { message: `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)`, ...(facts === undefined ? {} : { facts }) };
+    }
+    if (s["baseDir"] !== undefined && !isAbsoluteHostPath(s["baseDir"])) {
+        const facts = overCharsFacts(`skills[${index}].baseDir`, s["baseDir"], ABSOLUTE_HOST_PATH_MAX);
+        return { message: `skill.baseDir must be an absolute path string of at most ${ABSOLUTE_HOST_PATH_MAX} characters with no ".." segment and no NUL byte (it is not resolved or read here — the engine only substitutes it into the skill's own text)`, ...(facts === undefined ? {} : { facts }) };
+    }
+    if (skillCarriesRetiredManifest(s))
+        return { message: SKILL_MANIFEST_RETIRED };
+    for (const key of ["allowedTools", "disallowedTools"]) {
+        if (s[key] !== undefined && !skillToolListOk(s[key]))
+            return { message: `skill.${key} must be an array of strings (permission-rule spellings: a tool name, mcp__<server> / mcp__<server>__*, Bash(<prefix>:*), Read(//<dir>/**))` };
     }
     return null;
 }
@@ -60,15 +93,68 @@ function refuseUnavailableModel(res, config, field, ref) {
     const hit = refusedCatalogEntry(ref, config.modelRefusals);
     if (hit === undefined)
         return false;
-    const message = modelUnavailableMessage(field, ref.slice(0, 120), hit.name, hit.refusal);
+    const message = modelUnavailableMessage(field, ref, hit.name, hit.refusal);
     sendError(res, 400, "request.model_unavailable", message);
     return true;
 }
+const kindOf = (v) => (v === null ? "null" : Array.isArray(v) ? "an array" : typeof v === "object" ? "an object" : `a ${typeof v}`);
+function hostPathListRefusal(field, raw) {
+    if (!Array.isArray(raw))
+        return { message: `${field} must be an array of absolute host paths` };
+    if (raw.length > MAX_ADDITIONAL_DIRS)
+        return limitRefusal(field, "entries", raw.length, MAX_ADDITIONAL_DIRS);
+    const index = raw.findIndex((d) => !isAbsoluteHostPath(d));
+    if (index < 0)
+        return undefined;
+    const bad = raw[index];
+    return { message: `${field}[${index}] must be a non-empty absolute host path (no '..' segments) — got ${typeof bad === "string" ? quotedCallerText(bad) : kindOf(bad)}`, facts: { field, reason: "bad_entry", index } };
+}
 const modelIdOf = (model) => (typeof model === "string" ? model : model?.id);
 export function createAdmission(ctx) {
     const { deps, readJson, runnerFor } = ctx;
     async function prepareSpec(req, res, bodyIn, onTypedFailure, legFacts) {
         const body = bodyIn ?? (await readJson(req));
+        {
+            const refusal = refuseSubmitBody(sqlWallsOf(deps.sqlEngine), body);
+            if (refusal !== null) {
+                const facts = { ...limitFacts("body", "bytes", refusal.bytes, refusal.limitBytes), wallSource: refusal.wallSource };
+                switch (refusal.wallSource) {
+                    case "reported":
+                        switch (refusal.by) {
+                            case "row":
+                                sendError(res, 413, "request.payload_too_large", `task body is ${refusal.bytes} bytes, over this deployment's ${refusal.limitBytes}-byte limit: the database stores each submitted task in one row and holds at most ${refusal.wallBytes} bytes per row — shrink the inline images / userAttachments, or ask the operator to raise the database's single-row limit (TiDB performance.txn-entry-size-limit)`, facts);
+                                break;
+                            case "packet":
+                                sendError(res, 413, "request.payload_too_large", `task body is ${refusal.bytes} bytes as sent to the database (JSON text with SQL string escaping), over this deployment's ${refusal.limitBytes}-byte limit: the database takes each submitted task in one statement and accepts at most ${refusal.wallBytes} bytes per statement — shrink the inline images / userAttachments, or ask the operator to raise the database's max_allowed_packet`, facts);
+                                break;
+                            default: {
+                                const unhandled = refusal.by;
+                                throw new Error(`submit body refusal without an HTTP answer: ${String(unhandled)}`);
+                            }
+                        }
+                        break;
+                    case "assumed":
+                        switch (refusal.by) {
+                            case "row":
+                                sendError(res, 413, "request.payload_too_large", `task body is ${refusal.bytes} bytes, over this deployment's ${refusal.limitBytes}-byte limit: the database's single-row limit was not read (engine facts not read yet, or the limit could not be read); refusing conservatively at ${refusal.wallBytes} bytes per row (the smallest documented single-row limit among the supported engines) — retry shortly; if it persists, ask the operator to let the service's database account read the engine's row-size limit`, facts);
+                                break;
+                            case "packet":
+                                sendError(res, 413, "request.payload_too_large", `task body is ${refusal.bytes} bytes as sent to the database (JSON text with SQL string escaping), over this deployment's ${refusal.limitBytes}-byte limit: the database's statement limit was not read (engine facts not read yet, or max_allowed_packet could not be read); refusing conservatively at ${refusal.wallBytes} bytes per statement (smallest documented max_allowed_packet default) — retry shortly; if it persists, ask the operator to check that the service's database account can read max_allowed_packet`, facts);
+                                break;
+                            default: {
+                                const unhandled = refusal.by;
+                                throw new Error(`submit body refusal without an HTTP answer: ${String(unhandled)}`);
+                            }
+                        }
+                        break;
+                    default: {
+                        const unhandled = refusal.wallSource;
+                        throw new Error(`submit body refusal without an HTTP answer: ${String(unhandled)}`);
+                    }
+                }
+                return null;
+            }
+        }
         if (!body || typeof body.objective !== "string") {
             sendError(res, 400, "request.field_invalid", "missing 'objective' string");
             return null;
@@ -84,8 +170,8 @@ export function createAdmission(ctx) {
                 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");
+        if (body.jobId !== undefined && (typeof body.jobId !== "string" || body.jobId.length === 0 || body.jobId.length > MAX_JOB_ID_CHARS)) {
+            sendError(res, 400, "request.field_invalid", "jobId must be a non-empty string of at most 64 characters", overCharsFacts("jobId", body.jobId, MAX_JOB_ID_CHARS));
             return null;
         }
         {
@@ -96,7 +182,7 @@ export function createAdmission(ctx) {
             }
         }
         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`);
+            sendError(res, 400, "request.field_invalid", `systemPrompt must be at most ${MAX_SYSTEM_PROMPT_CHARS} characters`, limitFacts("systemPrompt", "characters", body.systemPrompt.length, MAX_SYSTEM_PROMPT_CHARS));
             return null;
         }
         if (body.appendSystemPrompt !== undefined) {
@@ -105,7 +191,7 @@ export function createAdmission(ctx) {
                 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`);
+                sendError(res, 400, "request.field_invalid", `appendSystemPrompt must be at most ${MAX_SYSTEM_PROMPT_CHARS} characters`, limitFacts("appendSystemPrompt", "characters", body.appendSystemPrompt.length, MAX_SYSTEM_PROMPT_CHARS));
                 return null;
             }
         }
@@ -113,35 +199,13 @@ export function createAdmission(ctx) {
             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) => !isAbsoluteHostPath(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) => !isAbsoluteHostPath(d));
-            if (badRead !== undefined) {
-                sendError(res, 400, "request.field_invalid", "each additionalReadDirectories entry must be a non-empty absolute host path (no '..' segments)");
+        for (const field of ["additionalDirectories", "additionalReadDirectories"]) {
+            const raw = body[field];
+            if (raw === undefined)
+                continue;
+            const refusal = hostPathListRefusal(field, raw);
+            if (refusal !== undefined) {
+                sendError(res, 400, "request.field_invalid", refusal.message, refusal.facts);
                 return null;
             }
         }
@@ -160,14 +224,12 @@ export function createAdmission(ctx) {
                 }
             }
             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`);
+                sendError(res, 400, "request.field_invalid", `settings.outputStyle must be at most ${MAX_SETTINGS_OUTPUT_STYLE_CHARS} characters`, limitFacts("settings.outputStyle", "characters", st.outputStyle.length, MAX_SETTINGS_OUTPUT_STYLE_CHARS));
                 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)`);
+            const foldedChars = typeof st.outputStyle === "string" && st.outputStyle.length > 0 && typeof body.appendSystemPrompt === "string" ? body.appendSystemPrompt.length + 2 + st.outputStyle.length : 0;
+            if (foldedChars > 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)`, fieldConflictFacts("system_prompt_fold", ["appendSystemPrompt", "settings.outputStyle"], { count: foldedChars, cap: MAX_SYSTEM_PROMPT_CHARS }));
                 return null;
             }
             const perms = st.permissions;
@@ -182,6 +244,13 @@ export function createAdmission(ctx) {
                     return null;
                 }
             }
+            {
+                const seatIssue = tightenOnlySeatIssue(st);
+                if (seatIssue) {
+                    sendError(res, 400, "request.field_invalid", seatIssue.message, seatIssue.fields);
+                    return null;
+                }
+            }
             const envRaw = st.env;
             if (envRaw !== undefined && envRaw !== null) {
                 if (typeof envRaw !== "object" || Array.isArray(envRaw)) {
@@ -190,12 +259,16 @@ export function createAdmission(ctx) {
                 }
                 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`);
+                    sendError(res, 400, "request.field_invalid", `settings.env must have at most ${MAX_SETTINGS_ENV_VARS} variables`, limitFacts("settings.env", "entries", entries.length, MAX_SETTINGS_ENV_VARS));
                     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`);
+                    const keyOver = k.length > MAX_SETTINGS_ENV_KEY_CHARS;
+                    const valueOver = typeof val === "string" && val.length > MAX_SETTINGS_ENV_VALUE_CHARS;
+                    if (keyOver || valueOver) {
+                        const field = `settings.env.${echoCallerText(k, { maxChars: MAX_SETTINGS_ENV_KEY_CHARS })}`;
+                        const facts = keyOver ? limitFacts(field, "characters", k.length, MAX_SETTINGS_ENV_KEY_CHARS) : limitFacts(field, "characters", 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`, facts);
                         return null;
                     }
                 }
@@ -215,12 +288,13 @@ export function createAdmission(ctx) {
             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");
+                    const refusal = buildHooksRefusal(hooksParsed.issue);
+                    sendError(res, 400, "request.field_invalid", refusal.message, { field: refusal.field, detail: refusal.detail });
                     return null;
                 }
-                const toolMatcher = toolMatcherIssue(hooksParsed.config, taskHooksHonored(deps.config) ? "regex" : "literal");
+                const toolMatcher = hooksMatcherIssue(hooksParsed.config, taskHooksHonored(deps.config) ? "regex" : "literal");
                 if (toolMatcher !== undefined) {
-                    const refusal = buildToolMatcherRefusal(toolMatcher);
+                    const refusal = buildHooksRefusal(toolMatcher);
                     sendError(res, 400, "request.field_invalid", refusal.message, { field: refusal.field, detail: refusal.detail });
                     return null;
                 }
@@ -235,18 +309,19 @@ export function createAdmission(ctx) {
         }
         const skillsErr = validateUserSkills(body.skills);
         if (skillsErr) {
-            sendError(res, 400, "request.field_invalid", skillsErr);
+            sendError(res, 400, "request.field_invalid", skillsErr.message, skillsErr.facts);
             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`);
+                sendError(res, 413, "request.payload_too_large", `at most ${MAX_IMAGES_PER_REQUEST} images per request`, limitFacts("images", "entries", body.images.length, MAX_IMAGES_PER_REQUEST));
                 return null;
             }
-            for (const img of body.images) {
+            for (const [i, img] of body.images.entries()) {
                 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 (the engine's inline-image limit — the model API's 5 MB image cap)`);
+                const dataBytes = typeof data === "string" ? Buffer.byteLength(data, "utf8") : 0;
+                if (dataBytes > MAX_IMAGE_BASE64_BYTES) {
+                    sendError(res, 413, "request.payload_too_large", `each inline image must be at most ${MAX_IMAGE_BASE64_BYTES} base64 bytes (the engine's inline-image limit — the model API's 5 MB image cap)`, limitFacts(`images[${i}].data`, "bytes", dataBytes, MAX_IMAGE_BASE64_BYTES));
                     return null;
                 }
             }
@@ -257,17 +332,17 @@ export function createAdmission(ctx) {
                 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");
+            if (cc.timeZone !== undefined && (typeof cc.timeZone !== "string" || cc.timeZone.length > MAX_CLIENT_TIMEZONE_CHARS)) {
+                sendError(res, 400, "request.field_invalid", "clientContext.timeZone must be a string of at most 64 characters", overCharsFacts("clientContext.timeZone", cc.timeZone, MAX_CLIENT_TIMEZONE_CHARS));
                 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");
+            if (cc.userEmail !== undefined && (typeof cc.userEmail !== "string" || cc.userEmail.length > MAX_CLIENT_USER_EMAIL_CHARS)) {
+                sendError(res, 400, "request.field_invalid", "clientContext.userEmail must be a string of at most 256 characters", overCharsFacts("clientContext.userEmail", cc.userEmail, MAX_CLIENT_USER_EMAIL_CHARS));
                 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");
+        if (body.sandboxImageProfile !== undefined && (typeof body.sandboxImageProfile !== "string" || body.sandboxImageProfile.length === 0 || body.sandboxImageProfile.length > MAX_SANDBOX_IMAGE_PROFILE_CHARS)) {
+            sendError(res, 400, "request.field_invalid", "sandboxImageProfile must be a non-empty string of at most 128 characters", overCharsFacts("sandboxImageProfile", body.sandboxImageProfile, MAX_SANDBOX_IMAGE_PROFILE_CHARS));
             return null;
         }
         if (body.capabilitiesNeeded !== undefined && (!Array.isArray(body.capabilitiesNeeded) || body.capabilitiesNeeded.some((c) => typeof c !== "string"))) {
@@ -275,11 +350,11 @@ export function createAdmission(ctx) {
             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)");
+            sendError(res, 400, "request.field_conflict", "capabilitiesNeeded requires sandboxImageProfile (it constrains the selected image)", fieldConflictFacts("image_profile", ["capabilitiesNeeded", "sandboxImageProfile"]));
             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)");
+            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)", fieldConflictFacts("cascade_verify", ["sandboxImageProfile", ...multiAttemptFields(body)]));
             return null;
         }
         if (body.outputSchema !== undefined) {
@@ -287,8 +362,9 @@ export function createAdmission(ctx) {
                 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`);
+            const schemaChars = JSON.stringify(body.outputSchema).length;
+            if (schemaChars > MAX_OUTPUT_SCHEMA_CHARS) {
+                sendError(res, 400, "request.field_invalid", `outputSchema must serialize to at most ${MAX_OUTPUT_SCHEMA_CHARS} characters`, limitFacts("outputSchema", "characters", schemaChars, MAX_OUTPUT_SCHEMA_CHARS));
                 return null;
             }
         }
@@ -297,12 +373,12 @@ export function createAdmission(ctx) {
             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)");
+            if (typeof body.resumeAt !== "string" || body.resumeAt.length === 0 || body.resumeAt.length > MAX_RESUME_AT_CHARS) {
+                sendError(res, 400, "request.field_invalid", "resumeAt must be a non-empty message eventId string (≤64 chars)", overCharsFacts("resumeAt", body.resumeAt, MAX_RESUME_AT_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)");
+                sendError(res, 400, "request.field_conflict", "resumeAt is not supported with verify or cascade (those start a fresh/replaced session)", fieldConflictFacts("cascade_verify", ["resumeAt", ...multiAttemptFields(body)]));
                 return null;
             }
         }
@@ -312,7 +388,7 @@ export function createAdmission(ctx) {
                 return null;
             }
             if (body.resumeAt === undefined) {
-                sendError(res, 400, "request.field_conflict", "resumeAtMode requires resumeAt (it qualifies the rewind target)");
+                sendError(res, 400, "request.field_conflict", "resumeAtMode requires resumeAt (it qualifies the rewind target)", fieldConflictFacts("resume_anchor", ["resumeAtMode", "resumeAt"]));
                 return null;
             }
         }
@@ -363,7 +439,7 @@ export function createAdmission(ctx) {
             }
         }
         if (fileHistoryRestoreConflict(body)) {
-            sendError(res, 400, "request.field_conflict", FILE_HISTORY_DISABLED_NO_RESTORE);
+            sendError(res, 400, "request.field_conflict", FILE_HISTORY_DISABLED_NO_RESTORE, fieldConflictFacts("file_history_restore", ["fileHistory", ...fileHistoryRestoreKeysInBody(body)]));
             return null;
         }
         if (body.requireExistingSession !== undefined && typeof body.requireExistingSession !== "boolean") {
@@ -461,7 +537,7 @@ export function createAdmission(ctx) {
         if (body.agents !== undefined) {
             const agentsErr = validateTaskAgents(body.agents);
             if (agentsErr) {
-                sendError(res, 400, "request.field_invalid", agentsErr);
+                sendError(res, 400, "request.field_invalid", agentsErr.message, agentsErr.facts);
                 return null;
             }
             const agentsBare = deps.config.models ?? {};
@@ -470,7 +546,7 @@ export function createAdmission(ctx) {
             if (um !== undefined && refuseUnavailableModel(res, deps.config, `agents[${um.index}].model`, um.ref))
                 return null;
             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) });
+                sendError(res, 400, "request.unknown_reference", `unknown agents[${um.index}].model "${echoModelRef(um.ref)}" — not in the configured catalog (a catalog name or tier word)`, { available: mentionableNames(deps.config, agentsCatalog) });
                 return null;
             }
         }
@@ -497,9 +573,12 @@ export function createAdmission(ctx) {
                 return null;
             }
         }
-        if (body.disableSkills === true && ((body.skills?.length ?? 0) > 0 || (body.agents ?? []).some((a) => (a.skills?.length ?? 0) > 0))) {
-            sendError(res, 400, "request.field_conflict", "disableSkills: true means this run installs no skill at all (not the deployment's, not the request's), so it cannot come with a non-empty skills or agents[].skills — send one or the other");
-            return null;
+        if (body.disableSkills === true) {
+            const skillSeats = [...((body.skills?.length ?? 0) > 0 ? ["skills"] : []), ...(body.agents ?? []).flatMap((a, i) => ((a.skills?.length ?? 0) > 0 ? [`agents[${i}].skills`] : []))];
+            if (skillSeats.length > 0) {
+                sendError(res, 400, "request.field_conflict", "disableSkills: true means this run installs no skill at all (not the deployment's, not the request's), so it cannot come with a non-empty skills or agents[].skills — send one or the other", fieldConflictFacts("skills_disabled", ["disableSkills", ...skillSeats]));
+                return null;
+            }
         }
         {
             const v = body.userInvokedSkills;
@@ -564,7 +643,7 @@ export function createAdmission(ctx) {
             if (matchCatalogModel(body.model, catalog, deps.config.modelRefusals) === undefined) {
                 if (refuseUnavailableModel(res, deps.config, "model", body.model))
                     return null;
-                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) });
+                sendError(res, 400, "request.unknown_reference", `unknown model "${echoModelRef(body.model)}" — not in the configured catalog (name, tier word, or id)`, { available: mentionableNames(deps.config, catalog) });
                 return null;
             }
         }
@@ -578,7 +657,7 @@ export function createAdmission(ctx) {
             if (matchCatalogModel(body.compactionModel, catalog, deps.config.modelRefusals) === undefined) {
                 if (refuseUnavailableModel(res, deps.config, "compactionModel", body.compactionModel))
                     return null;
-                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) });
+                sendError(res, 400, "request.unknown_reference", `unknown compactionModel "${echoModelRef(body.compactionModel)}" — not in the configured catalog (name, tier word, or id)`, { available: mentionableNames(deps.config, catalog) });
                 return null;
             }
         }
@@ -619,17 +698,24 @@ export function createAdmission(ctx) {
         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)");
+            sendError(res, 400, "request.field_conflict", "verify and cascade are mutually exclusive (verify = adversarial gate; cascade = cheap→strong ladder)", fieldConflictFacts("cascade_verify", ["verify", "cascade"]));
             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)");
+            sendError(res, 400, "request.field_conflict", "suggestNextPrompts is not supported with verify or cascade (those return a result, not a streamed run)", fieldConflictFacts("cascade_verify", ["suggestNextPrompts", ...multiAttemptFields(body)]));
             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;
         }
+        {
+            const refusal = requestTrustRefusal({ permissions: parseTaskSettings(body.settings).settings?.permissions, skills: body.skills, userInvokedSkills: body.userInvokedSkills }, callerTrust(req, deps.config));
+            if (refusal !== undefined) {
+                sendError(res, 400, "request.field_invalid", refusal.message, refusal.facts);
+                return null;
+            }
+        }
         const { body: admitted, entry: entryMode } = stampEntryPermissionMode(body, autonomyModeFloor(deps.config.autonomy));
         try {
             const auth = deps.authorize ? await deps.authorize({ req, body: admitted }) : undefined;
@@ -647,7 +733,8 @@ export function createAdmission(ctx) {
             const acceptance = createRunAcceptance({ sessionTitler: deps.sessionTitler }, { ...(spec.sessionId ? { sessionId: spec.sessionId } : {}), objective: spec.objective, ...(model !== undefined ? { model } : {}) });
             const clampNotice = buildEntryModeClampNotice(entryMode, spec.sessionId);
             const pendingNotices = clampNotice !== undefined ? [clampNotice, ...engineNotices] : engineNotices;
-            return { spec, runner: runnerFor(spec), auth, verify, cascade, jobId: admitted.jobId, body: admitted, acceptance, ...(bindingIntent === undefined ? {} : { bindingIntent }), ...(pendingNotices.length > 0 ? { engineNotices: pendingNotices } : {}) };
+            const warnings = allowSelectorWarningsOf(admitted, spec.tools ?? []);
+            return { spec, runner: runnerFor(spec), auth, verify, cascade, jobId: admitted.jobId, body: admitted, acceptance, ...(bindingIntent === undefined ? {} : { bindingIntent }), ...(pendingNotices.length > 0 ? { engineNotices: pendingNotices } : {}), ...(warnings.length > 0 ? { warnings } : {}) };
         }
         catch (err) {
             if (err instanceof HttpError) {