@desplega.ai/agent-swarm 1.173.0 → 2.1.0

package/src/tools/request-human-input.ts

@@ -56,6 +56,12 @@ export const registerRequestHumanInputTool = (server: McpServer) => {
           .describe(
             "Seconds until the request expires. After that the request becomes 'timeout' and you get a hitl-follow-up task. A request with no timeout is cancelled after APPROVAL_REQUEST_AUTO_CANCELLATION_DAYS days (default 7).",
           ),
+        detached: z
+          .boolean()
+          .optional()
+          .describe(
+            "Do not attach the request to your current task, so no hitl-follow-up task is created. For scripts that read the request's status themselves.",
+          ),
       }),
       outputSchema: swarmToolOutputSchema({
         yourAgentId: z.string().optional(),
@@ -63,7 +69,7 @@ export const registerRequestHumanInputTool = (server: McpServer) => {
         url: z.string().optional(),
       }),
     },
-    async ({ title, questions, timeoutSeconds }, requestInfo) => {
+    async ({ title, questions, timeoutSeconds, detached }, requestInfo) => {
       if (!requestInfo.agentId) {
         return toolErr(
           'Agent ID not found. The MCP client should define the "X-Agent-ID" header.',
@@ -74,8 +80,10 @@ export const registerRequestHumanInputTool = (server: McpServer) => {
       // Resolve sourceTaskId: prefer header, fall back to agent's current in-progress task.
       // The X-Source-Task-Id header may be missing when the per-session MCP config wasn't
       // created (e.g. .mcp.json not found, session resumed, or lead agent on a non-task trigger).
-      let sourceTaskId = requestInfo.sourceTaskId;
-      if (!sourceTaskId && requestInfo.agentId) {
+      // A detached request has no source task: a script call carries no task
+      // header, and the agent's current task is unrelated to the script.
+      let sourceTaskId = detached ? undefined : requestInfo.sourceTaskId;
+      if (!sourceTaskId && !detached && requestInfo.agentId) {
         const currentTask = await getAgentCurrentTask(requestInfo.agentId);
         if (currentTask) {
           sourceTaskId = currentTask.id;

package/src/tools/script-apis.ts

@@ -149,7 +149,11 @@ export const registerScriptApisTool = (server: McpServer) => {
             agentId: args.agentId,
           },
           requestInfo,
-          successMessage: (data) => `Endpoint ${(data as ScriptApiWithSecret).id} created.`,
+          successMessage: (data) => {
+            const warnings = (data as { warnings?: string[] }).warnings ?? [];
+            const note = warnings.length > 0 ? `\n${warnings.join("\n")}` : "";
+            return `Endpoint ${(data as ScriptApiWithSecret).id} created.${note}`;
+          },
           successDetails: (data) => {
             const token = (data as ScriptApiWithSecret).token;
             return token ? `Bearer token (shown once — save it now): ${token}` : undefined;

package/src/tools/script-upsert.ts

@@ -47,11 +47,14 @@ export const registerScriptUpsertTool = (server: McpServer) => {
             name?: unknown;
             version?: unknown;
             contentDeduped?: unknown;
+            warnings?: unknown;
           };
           const name = typeof body.name === "string" ? body.name : args.name;
           const version = typeof body.version === "number" ? ` v${body.version}` : "";
           const deduped = body.contentDeduped ? " (content unchanged — deduped)" : "";
-          return `Script \`${name}\`${version} saved.${deduped}`;
+          const warnings = Array.isArray(body.warnings) ? body.warnings.map(String) : [];
+          const note = warnings.length > 0 ? `\n${warnings.join("\n")}` : "";
+          return `Script \`${name}\`${version} saved.${deduped}${note}`;
         },
       }),
   );

package/src/tools/send-task.ts

@@ -18,6 +18,7 @@ import {
   isExtensionAgent,
   isLinearTrackerContextKey,
 } from "@/be/db";
+import { modelProfileRefError, taskProfileError } from "@/be/db/model-profiles";
 import { repointTrackerSyncBySwarmId } from "@/be/db-queries/tracker";
 import { explicitModelErrorForAgent } from "@/be/model-validation";
 import { applyPreTaskCreate } from "@/extensions/apply-task-create";
@@ -150,6 +151,14 @@ export const sendTaskInputSchema = z
     effort: ReasoningEffortSchema.optional().describe(
       "Reasoning effort for this task: 'off', 'low', 'medium', 'high', 'xhigh', or 'max'. If omitted, the assignee's REASONING_EFFORT_OVERRIDE/default applies.",
     ),
+    profile: z
+      .string()
+      .trim()
+      .min(1)
+      .optional()
+      .describe(
+        "Model profile name (see list-model-profiles): a named harness + model + effort, applied when the task is claimed. Must run on the assignee's harness. Exclusive with model and modelTier. A set `effort` still wins over the profile's.",
+      ),
     allowDuplicate: z
       .boolean()
       .default(false)
@@ -281,6 +290,7 @@ export async function sendTaskHandler(
     modelTier,
     allowCustomModel,
     effort,
+    profile,
     allowDuplicate,
     slackChannelId,
     slackThreadTs,
@@ -378,6 +388,30 @@ export async function sendTaskHandler(
   const effectiveParentTask = effectiveParentTaskId
     ? await getTaskById(effectiveParentTaskId)
     : null;
+  // The child inherits the parent's contextKey (its Slack or chat thread) and requester, and
+  // thread-scoped tools trust that binding. An agent can only build on a parent it owns or
+  // created; otherwise a worker could mint access to a foreign thread.
+  if (ctx.kind === "owner" && creatorAgentId && effectiveParentTask) {
+    const caller = await getAgentById(creatorAgentId);
+    const decision = can({
+      principal: { kind: "agent", agentId: creatorAgentId, isLead: caller?.isLead ?? false },
+      verb: "task.parent.attach",
+      resource: {
+        kind: "task",
+        taskId: effectiveParentTask.id,
+        requestedByUserId: effectiveParentTask.requestedByUserId,
+        creatorAgentId: effectiveParentTask.creatorAgentId,
+        agentId: effectiveParentTask.agentId,
+      },
+      source: "mcp",
+    });
+    if (!decision.allow) {
+      return toolErr(
+        `You don't have context for parent task ${effectiveParentTask.id}. Only its assignee, its creator, or a lead can create a child task under it.`,
+        { data: { yourAgentId: creatorAgentId } },
+      );
+    }
+  }
   if (effectiveParentTask?.routingAffinityInvalid) {
     return toolErr("Cannot continue a task with an invalid routing affinity.", {
       data: { yourAgentId: creatorAgentId },
@@ -450,6 +484,13 @@ export async function sendTaskHandler(
     agentId: effectiveAgentId,
   });
   if (modelError) return toolErr(modelError, { data: { yourAgentId: creatorAgentId } });
+  const profileError = await taskProfileError({
+    profile,
+    model: normalizedModel.model,
+    modelTier: normalizedModel.modelTier,
+    agentId: effectiveAgentId,
+  });
+  if (profileError) return toolErr(profileError, { data: { yourAgentId: creatorAgentId } });
   const effectiveRoutingReason =
     requestedAgentId !== undefined
       ? requestedRoutingReason
@@ -484,6 +525,7 @@ export async function sendTaskHandler(
     model: normalizedModel.model,
     modelTier: normalizedModel.modelTier,
     effort,
+    profile,
     slackChannelId,
     slackThreadTs,
     slackUserId,
@@ -623,7 +665,7 @@ export async function sendTaskHandler(
       : toolErr(guard.message, { data: guardData });
   }
 
-  const result = await getDbClient().transaction(async () => {
+  const created = getDbClient().transaction(async () => {
     // Authoritative re-check: the reads above are separated from the INSERT by
     // the whole handler, so only a guard inside this transaction can see a
     // concurrent send-task's committed task.
@@ -719,6 +761,11 @@ export async function sendTaskHandler(
       task: newTask,
     };
   });
+  const result = await created.catch((error: unknown) => {
+    // The profile was deleted between taskProfileError and the insert.
+    if (modelProfileRefError(error) !== "missing") throw error;
+    return { success: false, message: `Unknown model profile "${profile}".`, task: undefined };
+  });
 
   const data = {
     yourAgentId: creatorAgentId,

package/src/tools/skills/skill-get.ts

@@ -1,6 +1,7 @@
 import type { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
 import * as z from "zod";
 import { getSkillById, getSkillByName } from "@/be/db";
+import { resolveSwarmSkillByName } from "@/be/db/skill-name-resolution";
 import { createToolRegistrar, swarmToolOutputSchema, toolErr, toolOk } from "@/tools/utils";
 
 export const registerSkillGetTool = (server: McpServer) => {
@@ -10,7 +11,7 @@ export const registerSkillGetTool = (server: McpServer) => {
       title: "Get Skill",
       annotations: { destructiveHint: false },
       description:
-        "Get full skill content by ID or name. Name resolution checks agent scope first, then swarm, then global.",
+        "Get full skill content by ID or name. Name resolution checks agent scope first, then swarm, then global. In swarm scope the ownerless skill wins, then your own, then the only agent-owned one; when several other agents own that name, it errors with their IDs: pass skillId instead.",
       inputSchema: z.object({
         skillId: z.string().optional().describe("Skill ID"),
         name: z.string().optional().describe("Skill name (resolved with precedence)"),
@@ -29,15 +30,22 @@ export const registerSkillGetTool = (server: McpServer) => {
 
       if (args.skillId) {
         skill = await getSkillById(args.skillId);
-      } else if (args.name && requestInfo.agentId) {
-        // Precedence: agent (personal) → swarm → global
-        skill =
-          (await getSkillByName(args.name, "agent", requestInfo.agentId)) ||
-          (await getSkillByName(args.name, "swarm")) ||
-          (await getSkillByName(args.name, "global"));
       } else if (args.name) {
-        skill =
-          (await getSkillByName(args.name, "swarm")) || (await getSkillByName(args.name, "global"));
+        // Precedence: agent (personal) → swarm → global
+        if (requestInfo.agentId) {
+          skill = await getSkillByName(args.name, "agent", requestInfo.agentId);
+        }
+        if (!skill) {
+          const swarm = await resolveSwarmSkillByName(args.name, requestInfo.agentId);
+          if (swarm.kind === "ambiguous") {
+            return toolErr(
+              `Skill name "${args.name}" matches ${swarm.skillIds.length} swarm skills owned by other agents: ${swarm.skillIds.join(", ")}. Call skill-get with skillId instead.`,
+              { data: { yourAgentId: requestInfo.agentId } },
+            );
+          }
+          if (swarm.kind === "found") skill = await getSkillById(swarm.skillId);
+        }
+        if (!skill) skill = await getSkillByName(args.name, "global");
       }
 
       if (!skill) {

package/src/tools/swarm-config/get-config.ts

@@ -19,6 +19,7 @@ const configEntryShape = z.looseObject({
   createdAt: z.string().optional(),
   lastUpdatedAt: z.string().optional(),
   encrypted: z.boolean().optional(),
+  exportToEnv: z.boolean().optional(),
 });
 
 export const registerGetConfigTool = (server: McpServer) => {
@@ -110,7 +111,7 @@ export const registerGetConfigTool = (server: McpServer) => {
             : result
                 .map(
                   (c) =>
-                    `- ${c.key}=${c.isSecret && !effectiveIncludeSecrets ? "********" : c.value} (scope: ${c.scope}${c.scopeId ? `, scopeId: ${c.scopeId}` : ""})`,
+                    `- ${c.key}=${c.isSecret && !effectiveIncludeSecrets ? "********" : c.value} (scope: ${c.scope}${c.scopeId ? `, scopeId: ${c.scopeId}` : ""}${c.exportToEnv ? "" : ", not in agent env"})`,
                 )
                 .join("\n");
 

package/src/tools/swarm-config/list-config.ts

@@ -19,6 +19,7 @@ const configEntryShape = z.looseObject({
   createdAt: z.string().optional(),
   lastUpdatedAt: z.string().optional(),
   encrypted: z.boolean().optional(),
+  exportToEnv: z.boolean().optional(),
 });
 
 export const registerListConfigTool = (server: McpServer) => {
@@ -102,7 +103,7 @@ export const registerListConfigTool = (server: McpServer) => {
             : result
                 .map(
                   (c) =>
-                    `- [${c.scope}${c.scopeId ? `:${c.scopeId}` : ""}] ${c.key}=${c.isSecret && !effectiveIncludeSecrets ? "********" : c.value}${c.description ? ` — ${c.description}` : ""}`,
+                    `- [${c.scope}${c.scopeId ? `:${c.scopeId}` : ""}] ${c.key}=${c.isSecret && !effectiveIncludeSecrets ? "********" : c.value}${c.exportToEnv ? "" : " [not in agent env]"}${c.description ? ` — ${c.description}` : ""}`,
                 )
                 .join("\n");
 

package/src/tools/swarm-config/set-config.ts

@@ -8,6 +8,7 @@ import {
   isReservedConfigKey,
   reservedKeyError,
   validateConfigValue,
+  validateExportToEnv,
 } from "@/be/swarm-config-guard";
 import { scheduleIntegrationsReload } from "@/http/core";
 import { can } from "@/rbac";
@@ -26,6 +27,7 @@ const configEntryShape = z.looseObject({
   createdAt: z.string().optional(),
   lastUpdatedAt: z.string().optional(),
   encrypted: z.boolean().optional(),
+  exportToEnv: z.boolean().optional(),
 });
 
 export const registerSetConfigTool = (server: McpServer) => {
@@ -34,7 +36,7 @@ export const registerSetConfigTool = (server: McpServer) => {
     {
       title: "Set Config",
       description:
-        "Set or update a swarm configuration value. Upserts by (scope, scopeId, key). Use scope='global' for server-wide settings, 'agent' for agent-specific, or 'repo' for repo-specific. Set isSecret=true to mask the value in API responses.",
+        "Set or update a swarm configuration value. Upserts by (scope, scopeId, key). Use scope='global' for server-wide settings, 'agent' for agent-specific, or 'repo' for repo-specific. Set isSecret=true to mask the value in API responses. Set exportToEnv=false to keep the row out of agent process env (agents then reach it through a connection or script credential binding).",
       annotations: { idempotentHint: true },
 
       inputSchema: z.object({
@@ -63,13 +65,22 @@ export const registerSetConfigTool = (server: McpServer) => {
           .string()
           .optional()
           .describe("Optional human-readable description of this config entry."),
+        exportToEnv: z
+          .boolean()
+          .optional()
+          .describe(
+            "Export this row into agent process env (default true on create, false for a few server-side secrets; omitted on update keeps the stored flag). Rejected as true for keys only the API server reads.",
+          ),
       }),
       outputSchema: swarmToolOutputSchema({
         yourAgentId: z.string().optional(),
         config: configEntryShape.optional(),
       }),
     },
-    async ({ scope, scopeId, key, value, isSecret, envPath, description }, requestInfo) => {
+    async (
+      { scope, scopeId, key, value, isSecret, envPath, description, exportToEnv },
+      requestInfo,
+    ) => {
       if (!requestInfo.agentId) {
         return toolErr('Agent ID not found. Set the "X-Agent-ID" header.');
       }
@@ -114,7 +125,8 @@ export const registerSetConfigTool = (server: McpServer) => {
           });
         }
 
-        const validationError = validateConfigValue(key, value);
+        const validationError =
+          validateConfigValue(key, value) ?? validateExportToEnv(key, exportToEnv);
         if (validationError) {
           return toolErr(validationError, { data: { yourAgentId: requestInfo.agentId } });
         }
@@ -127,6 +139,7 @@ export const registerSetConfigTool = (server: McpServer) => {
           isSecret,
           envPath,
           description,
+          exportToEnv,
         });
 
         if (scope === "global") {

package/src/tools/system-one-decide.ts

@@ -0,0 +1,104 @@
+import type { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import * as z from "zod";
+import { createToolRegistrar, swarmToolOutputSchema, toolErr, toolOk } from "@/tools/utils";
+import { getExecutorRegistry } from "@/workflows";
+import {
+  SYSTEM_ONE_DECISION_NODE_TYPE,
+  SystemOneDecisionConfigSchema,
+  SystemOneDecisionExecutor,
+} from "@/workflows/executors/system-one-decision";
+import { SYSTEM_ONE_PROVIDER_IDS } from "@/workflows/executors/system-one-providers";
+
+/**
+ * One typed decision (Jev and the other SystemOne hosts) made in the API
+ * process, the same way a `system-one-decision` workflow node makes it. The
+ * provider credential is read and sent here and never reaches the caller, so a
+ * script can ask for a decision without a credential binding in its own realm.
+ */
+export const registerSystemOneDecideTool = (server: McpServer) => {
+  createToolRegistrar(server)(
+    "system-one-decide",
+    {
+      title: "Ask a SystemOne decision model",
+      annotations: { destructiveHint: false, openWorldHint: true },
+      description:
+        "Send a state and typed questions (noul, choice, score) to a SystemOne decision host such as Jev, and return the validated answers. " +
+        "Same request, provider list, credentials and validation as the `system-one-decision` workflow node, without its human review band. " +
+        "The provider credential is a global secret that stays on the server; this tool never returns it.",
+      inputSchema: z.object({
+        provider: z
+          .enum(SYSTEM_ONE_PROVIDER_IDS)
+          .optional()
+          .describe("Decision host (default typesafe)"),
+        model: z.string().min(1).optional().describe("Provider model id (default: the provider's)"),
+        state: z
+          .union([z.string(), z.array(z.string()), z.record(z.string(), z.unknown())])
+          .describe("The state to decide on"),
+        questions: z
+          .record(z.string(), z.record(z.string(), z.unknown()))
+          .describe(
+            "Questions by id, each `{ type: 'noul' | 'choice' | 'score', instructions, criteria }`",
+          ),
+        timeoutMs: z
+          .number()
+          .int()
+          .optional()
+          .describe("Time budget for the call, retries included (default 30000)"),
+        maxRetries: z
+          .number()
+          .int()
+          .optional()
+          .describe("Retries on transient failures inside the time budget (default 2)"),
+      }),
+      outputSchema: swarmToolOutputSchema({
+        model: z.string().optional(),
+        answers: z.record(z.string(), z.unknown()).optional(),
+        usage: z.record(z.string(), z.unknown()).optional(),
+        requestId: z.string().optional(),
+      }),
+    },
+    async ({ provider, model, state, questions, timeoutMs, maxRetries }, requestInfo) => {
+      if (!requestInfo.agentId) {
+        return toolErr('Agent ID not found. The MCP client should define the "X-Agent-ID" header.');
+      }
+
+      // `returns` mirrors the questions: the caller reads answers directly, so
+      // there is no downstream port to declare.
+      const returns = Object.fromEntries(
+        Object.entries(questions).map(([id, question]) => [id, { type: question.type }]),
+      );
+      const parsed = SystemOneDecisionConfigSchema.safeParse({
+        provider,
+        model,
+        state,
+        questions,
+        returns,
+        timeoutMs,
+        maxRetries,
+      });
+      if (!parsed.success) {
+        const issues = parsed.error.issues
+          .map((issue) => `${issue.path.join(".") || "(root)"}: ${issue.message}`)
+          .join("; ");
+        return toolErr(`Invalid decision request: ${issues}`.slice(0, 1000));
+      }
+
+      const executor = getExecutorRegistry().get(SYSTEM_ONE_DECISION_NODE_TYPE);
+      if (!(executor instanceof SystemOneDecisionExecutor)) {
+        return toolErr("The system-one-decision executor is not available");
+      }
+      const decided = await executor.decide(parsed.data);
+      if (!decided.ok) return toolErr(decided.error);
+
+      const { output } = decided;
+      return toolOk(`Decision from ${output.model}`, {
+        data: {
+          model: output.model,
+          answers: output.answers,
+          usage: output.usage,
+          requestId: output.requestId,
+        },
+      });
+    },
+  );
+};

package/src/tools/task-action.ts

@@ -28,6 +28,7 @@ import {
   releaseTask,
   updateTaskClaudeSessionId,
 } from "@/be/db";
+import { modelProfileRefError, taskProfileError } from "@/be/db/model-profiles";
 import { explicitModelErrorForAgent } from "@/be/model-validation";
 import { touchRuntimeInstance } from "@/be/multi-runtime";
 import { applyPreTaskCreate } from "@/extensions/apply-task-create";
@@ -109,6 +110,14 @@ export const taskActionInputSchema = z.object({
   effort: ReasoningEffortSchema.optional().describe(
     "Reasoning effort for the created task: 'off', 'low', 'medium', 'high', 'xhigh', or 'max'. Only used with 'create' action.",
   ),
+  profile: z
+    .string()
+    .trim()
+    .min(1)
+    .optional()
+    .describe(
+      "Model profile name for the created pool task (see list-model-profiles); only workers on its harness claim it. Exclusive with model and modelTier. Only used with 'create' action.",
+    ),
   requiredCapabilities: z
     .array(z.string())
     .optional()
@@ -296,6 +305,12 @@ export async function taskActionHandler(
       allowCustomModel: input.allowCustomModel,
     });
     if (modelError) return taskActionResult({ success: false, message: modelError }, agentId);
+    const profileError = await taskProfileError({
+      profile: input.profile,
+      model: normalizedModel.model,
+      modelTier: normalizedModel.modelTier,
+    });
+    if (profileError) return taskActionResult({ success: false, message: profileError }, agentId);
     try {
       assetKey = key
         ? await authorizeAssetKeyWrite(key, await resolveTaskAuditUserId(ctx.sourceTaskId, agentId))
@@ -324,6 +339,7 @@ export async function taskActionHandler(
         model: normalizedModel.model,
         modelTier: normalizedModel.modelTier,
         effort: input.effort,
+        profile: input.profile,
         routingAffinity:
           leadOnly || requiredCapabilities?.length
             ? { leadOnly, capabilities: requiredCapabilities ?? [] }
@@ -342,7 +358,7 @@ export async function taskActionHandler(
     };
   }
 
-  const result = await getDbClient().transaction(async (): Promise<TaskActionResult> => {
+  const transacted = getDbClient().transaction(async (): Promise<TaskActionResult> => {
     switch (action) {
       case "create": {
         const newTask = await createTaskExtended(
@@ -644,6 +660,11 @@ export async function taskActionHandler(
         return { success: false, message: `Unknown action: ${action}` };
     }
   });
+  const result = await transacted.catch((error: unknown): TaskActionResult => {
+    // A create whose profile was deleted between taskProfileError and the insert.
+    if (modelProfileRefError(error) !== "missing") throw error;
+    return { success: false, message: `Unknown model profile "${input.profile}".` };
+  });
 
   // Phase 5: when the accept gate refused, run after-commit side
   // effects (lead follow-up + workflow bus). The dedup row was recorded

package/src/tools/tool-config.ts

@@ -72,12 +72,6 @@ export const DEFERRED_TOOLS = new Set([
   "retry-workflow-run",
   "cancel-workflow-run",
 
-  // Services (4)
-  "register-service",
-  "unregister-service",
-  "list-services",
-  "update-service-status",
-
   // Config (7)
   "set-config",
   "list-config",
@@ -87,6 +81,9 @@ export const DEFERRED_TOOLS = new Set([
   "model-catalog-refresh",
   "model-catalog-overlay-upsert",
 
+  // Model profiles (1)
+  "list-model-profiles",
+
   // Repos (1)
   "update-repo",
 
@@ -127,6 +124,14 @@ export const DEFERRED_TOOLS = new Set([
   "send-whatsapp-message",
   "reply-whatsapp-message",
 
+  // Chat SDK (6)
+  "chat-reply",
+  "chat-post",
+  "chat-open-dm",
+  "chat-read-thread",
+  "register-chat-channel",
+  "unregister-chat-channel",
+
   // Tracker (7)
   "tracker-status",
   "get-oauth-access-token",
@@ -149,6 +154,9 @@ export const DEFERRED_TOOLS = new Set([
   "request-human-input",
   "cancel-approval-request",
 
+  // Decisions (1)
+  "system-one-decide",
+
   // Skills (12)
   "skill-create",
   "skill-update",

package/src/types.ts

@@ -391,6 +391,7 @@ export const AgentTaskSourceSchema = z.enum([
   "linear",
   "jira",
   "comb",
+  "chat",
 ]);
 export type AgentTaskSource = z.infer<typeof AgentTaskSourceSchema>;
 
@@ -427,6 +428,31 @@ export const ProviderNameSchema = z.enum([
 ]);
 export type ProviderName = z.infer<typeof ProviderNameSchema>;
 
+// ============================================================================
+// Model Profiles (runbooks/model-tiers.md § Model profiles)
+// ============================================================================
+
+/** Lowercase, starts with a letter or digit; dots, dashes and underscores allowed. */
+export const ModelProfileNameSchema = z
+  .string()
+  .trim()
+  .regex(/^[a-z0-9][a-z0-9._-]{0,99}$/, "lowercase letters, digits, '.', '_' or '-', max 100");
+
+export const ModelProfileSchema = z.object({
+  id: z.string(),
+  name: z.string(),
+  harness: ProviderNameSchema,
+  model: z.string(),
+  effort: ReasoningEffortSchema.nullable(),
+  allowCustomModel: z.boolean(),
+  description: z.string().nullable(),
+  /** `tier:<tier>` (boot seed), `agent-config` (made from an agent's MODEL_OVERRIDE), or null. */
+  seededFrom: z.string().nullable(),
+  createdAt: z.string(),
+  lastUpdatedAt: z.string(),
+});
+export type ModelProfile = z.infer<typeof ModelProfileSchema>;
+
 // ============================================================================
 // Task Steering Messages
 // ============================================================================
@@ -446,7 +472,7 @@ export const SteeringStatusSchema = z.enum([
 ]);
 export type SteeringStatus = z.infer<typeof SteeringStatusSchema>;
 
-export const SteeringSourceSchema = z.enum(["ui", "mcp", "script", "slack", "api"]);
+export const SteeringSourceSchema = z.enum(["ui", "mcp", "script", "slack", "api", "chat"]);
 export type SteeringSource = z.infer<typeof SteeringSourceSchema>;
 
 export const SteeringMessageSchema = z
@@ -681,6 +707,15 @@ export const AgentTaskSchema = z
     resolvedModel: z.string().optional(),
     modelSource: z.string().optional(),
     modelAlias: z.string().optional(),
+    // The effort the session ran at (task effort, else the agent's
+    // REASONING_EFFORT_OVERRIDE, dropped when the harness/model cannot take
+    // it). Reported at session start; unset when the harness default applied.
+    resolvedEffort: ReasoningEffortSchema.optional(),
+    // Model profile (runbooks/model-tiers.md § Model profiles): `profile` is
+    // the creator's ask, `resolvedProfile` the name claim applied (the ask or
+    // the agent's default). Unset when no profile applied.
+    profile: z.string().optional(),
+    resolvedProfile: z.string().optional(),
 
     // Schedule linking (optional — set when task was created by a schedule).
     // z.string(): also reachable verbatim from the create-task query param.
@@ -812,6 +847,7 @@ export const CreateTaskOptionsSchema = z.object({
   model: z.string().optional(),
   modelTier: ModelTierSchema.optional(),
   effort: ReasoningEffortSchema.optional(),
+  profile: z.string().optional(),
   scheduleId: z.string().optional(),
   workflowRunId: z.string().optional(),
   workflowRunStepId: z.string().optional(),
@@ -1458,7 +1494,7 @@ export type ChannelType = z.infer<typeof ChannelTypeSchema>;
 export type Channel = z.infer<typeof ChannelSchema>;
 export type ChannelMessage = z.infer<typeof ChannelMessageSchema>;
 
-// Service Types (for PM2/background services)
+// Service Types (removed PM2 service registry; kept with the services table)
 export const ServiceStatusSchema = z.enum(["starting", "healthy", "unhealthy", "stopped"]);
 
 export const ServiceSchema = z
@@ -1834,6 +1870,10 @@ export const SwarmConfigSchema = z
     // auto-encrypted during initDb; if that fails, boot aborts before normal API
     // reads occur.
     encrypted: z.boolean(),
+    // Whether workers export this row into agent process env. False keeps it
+    // server-side (connections, script credential bindings). Always false for
+    // keys only the API server reads (src/utils/config-env-export.ts).
+    exportToEnv: z.boolean(),
   })
   .openapi("SwarmConfig");
 
@@ -2394,7 +2434,11 @@ export const TriggerConfigSchema = z
     }),
     z.object({
       type: z.literal("event"),
-      eventName: z.literal("slack.message"),
+      eventName: z.enum([
+        "slack.message",
+        "azure-devops.work_item.assigned",
+        "azure-devops.work_item.commented",
+      ]),
     }),
   ])
   .superRefine((trigger, ctx) => {
@@ -2625,6 +2669,7 @@ export type AgentTaskSummary = Pick<
   | "modelSource"
   | "modelAlias"
   | "effort"
+  | "resolvedEffort"
   | "provider"
   | "requestedByUserId"
   | "progress"