@desplega.ai/agent-swarm 2.0.0 → 2.1.0

package/dist/{http-r7f3eky0.js → http-r2dnb8f8.js}

@@ -19,12 +19,13 @@ import {
   MAX_RATE_LIMIT_RESET_MS
 } from "./cli-2pdaysab.js";
 import {
-  reasoningCapability
-} from "./cli-n5vwg842.js";
+  reasoningCapability,
+  supportedReasoningLevels
+} from "./cli-0veb92a3.js";
 import {
   ensureAgentFsCredentialsForAgent,
   inviteEmailToSharedOrg
-} from "./cli-r2pnvj8g.js";
+} from "./cli-zm9t2vde.js";
 import"./cli-6zx22mv6.js";
 import {
   DEFAULT_CONNECTOR_CODE_LABEL,
@@ -35,16 +36,16 @@ import {
   startPoolRouting,
   stopHeartbeat,
   stopPoolRouting
-} from "./cli-tsde1hdr.js";
+} from "./cli-yjmqpxt3.js";
 import {
   Anthropic
-} from "./cli-4jxm2qtz.js";
+} from "./cli-gxzkg1de.js";
 import {
   runtimeSupervisorStatus,
   startRuntimeSupervisor,
   stopRuntimeSupervisor
-} from "./cli-ke896fcf.js";
-import"./cli-f7kr7svz.js";
+} from "./cli-01xvj1rq.js";
+import"./cli-n8ndw8j7.js";
 import"./cli-knd276ed.js";
 import {
   AGENT_MAX_TASKS_CONFIG_KEY,
@@ -202,6 +203,7 @@ import {
   initAgentMail,
   initApiTelemetry,
   initAzureDevOps,
+  initAzureDevOpsOutbound,
   initGitHub,
   initGitLab,
   initJira,
@@ -344,13 +346,13 @@ import {
   wireHttpSpanLifecycle,
   workflowModelErrors,
   writeUnhandledError
-} from "./cli-bzszjf2p.js";
-import"./cli-zkpks3r3.js";
+} from "./cli-vgqzp4em.js";
+import"./cli-h1arqn31.js";
 import {
   AMP_ESTIMATE_MODELS,
   ampBillsCacheWrites,
   resolveAmpModel
-} from "./cli-hnhtk6cj.js";
+} from "./cli-8wwxw8a3.js";
 import {
   RATING_MODEL_MAX_LENGTH,
   REFERENCES_SOURCE_MAX_LENGTH,
@@ -364,7 +366,7 @@ import {
   loadModelsCatalog,
   requestModelCatalogRefresh,
   upsertModelCatalogOverlay
-} from "./cli-z5jjpaxw.js";
+} from "./cli-0pd8hzhc.js";
 import {
   ConnectionAuthInputSchema,
   MAX_SCRIPT_WALL_CLOCK_MS,
@@ -381,6 +383,7 @@ import {
   buildScriptCredentialBindingsWithFailures,
   callMcpServerTool,
   checkImportAllowlist,
+  checkQuickJSCompat,
   collectScriptReferences,
   computeExpiresAt,
   connectionAuthInputFromFlat,
@@ -421,6 +424,7 @@ import {
   oauthAppToProviderConfig,
   parseSkillContent,
   publicEndpointSsrfOptions,
+  quickJSCompatWarnings,
   readStreamCapped,
   refreshMcpToken,
   refreshScriptConnection,
@@ -443,7 +447,7 @@ import {
   upsertCredentialBinding,
   upsertMcpOAuthToken,
   upsertScriptConnection
-} from "./cli-ee9gtz70.js";
+} from "./cli-4mengw46.js";
 import"./cli-epan13p1.js";
 import {
   detachedProcessGroup,
@@ -458,11 +462,11 @@ import {
   forceRefreshAuthorizationOrThrow,
   forceRefreshTokenOrThrow,
   oauthAppRowToProviderConfig
-} from "./cli-6razj6t4.js";
-import"./cli-5t4f29ez.js";
+} from "./cli-711vwbxn.js";
+import"./cli-wfnemr1t.js";
 import {
   normalizeModelKey
-} from "./cli-r62a35ea.js";
+} from "./cli-hqr88ew6.js";
 import"./cli-6cvfxs8r.js";
 import {
   AgentFsProvider,
@@ -482,14 +486,14 @@ import {
   startWorkflowExecution,
   validateJsonSchema,
   workflowSaveWarnings
-} from "./cli-1e4b6bzh.js";
+} from "./cli-naqzr17j.js";
 import {
   createApprovalFollowUpTask,
   definitionNodeIds,
   generateEdges,
   validateDefinition
-} from "./cli-v1yb0rqb.js";
-import"./cli-se8w6wny.js";
+} from "./cli-20krdhz5.js";
+import"./cli-1y7yywmj.js";
 import {
   CLIENT_ID,
   MAX_CODEX_OAUTH_SLOT,
@@ -500,7 +504,7 @@ import {
   getAccountId,
   getValidCodexOAuth,
   loadAllCodexOAuthSlots
-} from "./cli-e6mpjhed.js";
+} from "./cli-rc6pf5kv.js";
 import"./cli-2x0e561b.js";
 import"./cli-txqb9s38.js";
 import"./cli-h6vtvt5c.js";
@@ -529,7 +533,7 @@ import {
   withRemoteContext,
   withSpan,
   withSpanContext
-} from "./cli-skxvvpap.js";
+} from "./cli-cvv9k0hh.js";
 import"./cli-n2wq4j7m.js";
 import {
   require_content_type
@@ -538,7 +542,7 @@ import"./cli-3er6gcsn.js";
 import"./cli-hjwmhcg1.js";
 import"./cli-rhs9pz33.js";
 import"./cli-9ha6hs2d.js";
-import"./cli-k3dp5tpf.js";
+import"./cli-r610p9bs.js";
 import {
   InvalidRuntimeTokenError,
   RuntimePoolError,
@@ -577,8 +581,8 @@ import {
   unlinkIdentity,
   updateRuntimeController,
   updateRuntimePool
-} from "./cli-eejsgvm4.js";
-import"./cli-ra0xzggj.js";
+} from "./cli-mgz4nbgg.js";
+import"./cli-j67mh2vg.js";
 import {
   bedrockProviderModule
 } from "./cli-hvqbtna4.js";
@@ -605,7 +609,7 @@ import"./cli-pzxba7gw.js";
 import {
   getUserGrant,
   init_rbac_roles
-} from "./cli-74ahz61x.js";
+} from "./cli-d9286m9h.js";
 import {
   LEGACY_RULES,
   can,
@@ -614,7 +618,7 @@ import {
   init_rbac,
   isRbacEnabled,
   setAuditSink
-} from "./cli-przpmdgr.js";
+} from "./cli-sksetb2q.js";
 import {
   API_DRAINING_HEADER,
   CANDIDATE_SET_MULTIPLIER,
@@ -630,6 +634,7 @@ import {
   KvTypeCollisionError,
   MAX_DB_RETENTION_DAYS,
   MEMORY_KEY_MAX_LENGTH,
+  MODEL_PROFILE_CONFIG_KEY,
   NOT_EXTENSION_AGENT_SQL,
   OpenAI,
   ReservedAgentRoleError,
@@ -677,6 +682,7 @@ import {
   createLogEntry,
   createMcpServer,
   createMetric,
+  createModelProfile,
   createOAuthApp,
   createPage,
   createScheduledTask,
@@ -698,6 +704,7 @@ import {
   deleteKv,
   deleteMcpServer,
   deleteMetric,
+  deleteModelProfile,
   deleteOAuthTokens,
   deletePage,
   deletePricingRow,
@@ -772,6 +779,7 @@ import {
   getMetric,
   getMetricVersion,
   getMetricVersions,
+  getModelProfileByName,
   getOAuthApp,
   getOAuthAppById,
   getOAuthTokens,
@@ -861,6 +869,7 @@ import {
   init_human_free,
   init_key_paths,
   init_memory,
+  init_model_profiles,
   init_oauth,
   init_openai,
   init_org_website,
@@ -909,6 +918,7 @@ import {
   listKv,
   listMcpServers,
   listMetricsByAgent,
+  listModelProfiles,
   listPagesByAgent,
   listRecentSessions,
   listScriptApisForScript,
@@ -928,6 +938,8 @@ import {
   markSteeringHandled,
   markSteeringUndeliverable,
   maskSecrets,
+  modelProfileRefError,
+  modelProfileReferences,
   moveAssetKey,
   normalizeDate,
   normalizeOrgWebsite,
@@ -977,6 +989,7 @@ import {
   startTask,
   supersedeTask,
   sweepExpiredKv,
+  taskProfileError,
   telemetry,
   touchScratchScriptLastUsed,
   trackRelayed,
@@ -995,6 +1008,7 @@ import {
   updateAgentStatusFromCapacity,
   updateAuthorizationIdentity,
   updateMetric,
+  updateModelProfile,
   updateOAuthAppById,
   updatePage,
   updateScheduledTask,
@@ -1023,8 +1037,8 @@ import {
   validateConfigValue,
   validateExportToEnv,
   withFavoriteFlags
-} from "./cli-ef1hg1wv.js";
-import"./cli-hnmhtzvh.js";
+} from "./cli-y3167wt1.js";
+import"./cli-9jzdj90z.js";
 import {
   ActiveSessionSchema,
   AgentAcpStatusSchema,
@@ -1083,6 +1097,8 @@ import {
   MetricSchema,
   MetricVersionSchema,
   MetricWidgetSchema,
+  ModelProfileNameSchema,
+  ModelProfileSchema,
   ModelTierSchema,
   OnUnsupportedSchema,
   PageAuthModeSchema,
@@ -1159,12 +1175,12 @@ import {
   isSafeBundlePath,
   isTerminalTaskStatus,
   splitLegacyModelAlias
-} from "./cli-cgtksawx.js";
+} from "./cli-pe05f8yk.js";
 import {
   IDENTITY_FIELD_BUDGETS,
   IdentityFieldBudgetError,
   init_identity_field_budget
-} from "./cli-s2sp957d.js";
+} from "./cli-78vv7446.js";
 import {
   getSlackConfiguration,
   init_config
@@ -1173,7 +1189,7 @@ import {
   init_steering_enabled,
   isSteeringEnabled
 } from "./cli-7mm2r1kp.js";
-import"./cli-5hkm7whv.js";
+import"./cli-x1r545x8.js";
 import"./cli-mvzyxwg3.js";
 import {
   getAllTemplateDefinitions,
@@ -1222,17 +1238,17 @@ import {
 import {
   init_package,
   package_default
-} from "./cli-k382tshb.js";
+} from "./cli-r35rw5de.js";
 import {
   init_event_bus,
   workflowEventBus
-} from "./cli-9nfx44eh.js";
+} from "./cli-z780ec7c.js";
 import {
   init_bus,
   realtimeBus
 } from "./cli-zf8jjwex.js";
 import"./cli-h8w3fg83.js";
-import"./cli-d2qr7aj4.js";
+import"./cli-t02z59f2.js";
 import {
   MAX_PROFILE_FILE_LENGTH,
   agentFsFileRoute,
@@ -1248,7 +1264,7 @@ import {
   parseEnvFlag
 } from "./cli-ej6gbxfb.js";
 import"./cli-1srmzpr3.js";
-import"./cli-tqaazemc.js";
+import"./cli-s69nfyeh.js";
 import {
   getApiKey,
   init_api_key
@@ -1259,7 +1275,7 @@ import {
   registerVolatileSecret,
   scrubObject,
   scrubSecrets
-} from "./cli-p1x85d2t.js";
+} from "./cli-shk7r5cs.js";
 import {
   init_src,
   isAlias
@@ -4048,6 +4064,7 @@ async function handleActiveSessions(req, res, pathSegments, queryParams, myAgent
 init_src();
 init_zod();
 init_db3();
+init_model_profiles();
 init_db2();
 init_telemetry();
 init_types();
@@ -4195,7 +4212,7 @@ var updateAgentRuntimeRoute = route({
   path: "/api/agents/{id}/runtime",
   pattern: ["api", "agents", null, "runtime"],
   summary: "Update an agent's runtime harness and default model",
-  description: "Updates `agents.harness_provider` and agent-scoped runtime config. The settings apply to future provider sessions. For `model`, `reasoning_effort`, and `claude.transport`: omit the field to leave it unchanged, send `null` to clear the corresponding override, or send a value to set it. A `model` the model catalog does not list is a 400 unless `allow_custom_model` is true. A `latest:` alias is not accepted here (aliases resolve for a task's model and for `MODEL_TIER_*` values); `reasoning_effort` must be one the harness and model support.",
+  description: "Updates `agents.harness_provider` and agent-scoped runtime config. The settings apply to future provider sessions. For `model`, `reasoning_effort`, and `claude.transport`: omit the field to leave it unchanged, send `null` to clear the corresponding override, or send a value to set it. A `model` the model catalog does not list is a 400 unless `allow_custom_model` is true. A `latest:` alias is not accepted here (aliases resolve for a task's model and for `MODEL_TIER_*` values); `reasoning_effort` must be one the harness and model support. `profile` sets the agent's default model profile (same tri-state): it must exist and run on `harness_provider`, and it cannot be sent with `model`. Sending `model`, or changing the model or effort override by any path, clears the default profile.",
   tags: ["Agents"],
   params: exports_external.object({ id: exports_external.string() }),
   query: exports_external.object({ repoId: exports_external.string().optional() }),
@@ -4204,6 +4221,7 @@ var updateAgentRuntimeRoute = route({
     model: exports_external.string().trim().min(1).nullable().optional(),
     allow_custom_model: exports_external.boolean().optional().default(false),
     reasoning_effort: ReasoningEffortSchema.nullable().optional(),
+    profile: exports_external.string().trim().min(1).nullable().optional(),
     acp: AcpRuntimeConfigSchema.optional(),
     claude: ClaudeRuntimeConfigSchema.optional()
   }),
@@ -4848,7 +4866,22 @@ async function handleAgentsRest(req, res, pathSegments, queryParams, _myAgentId)
     const parsed = await updateAgentRuntimeRoute.parse(req, res, pathSegments, queryParams);
     if (!parsed)
       return true;
-    const { harness_provider, model, allow_custom_model, reasoning_effort, acp, claude } = parsed.body;
+    const { harness_provider, model, allow_custom_model, reasoning_effort, profile, acp, claude } = parsed.body;
+    if (typeof profile === "string") {
+      if (model !== undefined) {
+        jsonError(res, "Send `profile` or `model`, not both", 400);
+        return true;
+      }
+      const picked = await getModelProfileByName(profile);
+      if (!picked) {
+        jsonError(res, `Unknown model profile "${profile}"`, 400);
+        return true;
+      }
+      if (picked.harness !== harness_provider) {
+        jsonError(res, `Model profile "${profile}" runs on the ${picked.harness} harness, not ${harness_provider}`, 400);
+        return true;
+      }
+    }
     if (acp && harness_provider !== "acp") {
       jsonError(res, "ACP configuration requires harness_provider=acp", 400);
       return true;
@@ -4925,6 +4958,18 @@ async function handleAgentsRest(req, res, pathSegments, queryParams, _myAgentId)
             description: "Set via PATCH /api/agents/{id}/runtime"
           });
         }
+        if (model !== undefined || profile === null) {
+          await deleteSwarmConfigByKey("agent", parsed.params.id, MODEL_PROFILE_CONFIG_KEY);
+        } else if (profile !== undefined) {
+          await upsertSwarmConfig({
+            scope: "agent",
+            scopeId: parsed.params.id,
+            key: MODEL_PROFILE_CONFIG_KEY,
+            value: profile,
+            description: "Default model profile, set via PATCH /api/agents/{id}/runtime",
+            exportToEnv: false
+          });
+        }
         if (claude?.transport === null) {
           await deleteSwarmConfigByKey("agent", parsed.params.id, "CLAUDE_TRANSPORT");
         } else if (claude?.transport !== undefined) {
@@ -5011,6 +5056,10 @@ async function handleAgentsRest(req, res, pathSegments, queryParams, _myAgentId)
         jsonError(res, error.message, 400);
         return true;
       }
+      if (modelProfileRefError(error) === "missing") {
+        jsonError(res, `Unknown model profile "${profile}"`, 400);
+        return true;
+      }
       throw error;
     }
     if (!agent) {
@@ -7511,6 +7560,7 @@ init_secret_scrubber();
 // src/http/config.ts
 init_zod();
 init_db3();
+init_model_profiles();
 
 // src/be/org-profile.ts
 init_org_website();
@@ -7553,6 +7603,16 @@ function singleHeader(req, name) {
   const raw = req.headers[name];
   return Array.isArray(raw) ? raw[0] : raw;
 }
+function readsRepoSecrets(auth, agent) {
+  if (auth?.kind !== "agent" || !auth.runtimeId)
+    return true;
+  return can({
+    principal: { kind: "agent", agentId: auth.agentId, isLead: agent?.isLead ?? false },
+    verb: "config.read.secrets",
+    resource: { kind: "none" },
+    source: "http"
+  }).allow;
+}
 async function requestSecretReadScope(req, resolvedScope) {
   const auth = getRequestAuth(req);
   if (auth?.kind === "operator")
@@ -7908,7 +7968,11 @@ async function handleConfig(req, res, pathSegments, queryParams) {
       }
       const result = includeSecrets || !config.isSecret ? config : maskSecrets([config])[0];
       upsertConfig.respond(res, 200, result);
-    } catch (_error) {
+    } catch (error) {
+      if (modelProfileRefError(error) === "missing") {
+        jsonError(res, `Unknown model profile "${String(value)}"`, 400);
+        return true;
+      }
       jsonError(res, "Failed to upsert config", 500);
     }
     return true;
@@ -9118,6 +9182,7 @@ declare module "swarm-extension" {
     model?: string | undefined;
     modelTier?: "smol" | "regular" | "smart" | "ultra" | undefined;
     effort?: "off" | "low" | "medium" | "high" | "xhigh" | "max" | undefined;
+    profile?: string | undefined;
     scheduleId?: string | undefined;
     workflowRunId?: string | undefined;
     workflowRunStepId?: string | undefined;
@@ -9252,6 +9317,8 @@ declare module "swarm-extension" {
     modelSource?: string | undefined;
     modelAlias?: string | undefined;
     resolvedEffort?: "off" | "low" | "medium" | "high" | "xhigh" | "max" | undefined;
+    profile?: string | undefined;
+    resolvedProfile?: string | undefined;
     scheduleId?: string | undefined;
     workflowRunId?: string | null | undefined;
     workflowRunStepId?: string | null | undefined;
@@ -9931,6 +9998,512 @@ void _configIsValid;
 
 // src/extensions/catalog.generated.json
 var catalog_generated_default = {
+  "comms-adherence-gate": {
+    manifestFile: "manifest.json",
+    manifest: {
+      $schema: "../manifest.schema.json",
+      name: "comms-adherence-gate",
+      description: "Judges every Slack-facing store-progress completion against the requester's comms preferences and latest request with Jev (TypeSafe or OpenRouter), and in enforce blocks a non-adherent completion once per task",
+      version: "1.5.0",
+      runtime: "api",
+      assets: {
+        hooks: "hooks.ts"
+      }
+    },
+    files: {
+      "hooks.ts": `import { type ApiCtx, block, type SwarmExtension } from "swarm-extension";
+import { z } from "zod";
+
+/**
+ * comms-adherence-gate
+ *
+ * When an agent calls \`store-progress\` with status "completed" on a task that
+ * reaches a human in Slack, judge the \`output\` against the requesting user's
+ * stored comms preferences (users.metadata.$.comms) with Jev, and against what
+ * that user actually asked for in their latest message. An explicit request
+ * ("tell me a long joke", "explain in detail") outranks the stored default, so
+ * a requested long answer is not a verbosity failure.
+ *
+ * Transport (config.provider): Jev is served by TypeSafe directly and by
+ * OpenRouter's Decisions endpoint. Both take the same {model, state, questions}
+ * body and return the same \`answers\` shape. \`auto\` uses TYPESAFE_API_KEY when
+ * set, else OPENROUTER_API_KEY.
+ *
+ * modes (config.mode):
+ *   off     -> never evaluate
+ *   shadow  -> evaluate + record, never block (default)
+ *   enforce -> record, and block the completion up to maxBlocksPerTask times
+ *              per task with actionable feedback
+ *
+ * Fails OPEN on every error: a judge outage must never wall the swarm.
+ * Every verdict lands in KV namespace \`ext:comms-gate\`.
+ */
+
+export const config = z.object({
+  mode: z.enum(["off", "shadow", "enforce"]).default("shadow"),
+  /** A dimension scoring below this fails. */
+  threshold: z.number().min(0).max(1).default(0.5),
+  timeoutMs: z.number().int().positive().default(4000),
+  maxBlocksPerTask: z.number().int().min(0).default(1),
+  provider: z.enum(["auto", "typesafe", "openrouter"]).default("auto"),
+  /** Jev model on the TypeSafe transport. */
+  model: z.string().default("jev-latest"),
+  /** Jev model on the OpenRouter transport. */
+  openrouterModel: z.string().default("typesafe/jev-1.13"),
+  /** Explicit TypeSafe key; otherwise TYPESAFE_API_KEY from the API process env. */
+  apiKey: z.string().optional(),
+});
+
+type Cfg = z.infer<typeof config>;
+type Swarm = ApiCtx["swarm"];
+
+const NS = "ext:comms-gate";
+const TYPESAFE_ENDPOINT = "https://api.typesafe.ai/v1/systemone";
+const OPENROUTER_ENDPOINT = "https://openrouter.ai/api/alpha/decisions";
+const UUID_RE = /^[0-9a-fA-F-]{36}$/;
+// The dispatcher cancels a handler after 5 s; leave room for the DB read and KV writes.
+const MAX_TIMEOUT_MS = 4000;
+
+export const cfgOf = (raw: unknown): Cfg => {
+  const parsed = config.safeParse(raw ?? {});
+  return parsed.success ? parsed.data : config.parse({});
+};
+
+// kv keys accept [a-zA-Z0-9._:/%-]
+const safeKey = (raw: string | undefined | null): string =>
+  (raw && raw.length > 0 ? raw : "unknown").replace(/[^a-zA-Z0-9._-]/g, "_").slice(0, 120);
+
+/** SDK envelopes: {success, data:{...}} or the bare payload. */
+type Envelope = {
+  data?: { rows?: unknown[]; value?: unknown };
+  rows?: unknown[];
+  value?: unknown;
+} | null;
+
+const cell = (row: unknown, i: number, key: string): unknown =>
+  Array.isArray(row) ? row[i] : (row as Record<string, unknown>)?.[key];
+
+/**
+ * The newest human message sits at the END of a Slack task: the
+ * \`<thread_context>\` blob comes first and can run to thousands of chars, so a
+ * leading slice of \`agent_tasks.task\` shows the judge everything except the
+ * actual request. Take the tail, then the part after the last \`</thread_context>\`.
+ */
+const CTX_END = "</thread_context>";
+export const latestAsk = (tail: string): string => {
+  const end = tail.lastIndexOf(CTX_END);
+  let out = (end >= 0 ? tail.slice(end + CTX_END.length) : tail)
+    .replace(/\\[Thread follow-up[^\\]]*\\]/g, "")
+    .trim();
+  // Some tasks end with the context block; fall back to the last messages in it.
+  if (out.length < 8) out = (end >= 0 ? tail.slice(0, end) : tail).trim().slice(-800);
+  return out.slice(0, 900);
+};
+
+// Preferences are the DEFAULT. A direct request outranks them.
+const JUDGING_RULES = [
+  "The requester's explicit instruction in latest_request OUTRANKS requester_preferences. Preferences describe the DEFAULT; they never override a direct request.",
+  "If latest_request asks for something long, detailed, creative, a story, a joke, a full explanation or a document, then length and structure serving that request are CORRECT and must NOT be penalized.",
+  "Judge whether agent_message serves what latest_request actually asked for, written in the requester's manner. Do not judge it against the default preference when the request overrides it.",
+];
+
+type Prefs = { verbosity?: unknown; tone?: unknown; language?: unknown } & Record<string, unknown>;
+
+/** One \`noul\` question per stated preference the gate knows how to judge. */
+export const buildQuestions = (prefs: Prefs): Record<string, unknown> => {
+  const questions: Record<string, unknown> = {};
+  if (prefs.verbosity) {
+    questions.verbosity = {
+      type: "noul",
+      instructions:
+        "Does agent_message respect the requester's verbosity preference, AS OVERRIDDEN by any explicit instruction in latest_request? Apply judging_rules.",
+      criteria: {
+        true: "Length and structure fit what latest_request asked for (or the stated preference when the request does not override it), and it leads with the result.",
+        false:
+          "Too long for what was asked, or it opens with preamble, recaps the request, narrates the process, or ends with an offer to elaborate. Length explicitly requested in latest_request is NOT a failure.",
+      },
+    };
+  }
+  if (prefs.tone) {
+    questions.tone = {
+      type: "noul",
+      instructions:
+        "Does agent_message match the requester's stated tone preference, as overridden by any explicit instruction in latest_request? Apply judging_rules.",
+      criteria: {
+        true: "The tone matches what the requester asked for.",
+        false:
+          "The tone conflicts with it (for example hedging, flattery or filler when the requester asked for direct and plain). A voice appropriate to an explicitly requested creative or narrative form is NOT a failure.",
+      },
+    };
+  }
+  if (prefs.language) {
+    questions.language = {
+      type: "noul",
+      instructions: "Is agent_message written in the requester's stated language?",
+      criteria: {
+        true: "Written in the stated language.",
+        false: "Written in a different language.",
+      },
+    };
+  }
+  return questions;
+};
+
+const secretCache = new Map<string, { value: string; at: number }>();
+const KEY_TTL_MS = 5 * 60 * 1000;
+const usable = (v: string): boolean => Boolean(v) && !v.startsWith("[REDACTED");
+const envOf = (name: string): string => String(process.env[name] ?? "");
+
+/**
+ * Resolve a secret: explicit value, then the API process env. The API process loads
+ * global swarm_config rows into process.env at boot and on config reload.
+ * ctx.swarm.config_get cannot serve it: the SDK scrubs secrets to "[REDACTED:<name>]".
+ */
+const secret = (name: string, explicit?: string): string => {
+  const cached = secretCache.get(name);
+  if (cached && Date.now() - cached.at < KEY_TTL_MS) return cached.value;
+  const value = [String(explicit ?? ""), envOf(name)].find(usable) ?? "";
+  if (usable(value)) secretCache.set(name, { value, at: Date.now() });
+  return value;
+};
+
+/** Test hook: forget cached secrets. */
+export const resetKeyCache = (): void => {
+  secretCache.clear();
+};
+
+export type JevTransport = {
+  provider: "typesafe" | "openrouter";
+  endpoint: string;
+  key: string;
+  model: string;
+};
+
+/**
+ * Pick the Jev transport. \`auto\` prefers TypeSafe and falls back to OpenRouter.
+ * Throws when the chosen provider has no usable key; the handler fails open.
+ */
+export const resolveTransport = (cfg: Cfg): JevTransport => {
+  const typesafe = (): JevTransport | null => {
+    const key = secret("TYPESAFE_API_KEY", cfg.apiKey);
+    return usable(key)
+      ? { provider: "typesafe", endpoint: TYPESAFE_ENDPOINT, key, model: cfg.model }
+      : null;
+  };
+  const openrouter = (): JevTransport | null => {
+    const key = secret("OPENROUTER_API_KEY");
+    return usable(key)
+      ? { provider: "openrouter", endpoint: OPENROUTER_ENDPOINT, key, model: cfg.openrouterModel }
+      : null;
+  };
+  const transport =
+    cfg.provider === "typesafe"
+      ? typesafe()
+      : cfg.provider === "openrouter"
+        ? openrouter()
+        : (typesafe() ?? openrouter());
+  if (transport) return transport;
+  throw new Error(
+    cfg.provider === "typesafe"
+      ? "no TYPESAFE_API_KEY"
+      : cfg.provider === "openrouter"
+        ? "no OPENROUTER_API_KEY"
+        : "no TYPESAFE_API_KEY or OPENROUTER_API_KEY",
+  );
+};
+
+/** One Jev call; returns the \`noul\` score per question. Throws on any failure. */
+export const askJev = async (
+  state: Record<string, unknown>,
+  questions: Record<string, unknown>,
+  transport: JevTransport,
+  cfg: Cfg,
+  outer?: AbortSignal,
+): Promise<{ scores: Record<string, number>; latencyMs: number }> => {
+  const controller = new AbortController();
+  const timer = setTimeout(() => controller.abort(), Math.min(cfg.timeoutMs, MAX_TIMEOUT_MS));
+  const onOuterAbort = () => controller.abort();
+  outer?.addEventListener("abort", onOuterAbort);
+  const t0 = Date.now();
+  try {
+    const res = await fetch(transport.endpoint, {
+      method: "POST",
+      headers: { "Content-Type": "application/json", Authorization: \`Bearer \${transport.key}\` },
+      body: JSON.stringify({ state, model: transport.model, questions }),
+      signal: controller.signal,
+    });
+    if (!res.ok) throw new Error(\`\${transport.provider} \${res.status}\`);
+    const body = (await res.json()) as { answers?: Record<string, { noul?: unknown }> } | null;
+    const answers = body?.answers;
+    if (!answers || typeof answers !== "object") throw new Error("no answers in response");
+    const scores: Record<string, number> = {};
+    for (const [id, a] of Object.entries(answers)) {
+      if (typeof a?.noul === "number") scores[id] = a.noul;
+    }
+    if (Object.keys(scores).length === 0) throw new Error("no scores in response");
+    return { scores, latencyMs: Date.now() - t0 };
+  } finally {
+    clearTimeout(timer);
+    outer?.removeEventListener("abort", onOuterAbort);
+  }
+};
+
+const SELFTEST = "comms-gate-selftest";
+const SELFTEST_PREFS = {
+  tone: "direct, plain, no hedging",
+  language: "English",
+  verbosity:
+    "very terse - answer in the first sentence, ~400 chars max. No preamble, no recap, no closing offer.",
+};
+const SELFTEST_BAD =
+  "Great question! Let me walk you through what I did here. First I looked at the task, then I reviewed the relevant files, and after careful consideration I decided to go with option B. I hope this helps - let me know if you would like me to elaborate further on any of the above!";
+const SELFTEST_GOOD =
+  "Went with option B: it is the only one that keeps the migration reversible. PR #123.";
+
+/**
+ * Run the judge on a known-bad (positive control, must score below threshold) and a
+ * known-good (negative control, must score at or above it) message and record both
+ * under \`selftest:last\`. Proves key, egress and KV from inside the API runtime
+ * without touching real traffic.
+ */
+const selfTest = async (swarm: Swarm, cfg: Cfg, signal?: AbortSignal): Promise<void> => {
+  const started = Date.now();
+  try {
+    const transport = resolveTransport(cfg);
+    const questions = { verbosity: buildQuestions(SELFTEST_PREFS).verbosity };
+    const judge = (message: string) =>
+      askJev(
+        { requester_preferences: SELFTEST_PREFS, agent_message: message },
+        questions,
+        transport,
+        cfg,
+        signal,
+      ).then((r) => r.scores.verbosity ?? null);
+    const [bad, good] = await Promise.all([judge(SELFTEST_BAD), judge(SELFTEST_GOOD)]);
+    await swarm.kv_set({
+      namespace: NS,
+      key: "selftest:last",
+      value: {
+        at: new Date().toISOString(),
+        provider: transport.provider,
+        threshold: cfg.threshold,
+        positiveControlBadScore: bad,
+        negativeControlGoodScore: good,
+        controlsOk:
+          typeof bad === "number" &&
+          typeof good === "number" &&
+          bad < cfg.threshold &&
+          good >= cfg.threshold,
+        latencyMs: Date.now() - started,
+      },
+    });
+  } catch (err) {
+    await swarm
+      .kv_set({
+        namespace: NS,
+        key: "selftest:last",
+        value: {
+          at: new Date().toISOString(),
+          error: String(err).slice(0, 400),
+          latencyMs: Date.now() - started,
+        },
+      })
+      .catch(() => {});
+  }
+};
+
+const TASK_SQL = \`SELECT t.source, t.slackThreadTs, t.agentId, t.requestedByUserId,
+       json_extract(u.metadata, '$.comms') AS comms, u.name,
+       substr(t.task, 1, 400) AS askHead,
+       substr(t.task, -1400) AS askTail
+FROM agent_tasks t
+LEFT JOIN users u ON u.id = t.requestedByUserId
+WHERE t.id = ?\`;
+
+const LEAD_SQL = "SELECT isLead FROM agents WHERE id = ?";
+
+/**
+ * Mirrors the \`task.progress.write\` rule store-progress enforces
+ * (src/rbac/legacy-policy.ts): the caller owns the task, the task is
+ * unassigned, or the caller is a lead. Lead status comes from the caller's
+ * agents row, never from tool args. Extension callers return before this.
+ */
+const mayWriteProgress = async (
+  swarm: Swarm,
+  callerId: string | undefined,
+  taskAgentId: string,
+): Promise<boolean> => {
+  if (!callerId) return false;
+  if (!taskAgentId || taskAgentId === callerId) return true;
+  const q = (await swarm.db_query({ sql: LEAD_SQL, params: [callerId] })) as Envelope;
+  const row = (q?.data?.rows ?? q?.rows ?? [])[0];
+  return Number(cell(row, 0, "isLead") ?? 0) === 1;
+};
+
+const extension: SwarmExtension = (api) => {
+  api.on("pre.tool.call", async (event, ctx) => {
+    if (event.tool !== "store-progress") return;
+    if (event.requestInfo?.callOrigin === "extension") return;
+
+    const cfg = cfgOf(ctx.config);
+    if (cfg.mode === "off") return;
+
+    const args = (event.args ?? {}) as Record<string, unknown>;
+
+    // Self-test hatch: a progress call whose text starts with the sentinel runs
+    // the controls and records them under \`selftest:last\`.
+    if (args.status !== "completed") {
+      if (typeof args.progress === "string" && args.progress.startsWith(SELFTEST)) {
+        await selfTest(ctx.swarm, cfg, ctx.signal);
+      }
+      return;
+    }
+
+    const output = typeof args.output === "string" ? args.output.trim() : "";
+    if (!output) return;
+
+    const taskId = String(args.taskId ?? event.requestInfo?.sourceTaskId ?? "");
+    if (!UUID_RE.test(taskId)) return;
+
+    try {
+      const q = (await ctx.swarm.db_query({ sql: TASK_SQL, params: [taskId] })) as Envelope;
+      const row = (q?.data?.rows ?? q?.rows ?? [])[0];
+      if (!row) return;
+
+      const source = String(cell(row, 0, "source") ?? "");
+      const slackThreadTs = cell(row, 1, "slackThreadTs");
+      const agentId = String(cell(row, 2, "agentId") ?? "");
+      const requesterId = String(cell(row, 3, "requestedByUserId") ?? "");
+      const commsRaw = cell(row, 4, "comms");
+      const requesterName = String(cell(row, 5, "name") ?? requesterId);
+      const threadOpening = String(cell(row, 6, "askHead") ?? "");
+      const ask = latestAsk(String(cell(row, 7, "askTail") ?? ""));
+
+      // Judge only a completion store-progress will accept, so no agent can ship
+      // another task's thread and preferences to the external judge.
+      if (!(await mayWriteProgress(ctx.swarm, event.requestInfo?.agentId, agentId))) return;
+
+      // Only where the text actually reaches a human in Slack.
+      if (source !== "slack" && !slackThreadTs) return;
+      if (!commsRaw) return; // no stated preferences -> nothing to judge against
+      const prefs = (typeof commsRaw === "string" ? JSON.parse(commsRaw) : commsRaw) as Prefs;
+      if (!prefs || typeof prefs !== "object") return;
+
+      const questions = buildQuestions(prefs);
+      if (Object.keys(questions).length === 0) return;
+
+      const transport = resolveTransport(cfg);
+      const { scores, latencyMs } = await askJev(
+        {
+          role: "You audit an AI agent's final message to the human who requested the work.",
+          requester: requesterName,
+          requester_preferences: prefs,
+          latest_request: ask,
+          thread_opening: threadOpening,
+          judging_rules: JUDGING_RULES,
+          agent_message: output,
+        },
+        questions,
+        transport,
+        cfg,
+        ctx.signal,
+      );
+
+      const failed = Object.entries(scores)
+        .filter(([, v]) => v < cfg.threshold)
+        .map(([k]) => k);
+
+      const verdict = {
+        at: new Date().toISOString(),
+        taskId,
+        agentId,
+        source,
+        requester: requesterName,
+        requesterId,
+        provider: transport.provider,
+        scores,
+        failed,
+        threshold: cfg.threshold,
+        mode: cfg.mode,
+        latencyMs,
+        preferences: prefs,
+        askPreview: ask.slice(0, 400),
+        outputPreview: output.slice(0, 700),
+      };
+
+      await ctx.swarm.kv_incr({ namespace: NS, key: "total" });
+      await ctx.swarm.kv_set({ namespace: NS, key: "last", value: verdict });
+
+      if (failed.length === 0) {
+        await ctx.swarm.kv_incr({ namespace: NS, key: "pass" });
+        return;
+      }
+
+      await ctx.swarm.kv_incr({ namespace: NS, key: "fail" });
+      for (const dim of failed) {
+        await ctx.swarm.kv_incr({ namespace: NS, key: \`dim:\${safeKey(dim)}\` });
+      }
+
+      const blocksKey = \`blocks:\${safeKey(taskId)}\`;
+      // kv_get answers {success, data:{value}}, and {success:false} when absent.
+      const prior = (await ctx.swarm.kv_get({ namespace: NS, key: blocksKey })) as Envelope;
+      const priorBlocks = Number(prior?.data?.value ?? prior?.value ?? 0) || 0;
+      const willBlock = cfg.mode === "enforce" && priorBlocks < cfg.maxBlocksPerTask;
+
+      await ctx.swarm.kv_set({
+        namespace: NS,
+        key: \`fail:\${Date.now()}:\${safeKey(taskId)}\`,
+        value: { ...verdict, action: willBlock ? "blocked" : "recorded" },
+      });
+
+      if (!willBlock) {
+        await ctx.swarm.kv_incr({
+          namespace: NS,
+          key: cfg.mode === "enforce" ? "escaped" : "shadowed",
+        });
+        return;
+      }
+
+      await ctx.swarm.kv_incr({ namespace: NS, key: "blocked" });
+      await ctx.swarm.kv_incr({ namespace: NS, key: blocksKey });
+
+      const detail = failed
+        .map(
+          (d) =>
+            \`\${d} (\${scores[d]!.toFixed(2)} vs \${cfg.threshold}) — requested: \${String(prefs[d] ?? "").slice(0, 220)}\`,
+        )
+        .join("\\n");
+
+      return block(
+        [
+          \`Comms gate: this output does not match \${requesterName}'s stated preferences.\`,
+          detail,
+          "Rewrite the output to match and call store-progress again. Do not change the facts, only how they are said.",
+        ].join("\\n"),
+      );
+    } catch (err) {
+      // Fail open, always.
+      try {
+        await ctx.swarm.kv_incr({ namespace: NS, key: "error" });
+        await ctx.swarm.kv_set({
+          namespace: NS,
+          key: "error:last",
+          value: { at: new Date().toISOString(), taskId, error: String(err).slice(0, 400) },
+        });
+      } catch {
+        /* ignore */
+      }
+      ctx.log.warn("comms-adherence-gate: failing open", { error: String(err) });
+      return;
+    }
+  });
+};
+
+export default extension;
+`
+    },
+    readme: '# comms-adherence-gate\n\nAgents finish Slack tasks with a final message a human reads. This extension judges that message against the requester\'s stated comms preferences and their latest request with Jev, [TypeSafe](https://typesafe.ai)\'s decision model. In `enforce` it blocks a non-adherent completion once and tells the agent what to fix.\n\nInstall config:\n\n```json\n{ "mode": "shadow" }\n```\n\nStart in `shadow`, read the verdicts in KV for a few days, then switch to `enforce`.\n\n## Modes\n\n| `mode` | Effect |\n|---|---|\n| `off` | Never evaluates. |\n| `shadow` (default) | Asks Jev and records the verdict. Never blocks. |\n| `enforce` | Asks Jev, records the verdict, and blocks the `store-progress` call when a dimension fails, at most `maxBlocksPerTask` times per task. The agent gets the failed dimensions, their scores and the stated preference, and calls again. |\n\n## What it gates\n\nHook: `pre.tool.call` on `store-progress` with `status: "completed"` and a non-empty `output`. Calls made by extensions are skipped. The task must:\n\n1. Come from Slack (`source = "slack"` or a `slackThreadTs`). Other tasks pass without a Jev call.\n2. Have a requester with stated preferences in `users.metadata.comms`. A requester with none passes. Set them with the `manage-user` tool.\n\n## Decision\n\nThe gate reads the task row and asks one `noul` question per stated preference it knows: `verbosity`, `tone`, `language`. Any other key in `comms` is context only.\n\nJev sees the preferences, the requester\'s latest message (the text after the last `</thread_context>`, from the last 1,400 characters of the task), the first 400 characters of the task, and the output. Its judging rules say an explicit request outranks the stored default. A requested long answer, story or document is not a verbosity failure.\n\nA dimension fails when its score is below `threshold`. Any failed dimension fails the output.\n\n## Jev transport\n\nJev is reachable two ways. Both take the same request and return the same answer.\n\n| `provider` | Endpoint | Key | Model |\n|---|---|---|---|\n| `typesafe` | `POST https://api.typesafe.ai/v1/systemone` | `TYPESAFE_API_KEY` (or `apiKey`) | `model`, default `jev-latest` |\n| `openrouter` | `POST https://openrouter.ai/api/alpha/decisions` | `OPENROUTER_API_KEY` | `openrouterModel`, default `typesafe/jev-1.13` |\n| `auto` (default) | TypeSafe when its key is set, else OpenRouter | | |\n\nEach verdict row records the `provider` that answered.\n\n## Fail open\n\nEvery error lets the completion through: a missing key, an HTTP error, a network error, a timeout, a malformed answer, or a failed DB read. The handler never throws, so an outage cannot auto-disable the extension. Each failure bumps the `error` counter and overwrites `error:last`.\n\n## Self-test\n\nCall `store-progress` with a non-completed status and `progress` starting with `comms-gate-selftest`. The gate judges a known-bad and a known-good message against a terse preference and writes `selftest:last`: both scores, the threshold, the provider, and `controlsOk` (bad below threshold and good at or above it). Real traffic is untouched.\n\n## Config\n\n| Key | Default | Notes |\n|---|---|---|\n| `mode` | `shadow` | `off`, `shadow`, or `enforce` |\n| `threshold` | `0.5` | A dimension scoring below this fails |\n| `timeoutMs` | `4000` | Jev call timeout, capped at 4000 (the dispatcher cancels a handler at 5 s) |\n| `maxBlocksPerTask` | `1` | Blocks per task in `enforce`; after that the gate records and lets it through |\n| `provider` | `auto` | `auto`, `typesafe`, or `openrouter`. See [Jev transport](#jev-transport) |\n| `model` | `jev-latest` | Jev model on TypeSafe |\n| `openrouterModel` | `typesafe/jev-1.13` | Jev model on OpenRouter |\n| `apiKey` | unset | Explicit TypeSafe key. Prefer the `TYPESAFE_API_KEY` secret below |\n\n## Required secrets\n\nRead from the API process environment at call time. Set them as global `swarm_config` secrets: the API process loads global rows into `process.env` at boot and on config reload.\n\n- `TYPESAFE_API_KEY` or `OPENROUTER_API_KEY`: one is required for any evaluation. Under `auto`, TypeSafe wins when both are set. Without either, every completion fails open.\n\nNo key is written to config, KV, logs, or a block reason.\n\n## KV namespace `ext:comms-gate`\n\n- `last`: the latest verdict, with `scores`, `failed`, `provider`, `latencyMs`, the preferences, a 400-character `askPreview` and a 700-character `outputPreview`.\n- `fail:<epochMs>:<taskId>`: one row per failed verdict, with `action` (`blocked` or `recorded`).\n- `blocks:<taskId>`: blocks issued for that task.\n- `error:last`, `selftest:last`.\n- Counters: `total`, `pass`, `fail`, `blocked`, `escaped` (enforce, block budget spent), `shadowed`, `error`, and `dim:<dimension>`.\n\n## Known limits\n\n- Only the last 1,400 characters of the task are searched for the latest request. A very long final message is cut to its last 900 characters.\n- The block budget is per task, so a retried completion after a block goes through once the budget is spent, even if it still fails.\n'
+  },
   "deploy-awareness": {
     manifestFile: "manifest.json",
     manifest: {
@@ -18907,6 +19480,237 @@ async function handleMetrics(req, res, pathSegments, queryParams, myAgentId) {
   return false;
 }
 
+// src/http/model-profiles.ts
+init_src();
+init_zod();
+init_model_profiles();
+init_rbac();
+init_types();
+var listProfiles = route({
+  method: "get",
+  path: "/api/model-profiles",
+  pattern: ["api", "model-profiles"],
+  summary: "List model profiles",
+  description: "Every model profile, ordered by harness then name. Filter by `harness` to see what an agent on that harness can run.",
+  tags: ["Models"],
+  query: exports_external.object({ harness: ProviderNameSchema.optional() }),
+  responses: {
+    200: {
+      description: "Model profiles",
+      schema: exports_external.object({ profiles: exports_external.array(ModelProfileSchema) })
+    }
+  }
+});
+var getProfile = route({
+  method: "get",
+  path: "/api/model-profiles/{name}",
+  pattern: ["api", "model-profiles", null],
+  summary: "Get one model profile",
+  tags: ["Models"],
+  params: exports_external.object({ name: exports_external.string() }),
+  responses: {
+    200: { description: "The model profile", schema: ModelProfileSchema },
+    404: { description: "No profile with that name" }
+  }
+});
+var createProfile = route({
+  method: "post",
+  path: "/api/model-profiles",
+  pattern: ["api", "model-profiles"],
+  summary: "Create a model profile",
+  description: "A profile runs on one harness. `model` must run on that harness and be in the model catalog unless `allowCustomModel` is true (a gateway id, a fresh launch); a `latest:` alias is accepted and resolves at claim. `effort` must be a level the harness and model support. Operator only (the shared API key).",
+  tags: ["Models"],
+  rbac: { permission: "models.profiles.write" },
+  body: exports_external.object({
+    name: ModelProfileNameSchema,
+    harness: ProviderNameSchema,
+    model: exports_external.string().trim().min(1),
+    effort: ReasoningEffortSchema.nullable().optional(),
+    allowCustomModel: exports_external.boolean().optional().default(false),
+    description: exports_external.string().trim().max(500).nullable().optional()
+  }),
+  responses: {
+    201: { description: "Profile created", schema: ModelProfileSchema },
+    400: { description: "Validation error" },
+    403: { description: "Forbidden" },
+    409: { description: "A profile with that name exists" }
+  }
+});
+var updateProfile = route({
+  method: "patch",
+  path: "/api/model-profiles/{name}",
+  pattern: ["api", "model-profiles", null],
+  summary: "Update a model profile",
+  description: "Changes the model, effort, custom-model flag or description; the name and harness are fixed. Omit a field to keep it; `effort: null` clears it. Applies to tasks claimed after the change. Operator only (the shared API key).",
+  tags: ["Models"],
+  rbac: { permission: "models.profiles.write" },
+  params: exports_external.object({ name: exports_external.string() }),
+  body: exports_external.object({
+    model: exports_external.string().trim().min(1).optional(),
+    effort: ReasoningEffortSchema.nullable().optional(),
+    allowCustomModel: exports_external.boolean().optional(),
+    description: exports_external.string().trim().max(500).nullable().optional()
+  }),
+  responses: {
+    200: { description: "Profile updated", schema: ModelProfileSchema },
+    400: { description: "Validation error" },
+    403: { description: "Forbidden" },
+    404: { description: "No profile with that name" }
+  }
+});
+var deleteProfile = route({
+  method: "delete",
+  path: "/api/model-profiles/{name}",
+  pattern: ["api", "model-profiles", null],
+  summary: "Delete a model profile",
+  description: "Refused (409) for a shipped `<harness>-<tier>` seed (edit it instead; it would come back at the next boot), and while an agent has the profile as its default or a task holds it (unfinished, or superseded and still owed its resume). Operator only (the shared API key).",
+  tags: ["Models"],
+  rbac: { permission: "models.profiles.write" },
+  params: exports_external.object({ name: exports_external.string() }),
+  responses: {
+    200: { description: "Profile deleted", schema: exports_external.object({ deleted: exports_external.literal(true) }) },
+    403: { description: "Forbidden" },
+    404: { description: "No profile with that name" },
+    409: { description: "The profile is a seed or still in use" }
+  }
+});
+async function profileValueError(input) {
+  const modelError = await explicitModelError({
+    model: input.model,
+    allowCustomModel: input.allowCustomModel,
+    harnessProvider: input.harness
+  });
+  if (modelError)
+    return modelError;
+  if (input.effort && !isAlias(input.model) && !supportedReasoningLevels(input.harness, input.model).includes(input.effort)) {
+    return `Effort "${input.effort}" is not supported by ${input.model} on ${input.harness}.`;
+  }
+  return null;
+}
+async function canWriteProfiles(req, res, myAgentId) {
+  const decision = can({
+    principal: await agentFirstPrincipal(req, myAgentId),
+    verb: "models.profiles.write",
+    resource: { kind: "none" },
+    source: "http"
+  });
+  if (!decision.allow) {
+    jsonError(res, "Writing model profiles requires the operator", 403);
+    return false;
+  }
+  return true;
+}
+async function handleModelProfiles(req, res, pathSegments, queryParams, myAgentId) {
+  if (listProfiles.match(req.method, pathSegments)) {
+    const parsed = await listProfiles.parse(req, res, pathSegments, queryParams);
+    if (!parsed)
+      return true;
+    listProfiles.respond(res, 200, {
+      profiles: await listModelProfiles({ harness: parsed.query.harness })
+    });
+    return true;
+  }
+  if (getProfile.match(req.method, pathSegments)) {
+    const parsed = await getProfile.parse(req, res, pathSegments, queryParams);
+    if (!parsed)
+      return true;
+    const profile = await getModelProfileByName(parsed.params.name);
+    if (!profile) {
+      jsonError(res, "Model profile not found", 404);
+      return true;
+    }
+    getProfile.respond(res, 200, profile);
+    return true;
+  }
+  if (createProfile.match(req.method, pathSegments)) {
+    const parsed = await createProfile.parse(req, res, pathSegments, queryParams);
+    if (!parsed)
+      return true;
+    if (!await canWriteProfiles(req, res, myAgentId))
+      return true;
+    const body = parsed.body;
+    const error = await profileValueError({ ...body, effort: body.effort ?? null });
+    if (error) {
+      jsonError(res, error, 400);
+      return true;
+    }
+    const created = await createModelProfile(body, {
+      userId: await resolveHttpAuditUserId(req, myAgentId)
+    });
+    if (!created) {
+      jsonError(res, `Model profile "${body.name}" already exists`, 409);
+      return true;
+    }
+    createProfile.respond(res, 201, created);
+    return true;
+  }
+  if (updateProfile.match(req.method, pathSegments)) {
+    const parsed = await updateProfile.parse(req, res, pathSegments, queryParams);
+    if (!parsed)
+      return true;
+    if (!await canWriteProfiles(req, res, myAgentId))
+      return true;
+    const current = await getModelProfileByName(parsed.params.name);
+    if (!current) {
+      jsonError(res, "Model profile not found", 404);
+      return true;
+    }
+    const body = parsed.body;
+    const error = await profileValueError({
+      harness: current.harness,
+      model: body.model ?? current.model,
+      effort: body.effort === undefined ? current.effort : body.effort,
+      allowCustomModel: body.allowCustomModel ?? current.allowCustomModel
+    });
+    if (error) {
+      jsonError(res, error, 400);
+      return true;
+    }
+    const updated = await updateModelProfile(current.name, body, {
+      userId: await resolveHttpAuditUserId(req, myAgentId)
+    });
+    if (!updated) {
+      jsonError(res, "Model profile not found", 404);
+      return true;
+    }
+    updateProfile.respond(res, 200, updated);
+    return true;
+  }
+  if (deleteProfile.match(req.method, pathSegments)) {
+    const parsed = await deleteProfile.parse(req, res, pathSegments, queryParams);
+    if (!parsed)
+      return true;
+    if (!await canWriteProfiles(req, res, myAgentId))
+      return true;
+    const current = await getModelProfileByName(parsed.params.name);
+    if (!current) {
+      jsonError(res, "Model profile not found", 404);
+      return true;
+    }
+    if (current.seededFrom?.startsWith("tier:")) {
+      jsonError(res, `"${current.name}" is a shipped tier profile and comes back at the next boot; edit it instead.`, 409);
+      return true;
+    }
+    const refs = await modelProfileReferences(current.name);
+    if (refs.agentIds.length > 0 || refs.openTaskCount > 0) {
+      jsonError(res, `"${current.name}" is in use: default of ${refs.agentIds.length} agent(s), held by ${refs.openTaskCount} unfinished or awaiting-resume task(s).`, 409);
+      return true;
+    }
+    const outcome = await deleteModelProfile(current.name);
+    if (outcome === "in-use") {
+      jsonError(res, `"${current.name}" is in use by a task or an agent default created just now.`, 409);
+      return true;
+    }
+    if (outcome === "missing") {
+      jsonError(res, "Model profile not found", 404);
+      return true;
+    }
+    deleteProfile.respond(res, 200, { deleted: true });
+    return true;
+  }
+  return false;
+}
+
 // src/http/models-catalog.ts
 init_zod();
 init_db3();
@@ -20793,6 +21597,7 @@ init_request_auth_context();
 // src/http/tasks.ts
 init_zod();
 init_db3();
+init_model_profiles();
 init_steering();
 init_users();
 init_rbac();
@@ -20989,6 +21794,7 @@ var createTask = route({
     modelTier: ModelTierSchema.optional(),
     allowCustomModel: exports_external.boolean().optional(),
     effort: ReasoningEffortSchema.optional(),
+    profile: exports_external.string().trim().min(1).optional(),
     draft: exports_external.boolean().optional()
   }).superRefine((body, ctx) => {
     if ((body.agentId !== undefined || body.offeredTo !== undefined) && !body.routingReason) {
@@ -21530,6 +22336,15 @@ async function handleTasks(req, res, pathSegments, queryParams, myAgentId) {
       jsonError(res, modelError, 400);
       return true;
     }
+    const profileError = await taskProfileError({
+      profile: parsed.body.profile,
+      ...splitLegacyModelAlias({ model: parsed.body.model, modelTier: parsed.body.modelTier }),
+      agentId: defaultAgentId
+    });
+    if (profileError) {
+      jsonError(res, profileError, 400);
+      return true;
+    }
     const parentTask = parsed.body.parentTaskId ? await getTaskById(parsed.body.parentTaskId) : null;
     const principal = await resolveTaskWritePrincipal(req, myAgentId);
     if (parentTask && !can({
@@ -21587,7 +22402,8 @@ async function handleTasks(req, res, pathSegments, queryParams, myAgentId) {
           model: parsed.body.model,
           modelTier: parsed.body.modelTier
         }),
-        effort: parsed.body.effort
+        effort: parsed.body.effort,
+        profile: parsed.body.profile
       }, { origin: "rest", allowCustomModel: parsed.body.allowCustomModel });
       ensure({
         id: "created",
@@ -21614,6 +22430,10 @@ async function handleTasks(req, res, pathSegments, queryParams, myAgentId) {
         jsonError(res, error.message, 400);
         return true;
       }
+      if (modelProfileRefError(error) === "missing") {
+        jsonError(res, `Unknown model profile "${parsed.body.profile}"`, 400);
+        return true;
+      }
       console.error("[HTTP] Failed to create task:", error);
       jsonError(res, "Failed to create task", 500);
     }
@@ -23813,6 +24633,33 @@ function isPageFeedbackRequested(queryParams) {
   const value = (queryParams.get(PAGE_FEEDBACK_PARAM) ?? "").toLowerCase();
   return value !== "0" && value !== "false";
 }
+var FEEDBACK_KEY_GUARD_JS = `
+(function () {
+  if (window.__swarmFeedbackKeys) return;
+  var keys = window.__swarmFeedbackKeys = { host: null, handle: null };
+  var owned = {};
+  function id(e) { return e.code || e.key; }
+  function fromOverlay(e) {
+    return !!keys.host && typeof e.composedPath === 'function' && e.composedPath().indexOf(keys.host) !== -1;
+  }
+  function guard(e) {
+    var k = id(e);
+    var mine = fromOverlay(e);
+    if (!mine && !owned[k]) return;
+    if (e.type === 'keydown') {
+      if (mine) owned[k] = true;
+      else if (!e.repeat) { delete owned[k]; return; }
+    }
+    if (e.type === 'keyup') delete owned[k];
+    e.stopImmediatePropagation();
+    if (mine && keys.handle) keys.handle(e);
+  }
+  ['keydown', 'keypress', 'keyup'].forEach(function (type) {
+    window.addEventListener(type, guard, true);
+  });
+  window.addEventListener('blur', function () { owned = {}; });
+})();
+`;
 var FEEDBACK_OVERLAY_JS = `
 (function () {
   var cfg = window.__swarmFeedback;
@@ -23923,6 +24770,7 @@ var FEEDBACK_OVERLAY_JS = `
   var panel = document.createElement('div');
   panel.className = 'panel';
   var composer = null;
+  var composerInput = null;
   root.appendChild(hl);
   root.appendChild(markers);
   root.appendChild(panel);
@@ -23995,11 +24843,25 @@ var FEEDBACK_OVERLAY_JS = `
     }
     render();
   }
-  document.addEventListener('keydown', function (e) {
-    if (e.key !== 'Escape') return;
+  function onEscape() {
     if (state.draft) { closeComposer(); return; }
     if (state.selecting) setSelecting(false);
+  }
+  // Escape pressed on the page while selecting. Keys typed in the overlay never
+  // get here: the key guard stops them and calls onOverlayKey instead.
+  document.addEventListener('keydown', function (e) {
+    if (e.key === 'Escape') onEscape();
   }, true);
+  function onOverlayKey(e) {
+    if (e.type !== 'keydown') return;
+    if (e.key === 'Escape') { onEscape(); return; }
+    if (e.key === 'Enter' && (e.metaKey || e.ctrlKey) && composerInput && e.composedPath()[0] === composerInput) {
+      e.preventDefault();
+      commitDraft(composerInput.value);
+    }
+  }
+  window.__swarmFeedbackKeys.host = host;
+  window.__swarmFeedbackKeys.handle = onOverlayKey;
 
   // ─── Composer ──────────────────────────────────────────────────────────
   function openComposer(target) {
@@ -24018,9 +24880,7 @@ var FEEDBACK_OVERLAY_JS = `
     add.type = 'button';
     cancel.addEventListener('click', closeComposer);
     add.addEventListener('click', function () { commitDraft(input.value); });
-    input.addEventListener('keydown', function (e) {
-      if (e.key === 'Enter' && (e.metaKey || e.ctrlKey)) { e.preventDefault(); commitDraft(input.value); }
-    });
+    composerInput = input;
     row.appendChild(cancel);
     row.appendChild(add);
     composer.appendChild(row);
@@ -24041,6 +24901,7 @@ var FEEDBACK_OVERLAY_JS = `
   function closeComposer() {
     if (composer) composer.remove();
     composer = null;
+    composerInput = null;
     state.draft = null;
     hideHighlight();
   }
@@ -24306,7 +25167,10 @@ var FEEDBACK_OVERLAY_JS = `
 `;
 function feedbackOverlayScripts(pageId) {
   const config = JSON.stringify({ pageId }).replace(/</g, "\\u003c");
-  return `<script>window.__swarmFeedback = ${config};</script><script>${FEEDBACK_OVERLAY_JS}</script>`;
+  return `<script>window.__swarmFeedback = ${config};</script><script>${FEEDBACK_KEY_GUARD_JS}${FEEDBACK_OVERLAY_JS}</script>`;
+}
+function feedbackKeyGuardScript() {
+  return `<script>${FEEDBACK_KEY_GUARD_JS}</script>`;
 }
 
 // src/http/pages-public.ts
@@ -24414,8 +25278,8 @@ var PAGE_HEAD_DEFAULTS = `<base target="_blank">
     .swarm-card, swarm-diff { break-inside: avoid; }
   }
 </style>`;
-function injectBrowserSdk(html) {
-  const injection = `${PAGE_HEAD_DEFAULTS}<script>${BROWSER_SDK_JS}</script><script>${SWARM_UI_JS}</script>`;
+function injectBrowserSdk(html, headFirst = "") {
+  const injection = `${headFirst}${PAGE_HEAD_DEFAULTS}<script>${BROWSER_SDK_JS}</script><script>${SWARM_UI_JS}</script>`;
   const headOpenMatch = html.match(/<head\b[^>]*>/i);
   if (headOpenMatch) {
     const idx = headOpenMatch.index + headOpenMatch[0].length;
@@ -24718,7 +25582,8 @@ async function handlePagesPublic(req, res, pathSegments, queryParams) {
     res.end();
     return true;
   }
-  const html = injectBrowserSdk(page.body) + (wantsPrint ? PRINT_AUTOTRIGGER_SCRIPT : "") + (isPageFeedbackRequested(queryParams) ? feedbackOverlayScripts(page.id) : "");
+  const feedback = isPageFeedbackRequested(queryParams);
+  const html = injectBrowserSdk(page.body, feedback ? feedbackKeyGuardScript() : "") + (wantsPrint ? PRINT_AUTOTRIGGER_SCRIPT : "") + (feedback ? feedbackOverlayScripts(page.id) : "");
   const headers2 = {
     "Content-Type": "text/html; charset=utf-8",
     "Cache-Control": "no-store",
@@ -24850,6 +25715,7 @@ async function fetchAllBotChannels(client) {
 // src/http/poll.ts
 init_telemetry_trigger();
 init_types();
+init_request_auth_context();
 init_runtime_pools_flag();
 function buildBudgetRefusedTrigger(refusal) {
   const trigger = {
@@ -24946,18 +25812,21 @@ async function attachmentsForTrigger(taskId) {
     sizeBytes: a.sizeBytes
   }));
 }
-async function claimModelFields(task, agent) {
+async function claimModelFields(task, agent, auth) {
   const pin = taskModelPin(task);
   const cleared = {
     model: pin,
     resolvedModel: undefined,
     modelSource: undefined,
-    modelAlias: undefined
+    modelAlias: undefined,
+    resolvedProfile: undefined
   };
   try {
     return {
       ...cleared,
-      ...await recordClaimModelResolution({ ...task, model: pin }, agent)
+      ...await recordClaimModelResolution({ ...task, model: pin }, agent, {
+        includeRepoSecrets: readsRepoSecrets(auth, agent)
+      })
     };
   } catch (error) {
     console.warn(`[/api/poll] model resolution failed for task ${task.id}:`, error);
@@ -25135,7 +26004,7 @@ async function handlePoll(req, res, pathSegments, queryParams, myAgentId) {
                 triggerSurface: assignedTriggerSurface,
                 task: {
                   ...pendingTask,
-                  ...await claimModelFields(pendingTask, agent),
+                  ...await claimModelFields(pendingTask, agent, getRequestAuth(req)),
                   status: "in_progress",
                   attachments: await attachmentsForTrigger(pendingTask.id)
                 },
@@ -25226,7 +26095,7 @@ async function handlePoll(req, res, pathSegments, queryParams, myAgentId) {
                     triggerSurface: claimedTriggerSurface,
                     task: {
                       ...claimed,
-                      ...await claimModelFields(claimed, agent),
+                      ...await claimModelFields(claimed, agent, getRequestAuth(req)),
                       attachments: await attachmentsForTrigger(claimed.id)
                     },
                     ...claimedRequestedBy && { requestedBy: claimedRequestedBy }
@@ -30132,7 +31001,7 @@ async function handleScriptRuns(req, res, pathSegments, queryParams, agentId) {
       return true;
     const result = await executeRawLlm(parsed.body);
     if (result.status === "failed") {
-      json(res, { error: result.error }, 500);
+      jsonError(res, result.error, 500);
       return true;
     }
     rawLlmRoute.respond(res, 200, result.output);
@@ -30336,7 +31205,8 @@ var upsertRoute2 = route({
       schema: exports_external.object({
         name: exports_external.string(),
         version: exports_external.number(),
-        contentDeduped: exports_external.boolean()
+        contentDeduped: exports_external.boolean(),
+        warnings: exports_external.array(exports_external.string()).optional().describe("Advisory quickjs-executor compatibility findings. Never blocks the save.")
       })
     },
     400: { description: "Validation or typecheck failure" },
@@ -30496,7 +31366,12 @@ var createScriptApiRoute = route({
   params: idParamsSchema4,
   body: createScriptApiBodySchema,
   responses: {
-    201: { description: "Endpoint created", schema: scriptApiWithSecretSchema },
+    201: {
+      description: "Endpoint created",
+      schema: scriptApiWithSecretSchema.extend({
+        warnings: exports_external.array(exports_external.string()).optional().describe("Advisory quickjs-executor compatibility findings for the script.")
+      })
+    },
     400: { description: "Validation error or script has no owning agent" },
     404: { description: "Script not found" }
   },
@@ -30705,10 +31580,12 @@ async function handleScripts(req, res, pathSegments, queryParams, agentId) {
         isPromotion: Boolean(existingAgentScript)
       });
     }
+    const warnings = quickJSCompatWarnings(checkQuickJSCompat(parsed.body.source, { fsMode: parsed.body.fsMode }));
     upsertRoute2.respond(res, 200, {
       name: result.script.name,
       version: result.script.version,
-      contentDeduped: result.contentDeduped
+      contentDeduped: result.contentDeduped,
+      ...warnings.length > 0 ? { warnings } : {}
     });
     return true;
   }
@@ -31005,7 +31882,11 @@ async function handleScripts(req, res, pathSegments, queryParams, agentId) {
       label: parsed.body.label ?? null,
       createdBy: await resolveHttpAuditUserId(req, agentId)
     });
-    createScriptApiRoute.respond(res, 201, endpoint);
+    const warnings = quickJSCompatWarnings(checkQuickJSCompat(script.source, { fsMode: script.fsMode }));
+    createScriptApiRoute.respond(res, 201, {
+      ...endpoint,
+      ...warnings.length > 0 ? { warnings } : {}
+    });
     return true;
   }
   if (listScriptApisRoute.match(req.method, pathSegments)) {
@@ -36037,8 +36918,7 @@ async function handleWebhooks(req, res, pathSegments) {
     }
     agentmailWebhook.respond(res, 200, { received: true });
     if (payload.message && !isInboxAllowed(payload.message.inbox_id, process.env.AGENTMAIL_INBOX_DOMAIN_FILTER)) {
-      const domain = payload.message.inbox_id.split("@")[1] ?? "unknown";
-      console.log(`[AgentMail] Ignoring event for inbox domain "${domain}" (not in AGENTMAIL_INBOX_DOMAIN_FILTER)`);
+      console.log(`[AgentMail] Ignoring event for inbox "${payload.message.inbox_id}" (not in AGENTMAIL_INBOX_DOMAIN_FILTER)`);
       return true;
     }
     if (payload.message && !isSenderAllowed(payload.message.from_, process.env.AGENTMAIL_SENDER_DOMAIN_FILTER)) {
@@ -37401,6 +38281,7 @@ var httpServer = createHttpServer(async (req, res) => {
         () => handleDbQuery(req, res, pathSegments, queryParams),
         () => handleMetrics(req, res, pathSegments, queryParams, myAgentId),
         () => handleModelsCatalog(req, res, pathSegments, queryParams),
+        () => handleModelProfiles(req, res, pathSegments, queryParams, myAgentId),
         () => handleRepos(req, res, pathSegments, queryParams, myAgentId),
         () => handleSkills(req, res, pathSegments, queryParams, myAgentId),
         () => handleScriptConnections(req, res, pathSegments, queryParams, myAgentId),
@@ -37461,7 +38342,7 @@ var httpServer = createHttpServer(async (req, res) => {
   });
 });
 var detachRealtime = attachRealtimeTransport(httpServer);
-var { attachControllerTransport } = await import("./controllers-connect-kwpvj3rf.js");
+var { attachControllerTransport } = await import("./controllers-connect-v9yn8zb9.js");
 var detachControllers = attachControllerTransport(httpServer);
 var stopWorkerNudges = startWorkerNudgeListener();
 var stopRoomDeletion = realtimeBus.subscribe("room:namespace-deleted", (namespace) => {
@@ -37490,7 +38371,7 @@ async function shutdown() {
     sessionsProcessed: getServerSessionsProcessed()
   });
   if (hasCapability("scheduling")) {
-    const { stopScheduler } = await import("./index-7ep4gzdk.js");
+    const { stopScheduler } = await import("./index-3gtmkhc6.js");
     stopScheduler();
   }
   stopHeartbeat();
@@ -37502,7 +38383,7 @@ async function shutdown() {
   await stopSlackApp();
   await stopChatSdk();
   if (process.env.OAUTH_KEEPALIVE_DISABLE !== "true") {
-    const { stopOAuthKeepalive } = await import("./keepalive-be9vwy5h.js");
+    const { stopOAuthKeepalive } = await import("./keepalive-psj6j54c.js");
     await stopOAuthKeepalive();
   }
   stopOAuthPendingGc();
@@ -37582,15 +38463,21 @@ try {
   console.warn("[startup] CAPABILITIES upgrade seed failed (non-fatal):", err);
 }
 try {
-  const { ensurePricingSeeded } = await import("./boot-seeds-kwjq4d2z.js");
+  const { ensurePricingSeeded } = await import("./boot-seeds-e9sta0yt.js");
   ensurePricingSeeded();
-  const { startPricingRefreshLoop } = await import("./pricing-refresh-qb0rv0ap.js");
+  const { startPricingRefreshLoop } = await import("./pricing-refresh-kefx9v3t.js");
   startPricingRefreshLoop();
 } catch (err) {
   console.error("[startup] Failed to seed pricing rows:", err);
 }
 try {
-  const { ensureRbacSeeded } = await import("./boot-seeds-kwjq4d2z.js");
+  const { ensureModelProfilesSeeded } = await import("./boot-seeds-e9sta0yt.js");
+  await ensureModelProfilesSeeded();
+} catch (err) {
+  console.error("[startup] Failed to seed model profiles:", err);
+}
+try {
+  const { ensureRbacSeeded } = await import("./boot-seeds-e9sta0yt.js");
   ensureRbacSeeded();
 } catch (err) {
   console.error("[startup] Failed to sync RBAC seed rows:", err);
@@ -37598,7 +38485,7 @@ try {
     throw err;
 }
 try {
-  const { runAllSeeders } = await import("./index-s2wxgzr0.js");
+  const { runAllSeeders } = await import("./index-5wyfjc2c.js");
   await runAllSeeders({ scriptEmbeddingMode: "skip" });
 } catch (err) {
   console.error("[startup] Failed to seed built-in entities:", err);
@@ -37653,45 +38540,46 @@ httpServer.listen(port, async () => {
   initGitHub();
   initGitLab();
   initAzureDevOps();
+  initAzureDevOpsOutbound();
   initAgentMail();
   await initLinear();
   await initJira();
   await initWorkflows();
   await startScriptRunSupervisor(getMcpBaseUrl());
   if (hasCapability("scheduling")) {
-    const { startScheduler } = await import("./index-7ep4gzdk.js");
-    const { getExecutorRegistry: getExecutorRegistry2 } = await import("./index-rmpw9a8q.js");
+    const { startScheduler } = await import("./index-3gtmkhc6.js");
+    const { getExecutorRegistry: getExecutorRegistry2 } = await import("./index-5e101240.js");
     const intervalMs = Number(process.env.SCHEDULER_INTERVAL_MS) || 1e4;
     startScheduler(getExecutorRegistry2(), intervalMs, {
       runId: globalState.__runId
     });
   }
   if (!isEnvFlagEnabled("HEARTBEAT_DISABLE", false)) {
-    const { startHeartbeat } = await import("./index-v1v6n7hg.js");
+    const { startHeartbeat } = await import("./index-3k5hkz7r.js");
     const heartbeatMs = Number(process.env.HEARTBEAT_INTERVAL_MS) || 90000;
     startHeartbeat(heartbeatMs);
   }
   startPoolRouting();
   startRuntimeSupervisor();
   if (process.env.OAUTH_KEEPALIVE_DISABLE !== "true") {
-    const { startOAuthKeepalive } = await import("./keepalive-be9vwy5h.js");
+    const { startOAuthKeepalive } = await import("./keepalive-psj6j54c.js");
     startOAuthKeepalive();
   }
   if (process.env.OAUTH_REFRESH_SWEEP_DISABLE !== "true") {
-    const { startOAuthRefreshSweep } = await import("./oauth-refresh-sweep-cpdnfwdj.js");
+    const { startOAuthRefreshSweep } = await import("./oauth-refresh-sweep-0284h93b.js");
     startOAuthRefreshSweep();
   }
   startOAuthPendingGc();
   await startMemoryGc();
   await startDbRetention();
   startHumanFreeDrain();
-  import("./boot-reembed-5c2z0mbe.js").then(({ runBootReembed }) => runBootReembed()).catch((err) => {
+  import("./boot-reembed-whzbdthj.js").then(({ runBootReembed }) => runBootReembed()).catch((err) => {
     console.error("[boot-reembed] startup backfill failed (non-fatal):", err);
   });
-  import("./boot-reembed-j8xa181e.js").then(({ runBootReembedScripts }) => runBootReembedScripts()).catch((err) => {
+  import("./boot-reembed-9apm9qw6.js").then(({ runBootReembedScripts }) => runBootReembedScripts()).catch((err) => {
     console.error("[boot-reembed-scripts] startup backfill failed (non-fatal):", err);
   });
-  import("./boot-scrub-sweep-hnkn3rgt.js").then(({ runBootScrubSweep }) => runBootScrubSweep()).catch((err) => {
+  import("./boot-scrub-sweep-ndzmvmgt.js").then(({ runBootScrubSweep }) => runBootScrubSweep()).catch((err) => {
     console.error("[boot-scrub-sweep] startup scrub failed (non-fatal):", err);
   });
 }).on("error", (err) => {