@desplega.ai/agent-swarm 1.173.0 → 2.1.0

package/src/be/db/tasks/read.ts

@@ -20,6 +20,7 @@ import {
   RoutingAffinitySchema,
 } from "../../../types";
 import { parseProviderMeta } from "../../../utils/provider-metadata";
+import { scrubSecrets } from "../../../utils/secret-scrubber";
 import { getAgentById } from "../agents";
 import { getDbClient } from "../runtime";
 
@@ -87,9 +88,12 @@ export type AgentTaskRow = {
   model: string | null;
   modelTier: string | null;
   effort: string | null;
+  resolvedEffort?: string | null;
   resolvedModel?: string | null;
   modelSource?: string | null;
   modelAlias?: string | null;
+  profile?: string | null;
+  resolvedProfile?: string | null;
   scheduleId: string | null;
   workflowRunId: string | null;
   workflowRunStepId: string | null;
@@ -154,6 +158,7 @@ type AgentTaskSummaryRow = Pick<
   | "modelSource"
   | "modelAlias"
   | "effort"
+  | "resolvedEffort"
   | "provider"
   | "requestedByUserId"
   | "progress"
@@ -207,6 +212,7 @@ const LIST_COLUMNS = {
     agent_tasks.offeredTo, agent_tasks.acceptedAt, agent_tasks.parentTaskId,
     agent_tasks.scheduleId, agent_tasks.model, agent_tasks.modelTier,
     agent_tasks.resolvedModel, agent_tasks.modelSource, agent_tasks.modelAlias, agent_tasks.effort,
+    agent_tasks.resolvedEffort,
     agent_tasks.provider, agent_tasks.requestedByUserId, agent_tasks.progress,
     agent_tasks.createdAt, agent_tasks.lastUpdatedAt, agent_tasks.finishedAt,
     agent_tasks.peakContextPercent`,
@@ -315,6 +321,11 @@ export function rowToAgentTask(row: AgentTaskRow): AgentTask {
     effort: ReasoningEffortSchema.safeParse(row.effort).success
       ? (row.effort as ReasoningEffort)
       : undefined,
+    resolvedEffort: ReasoningEffortSchema.safeParse(row.resolvedEffort).success
+      ? (row.resolvedEffort as ReasoningEffort)
+      : undefined,
+    profile: row.profile ?? undefined,
+    resolvedProfile: row.resolvedProfile ?? undefined,
     scheduleId: row.scheduleId ?? undefined,
     workflowRunId: row.workflowRunId ?? undefined,
     workflowRunStepId: row.workflowRunStepId ?? undefined,
@@ -381,6 +392,9 @@ export function rowToAgentTaskSummary(row: AgentTaskSummaryRow): AgentTaskSummar
     effort: ReasoningEffortSchema.safeParse(row.effort).success
       ? (row.effort as ReasoningEffort)
       : undefined,
+    resolvedEffort: ReasoningEffortSchema.safeParse(row.resolvedEffort).success
+      ? (row.resolvedEffort as ReasoningEffort)
+      : undefined,
     provider: (row.provider as ProviderName | null) ?? undefined,
     requestedByUserId: row.requestedByUserId ?? undefined,
     progress: row.progress ?? undefined,
@@ -446,6 +460,9 @@ export async function hasNonTerminalResumeChild(parentId: string): Promise<boole
   return row !== undefined && row !== null;
 }
 
+/** How far back the heartbeat repairs a superseded task that never got a resume. */
+export const SUPERSEDED_RESUME_REPAIR_WINDOW_MS = 24 * 60 * 60 * 1000;
+
 /**
  * Superseded tasks that never got a resume child. Both supersede paths
  * (heartbeat remediation and `POST /api/tasks/:id/supersede`) supersede
@@ -1035,6 +1052,163 @@ export async function markFinalizedSlackRelaysDelivered(): Promise<number> {
   return result.changes;
 }
 
+/** Pending Chat SDK relay row: the terminal task plus its obligation bookkeeping. */
+export interface PendingChatRelay {
+  task: AgentTask;
+  createdAt: string;
+  lastError: string | null;
+}
+
+/**
+ * Backoff gate for a chat relay obligation: eligible when never attempted, or
+ * when `min(3 s * 2^attempt_count, 10 min)` passed since `last_attempt_at`.
+ * `attempt_count >= 8` is already past the cap (3 s * 2^8 = 768 s). The one
+ * parameter is the reference time as ISO text.
+ */
+const CHAT_RELAY_ELIGIBLE_SQL = `(obligation.last_attempt_at IS NULL
+         OR (julianday(?) - julianday(obligation.last_attempt_at)) * 86400000.0 >=
+            CASE WHEN obligation.attempt_count >= 8 THEN 600000
+                 ELSE 3000 * (1 << obligation.attempt_count) END)`;
+
+/**
+ * Terminal chat tasks whose relay obligation is pending, out of backoff at
+ * `now`, and whose `task:chat-sdk:<adapter>:` contextKey names one of
+ * `adapters` (the adapters that are running). Rows of other adapters are left
+ * out of the query, so a stopped adapter cannot fill the window and starve the
+ * healthy ones. Returns no rows when `adapters` is empty. Never-attempted rows
+ * sort first, then the oldest attempts. A contextKey that does not parse as a
+ * chat key is not selected here; `giveUpStaleChatRelays` retires such rows once
+ * they age out.
+ */
+export async function getPendingChatRelayTasks(
+  now: number = Date.now(),
+  limit = 200,
+  adapters: readonly string[] = [],
+): Promise<PendingChatRelay[]> {
+  if (adapters.length === 0) return [];
+  for (const adapter of adapters) {
+    if (!/^[a-z]+$/.test(adapter)) throw new Error(`invalid chat adapter name: ${adapter}`);
+  }
+  const adapterFilter = adapters.map(() => "task.contextKey GLOB ?").join(" OR ");
+  const rows = await getDbClient().query<
+    AgentTaskRow & {
+      relay_created_at: string;
+      relay_last_error: string | null;
+    }
+  >(
+    `SELECT task.*,
+            obligation.created_at AS relay_created_at,
+            obligation.last_error AS relay_last_error
+       FROM chat_relay_obligations obligation
+       JOIN agent_tasks task ON task.id = obligation.task_id
+       WHERE obligation.delivered_at IS NULL
+       AND obligation.given_up_at IS NULL
+       AND task.status IN ('completed', 'failed', 'cancelled')
+       AND (${adapterFilter})
+       AND ${CHAT_RELAY_ELIGIBLE_SQL}
+       ORDER BY obligation.last_attempt_at IS NOT NULL,
+                obligation.last_attempt_at ASC,
+                obligation.created_at ASC
+       LIMIT ?`,
+    [
+      ...adapters.map((adapter) => `task:chat-sdk:${adapter}:*`),
+      new Date(now).toISOString(),
+      limit,
+    ],
+  );
+  return rows.map((row) => ({
+    task: rowToAgentTask(row),
+    createdAt: row.relay_created_at,
+    lastError: row.relay_last_error,
+  }));
+}
+
+/**
+ * Give up every pending chat relay obligation created more than `olderThanMs`
+ * before `now`, whatever the adapter state. Returns how many rows were retired.
+ */
+export async function giveUpStaleChatRelays(now: number, olderThanMs: number): Promise<number> {
+  const at = new Date(now).toISOString();
+  const cutoff = new Date(now - olderThanMs).toISOString();
+  const result = await getDbClient().run(
+    `UPDATE chat_relay_obligations
+       SET given_up_at = ?, last_error = 'gave up: older than 24h', updated_at = ?
+       WHERE delivered_at IS NULL AND given_up_at IS NULL AND created_at < ?`,
+    [at, at, cutoff],
+  );
+  return result.changes;
+}
+
+/**
+ * Claim a chat relay row before the send: bump `attempt_count` and set
+ * `last_attempt_at`. Conditional on the row still being pending and out of
+ * backoff, so two concurrent ticks cannot both send. Returns true when claimed.
+ */
+export async function markChatRelayAttempted(
+  taskId: string,
+  now: number = Date.now(),
+): Promise<boolean> {
+  const at = new Date(now).toISOString();
+  const result = await getDbClient().run(
+    `UPDATE chat_relay_obligations AS obligation
+       SET attempt_count = attempt_count + 1,
+           last_attempt_at = ?,
+           updated_at = ?
+       WHERE task_id = ?
+       AND delivered_at IS NULL
+       AND given_up_at IS NULL
+       AND ${CHAT_RELAY_ELIGIBLE_SQL}`,
+    [at, at, taskId, at],
+  );
+  return result.changes > 0;
+}
+
+/** Record why the last chat relay attempt failed. The text is scrubbed before it is stored. */
+export async function recordChatRelayError(
+  taskId: string,
+  error: string,
+  now: number = Date.now(),
+): Promise<boolean> {
+  const result = await getDbClient().run(
+    `UPDATE chat_relay_obligations
+       SET last_error = ?, updated_at = ?
+       WHERE task_id = ? AND delivered_at IS NULL`,
+    [scrubSecrets(error), new Date(now).toISOString(), taskId],
+  );
+  return result.changes > 0;
+}
+
+/** Mark a chat relay obligation delivered after the platform accepted every chunk. Idempotent. */
+export async function markChatRelayDelivered(
+  taskId: string,
+  now: number = Date.now(),
+): Promise<boolean> {
+  const at = new Date(now).toISOString();
+  const result = await getDbClient().run(
+    `UPDATE chat_relay_obligations
+       SET delivered_at = ?, updated_at = ?
+       WHERE task_id = ? AND delivered_at IS NULL`,
+    [at, at, taskId],
+  );
+  return result.changes > 0;
+}
+
+/** Stop retrying a chat relay obligation. The reason is scrubbed before it is stored. */
+export async function markChatRelayGivenUp(
+  taskId: string,
+  error: string,
+  now: number = Date.now(),
+): Promise<boolean> {
+  const at = new Date(now).toISOString();
+  const result = await getDbClient().run(
+    `UPDATE chat_relay_obligations
+       SET given_up_at = ?, last_error = ?, updated_at = ?
+       WHERE task_id = ? AND delivered_at IS NULL AND given_up_at IS NULL`,
+    [at, scrubSecrets(error), at, taskId],
+  );
+  return result.changes > 0;
+}
+
 /**
  * Get tasks that were recently finished (completed/failed) by workers (non-lead agents).
  * Used by leads to know when workers complete tasks.
@@ -1334,6 +1508,69 @@ export async function getLatestLeadTaskInThread(
   return row ? rowToAgentTask(row) : null;
 }
 
+/**
+ * ContextKey twins of the Slack thread lookups above, for channels that key a
+ * conversation by `contextKey` only (Chat SDK). `source` narrows to the
+ * channel's ingress tasks, as the Slack twins do with `source = 'slack'`:
+ * follow-ups and delegated worker tasks inherit the parent's contextKey.
+ * All three use `idx_agent_tasks_context_key_status`.
+ */
+export async function getAgentWorkingOnContextKey(
+  contextKey: string,
+  source?: string,
+): Promise<Agent | null> {
+  const taskRow = await getDbClient().get<AgentTaskRow>(
+    `SELECT agentId FROM agent_tasks
+       WHERE contextKey = ?
+       AND (? IS NULL OR source = ?)
+       ORDER BY createdAt DESC, rowid DESC
+       LIMIT 1`,
+    [contextKey, source ?? null, source ?? null],
+  );
+
+  if (taskRow?.agentId) return getAgentById(taskRow.agentId);
+
+  return null;
+}
+
+/** Latest `in_progress` or `pending` task on a contextKey (dependency chaining). */
+export async function getLatestActiveTaskByContextKey(
+  contextKey: string,
+  source?: string,
+): Promise<AgentTask | null> {
+  const row = await getDbClient().get<AgentTaskRow>(
+    `SELECT * FROM agent_tasks
+       WHERE contextKey = ?
+       AND (? IS NULL OR source = ?)
+       AND status IN ('in_progress', 'pending')
+       ORDER BY createdAt DESC, rowid DESC
+       LIMIT 1`,
+    [contextKey, source ?? null, source ?? null],
+  );
+
+  return row ? rowToAgentTask(row) : null;
+}
+
+/** Latest task assigned to a lead agent on a contextKey (the steering target). */
+export async function getLatestLeadTaskByContextKey(
+  contextKey: string,
+  source?: string,
+): Promise<AgentTask | null> {
+  const row = await getDbClient().get<AgentTaskRow>(
+    `SELECT t.*
+       FROM agent_tasks t
+       JOIN agents a ON a.id = t.agentId
+       WHERE t.contextKey = ?
+         AND (? IS NULL OR t.source = ?)
+         AND a.isLead = 1
+       ORDER BY t.createdAt DESC, t.rowid DESC
+       LIMIT 1`,
+    [contextKey, source ?? null, source ?? null],
+  );
+
+  return row ? rowToAgentTask(row) : null;
+}
+
 /**
  * Find the most recent task in a Slack thread, regardless of source or status.
  * Unlike getAgentWorkingOnThread (which filters source='slack'), this finds ALL tasks

package/src/be/db/tasks/write.ts

@@ -8,6 +8,7 @@ import type {
   AgentTask,
   AgentTaskSource,
   ProviderName,
+  ReasoningEffort,
   RuntimePool,
   TaskAttachment,
 } from "../../../types";
@@ -312,6 +313,8 @@ export async function updateTaskClaudeSessionId(
   model?: string,
   harnessVariant?: string,
   harnessVariantMeta?: Record<string, unknown>,
+  /** Effort the session runs at; null records that the harness default applied. */
+  resolvedEffort?: ReasoningEffort | null,
 ): Promise<AgentTask | null> {
   const setClauses = ["claudeSessionId = ?", "lastUpdatedAt = ?"];
   const params: (string | null)[] = [claudeSessionId, new Date().toISOString()];
@@ -336,6 +339,10 @@ export async function updateTaskClaudeSessionId(
     setClauses.push("harnessVariantMeta = ?");
     params.push(JSON.stringify(harnessVariantMeta));
   }
+  if (resolvedEffort !== undefined) {
+    setClauses.push("resolvedEffort = ?");
+    params.push(resolvedEffort);
+  }
 
   params.push(taskId);
 

package/src/be/db.ts

@@ -136,6 +136,12 @@ import {
   CODEX_AUTH_WATCH_NAMESPACE,
   codexAuthBenchMarkerKey,
 } from "../utils/codex-auth-failure";
+import {
+  defaultExportToEnv,
+  effectiveExportToEnv,
+  envExportRestrictedError,
+  isEnvExportRestrictedKey,
+} from "../utils/config-env-export";
 import { MASKED_SECRET_VALUE } from "../utils/config-secrets";
 import { deriveProviderFromKeyType } from "../utils/credentials";
 import type { RateLimitWindowTelemetry } from "../utils/error-tracker";
@@ -187,6 +193,7 @@ import {
   createContextVersion,
   getLatestContextVersion,
 } from "./db/context-versions";
+import { clearAgentModelProfileOnOverrideChange } from "./db/model-profiles";
 import { getDb, getDbClient } from "./db/runtime";
 import { classifyTaskHumanFree, reclassifyTaskHumanFree } from "./db/tasks/human-free";
 import {
@@ -205,7 +212,12 @@ import { scrubJsonValue } from "./scrub-json";
 import { openSealedJson, sealedJsonForDisplay, sealJson } from "./sealed-json";
 import { configSecretName, registerStoredSecret } from "./secret-registry";
 import { promotePendingSteeringForTask } from "./steering";
-import { isInternalConfigKey, isReservedConfigKey, reservedKeyError } from "./swarm-config-guard";
+import {
+  isInternalConfigKey,
+  isReservedConfigKey,
+  reservedKeyError,
+  teamsSdkEnvKeysSql,
+} from "./swarm-config-guard";
 import { emitTaskStarted } from "./task-lifecycle-events";
 import { publishWorkerConfigNudge, publishWorkerNudge } from "./worker-nudges";
 import { defineWorkflowPayload, type WorkflowPayloadView } from "./workflow-replay";
@@ -292,17 +304,21 @@ export {
   findTaskByGitHub,
   findTaskByVcs,
   getAgentCurrentTask,
+  getAgentWorkingOnContextKey,
   getAgentWorkingOnThread,
   getAllTasks,
   getChildTasks,
   getCompletedSlackTasks,
   getInProgressSlackTasks,
   getInProgressTasksByContextKey,
+  getLatestActiveTaskByContextKey,
   getLatestActiveTaskInThread,
+  getLatestLeadTaskByContextKey,
   getLatestLeadTaskInThread,
   getLatestScriptRunStepTaskByContextKey,
   getLatestTaskByContextKey,
   getMostRecentTaskInThread,
+  getPendingChatRelayTasks,
   getPendingSlackRelayTasks,
   getRecentlyFinishedWorkerTasks,
   getSlackTasksMissingTree,
@@ -313,14 +329,21 @@ export {
   getTasksByAgentId,
   getTasksByStatus,
   getTasksCount,
+  giveUpStaleChatRelays,
   hasNonTerminalRerouteDecisionChild,
   hasNonTerminalResumeChild,
   isLinearTrackerContextKey,
+  markChatRelayAttempted,
+  markChatRelayDelivered,
+  markChatRelayGivenUp,
   markFinalizedSlackRelaysDelivered,
   markSlackRelayAttempted,
   markSlackRelayDelivered,
   markTasksNotified,
+  type PendingChatRelay,
+  recordChatRelayError,
   resetTasksNotified,
+  SUPERSEDED_RESUME_REPAIR_WINDOW_MS,
   type TaskFilters,
 } from "./db/tasks/read";
 
@@ -2836,9 +2859,9 @@ export async function createTaskExtended(
         vcsProvider, vcsRepo, vcsEventType, vcsNumber, vcsCommentId, vcsAuthor, vcsUrl,
         vcsInstallationId, vcsNodeId,
         agentmailInboxId, agentmailMessageId, agentmailThreadId,
-        mentionMessageId, mentionChannelId, dir, parentTaskId, model, modelTier, effort, scheduleId,
+        mentionMessageId, mentionChannelId, dir, parentTaskId, model, modelTier, effort, profile, scheduleId,
         workflowRunId, workflowRunStepId, outputSchema, followUpConfig, requestedByUserId, requestedByUserIdInherited, contextKey, routingAffinity, swarmVersion, createdAt, lastUpdatedAt, created_by, updated_by, isHumanFree
-      ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?) RETURNING *`,
+      ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?) RETURNING *`,
       [
         id,
         assetKey,
@@ -2880,6 +2903,7 @@ export async function createTaskExtended(
         options?.model ?? null,
         options?.modelTier ?? null,
         options?.effort ?? null,
+        options?.profile?.trim() || null,
         options?.scheduleId ?? null,
         options?.workflowRunId ?? null,
         options?.workflowRunStepId ?? null,
@@ -4375,7 +4399,8 @@ export async function releaseStaleMentionProcessing(timeoutMinutes: number = 30)
 }
 
 // ============================================================================
-// Service Operations (PM2/background services)
+// Service Operations (removed PM2 service registry; the table and these
+// accessors stay until a drop migration lands)
 // ============================================================================
 
 type ServiceRow = {
@@ -6342,6 +6367,7 @@ type SwarmConfigRow = {
   createdAt: string;
   lastUpdatedAt: string;
   encrypted: number; // SQLite boolean: 0 = plaintext, 1 = AES-256-GCM ciphertext
+  exportToEnv?: number; // SQLite boolean; absent only on pre-215 test schemas
 };
 
 type SwarmConfigLookupRow = {
@@ -6370,6 +6396,7 @@ function rowToSwarmConfig(row: SwarmConfigRow): SwarmConfig {
       createdAt: row.createdAt,
       lastUpdatedAt: row.lastUpdatedAt,
       encrypted: isEncrypted,
+      exportToEnv: effectiveExportToEnv(row.key, row.exportToEnv !== 0),
     };
   }
 
@@ -6396,6 +6423,7 @@ function rowToSwarmConfig(row: SwarmConfigRow): SwarmConfig {
     createdAt: row.createdAt,
     lastUpdatedAt: row.lastUpdatedAt,
     encrypted: isEncrypted,
+    exportToEnv: effectiveExportToEnv(row.key, row.exportToEnv !== 0),
   };
 }
 
@@ -6550,7 +6578,7 @@ export async function getInjectableGlobalConfigs(): Promise<SwarmConfig[]> {
   const rows = await getDbClient().query<SwarmConfigRow>(
     `SELECT * FROM swarm_config
        WHERE scope = 'global'
-         AND UPPER(key) NOT IN ('API_KEY', 'SECRETS_ENCRYPTION_KEY', 'CORS_ALLOW_ANY_ORIGIN', 'EXTENSION_ALLOW_LEAD_ACTIVATION')
+         AND UPPER(key) NOT IN ('API_KEY', 'SECRETS_ENCRYPTION_KEY', 'CORS_ALLOW_ANY_ORIGIN', 'EXTENSION_ALLOW_LEAD_ACTIVATION', 'CHAT_SDK_API_URL_OVERRIDES', ${teamsSdkEnvKeysSql()})
        ORDER BY key ASC`,
   );
   return rows.filter((row) => !isInternalConfigKey(row.key)).map(rowToSwarmConfig);
@@ -6604,10 +6632,16 @@ export async function upsertSwarmConfig(data: {
   isSecret?: boolean;
   envPath?: string | null;
   description?: string | null;
+  /** Omitted: an update keeps the stored flag; an insert uses `defaultExportToEnv`. */
+  exportToEnv?: boolean;
 }): Promise<SwarmConfig> {
   if (isReservedConfigKey(data.key)) {
     throw reservedKeyError(data.key);
   }
+  if (data.exportToEnv === true && isEnvExportRestrictedKey(data.key)) {
+    throw new Error(envExportRestrictedError(data.key));
+  }
+  const restricted = isEnvExportRestrictedKey(data.key);
 
   const now = new Date().toISOString();
   const scopeId = data.scope === "global" ? null : (data.scopeId ?? null);
@@ -6631,41 +6665,55 @@ export async function upsertSwarmConfig(data: {
   const row = await getDbClient().transaction(async () => {
     const existing =
       scopeId === null
-        ? await getDbClient().get<{ id: string }>(
-            "SELECT id FROM swarm_config WHERE scope = ? AND scopeId IS NULL AND key = ?",
+        ? await getDbClient().get<SwarmConfigRow>(
+            "SELECT * FROM swarm_config WHERE scope = ? AND scopeId IS NULL AND key = ?",
             [data.scope, data.key],
           )
-        : await getDbClient().get<{ id: string }>(
-            "SELECT id FROM swarm_config WHERE scope = ? AND scopeId = ? AND key = ?",
+        : await getDbClient().get<SwarmConfigRow>(
+            "SELECT * FROM swarm_config WHERE scope = ? AND scopeId = ? AND key = ?",
             [data.scope, scopeId, data.key],
           );
 
-    if (existing) {
-      return await getDbClient().get<SwarmConfigRow>(
-        `UPDATE swarm_config SET value = ?, isSecret = ?, envPath = ?, description = ?, encrypted = ?, lastUpdatedAt = ?
-         WHERE id = ? RETURNING *`,
-        [storedValue, isSecret, envPath, description, encryptedFlag, now, existing.id],
-      );
+    // COALESCE keeps the stored flag when the caller did not send one.
+    const written = existing
+      ? await getDbClient().get<SwarmConfigRow>(
+          `UPDATE swarm_config SET value = ?, isSecret = ?, envPath = ?, description = ?, encrypted = ?, lastUpdatedAt = ?,
+             exportToEnv = CASE WHEN ? THEN 0 ELSE COALESCE(?, exportToEnv) END
+           WHERE id = ? RETURNING *`,
+          [
+            storedValue,
+            isSecret,
+            envPath,
+            description,
+            encryptedFlag,
+            now,
+            restricted ? 1 : 0,
+            data.exportToEnv === undefined ? null : data.exportToEnv ? 1 : 0,
+            existing.id,
+          ],
+        )
+      : await getDbClient().get<SwarmConfigRow>(
+          `INSERT INTO swarm_config (id, scope, scopeId, key, value, isSecret, envPath, description, createdAt, lastUpdatedAt, encrypted, exportToEnv)
+             VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?) RETURNING *`,
+          [
+            crypto.randomUUID(),
+            data.scope,
+            scopeId,
+            data.key,
+            storedValue,
+            isSecret,
+            envPath,
+            description,
+            now,
+            now,
+            encryptedFlag,
+            restricted ? 0 : (data.exportToEnv ?? defaultExportToEnv(data.key)) ? 1 : 0,
+          ],
+        );
+    if (data.scope === "agent" && scopeId) {
+      await clearAgentModelProfileOnOverrideChange(scopeId, data.key, existing, written);
     }
-
-    const id = crypto.randomUUID();
-    return await getDbClient().get<SwarmConfigRow>(
-      `INSERT INTO swarm_config (id, scope, scopeId, key, value, isSecret, envPath, description, createdAt, lastUpdatedAt, encrypted)
-         VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?) RETURNING *`,
-      [
-        id,
-        data.scope,
-        scopeId,
-        data.key,
-        storedValue,
-        isSecret,
-        envPath,
-        description,
-        now,
-        now,
-        encryptedFlag,
-      ],
-    );
+    return written;
   });
 
   if (!row) throw new Error("Failed to upsert swarm config");
@@ -6714,10 +6762,13 @@ export async function emitBuiltInIntegrationConnectedOnce(
  * predate hardening must remain removable through remediation paths.
  */
 export async function deleteSwarmConfig(id: string): Promise<boolean> {
-  const row = await getDbClient().get<Pick<SwarmConfigRow, "scope" | "scopeId">>(
-    "DELETE FROM swarm_config WHERE id = ? RETURNING scope, scopeId",
+  const row = await getDbClient().get<SwarmConfigRow>(
+    "DELETE FROM swarm_config WHERE id = ? RETURNING *",
     [id],
   );
+  if (row?.scope === "agent" && row.scopeId) {
+    await clearAgentModelProfileOnOverrideChange(row.scopeId, row.key, row, null);
+  }
   if (row) getDbClient().afterCommit(() => publishWorkerConfigNudge(row.scope, row.scopeId));
   return row !== null;
 }

package/src/be/migrations/215_swarm_config_export_to_env.sql

@@ -0,0 +1,34 @@
+-- Per-row flag: does this swarm_config row reach an agent's process env?
+-- Workers export a row into the harness env (and so into every agent shell)
+-- only when exportToEnv = 1. Rows with 0 stay server-side and are used through
+-- connections or script credential bindings.
+--
+-- Existing rows keep today's behaviour (exported), so nothing breaks at deploy.
+ALTER TABLE swarm_config ADD COLUMN exportToEnv INTEGER NOT NULL DEFAULT 1;
+
+-- Deny list: rows only the API server reads. The first block matches
+-- ENV_EXPORT_RESTRICTED_KEYS in src/utils/config-env-export.ts (never
+-- exportable); the second block (ENV_EXPORT_DEFAULT_OFF_KEYS, also the insert
+-- default for new rows) is off by default but operators may turn it
+-- back on per row.
+UPDATE swarm_config SET exportToEnv = 0
+WHERE upper(key) IN (
+    'SLACK_APP_TOKEN',
+    'SLACK_SIGNING_SECRET',
+    'GITHUB_APP_PRIVATE_KEY',
+    'GITHUB_WEBHOOK_SECRET',
+    'GITLAB_WEBHOOK_SECRET',
+    'LINEAR_CLIENT_SECRET',
+    'LINEAR_SIGNING_SECRET',
+    'JIRA_CLIENT_SECRET',
+    'JIRA_WEBHOOK_TOKEN',
+    'AZURE_DEVOPS_WEBHOOK_SECRET',
+    'AGENTMAIL_WEBHOOK_SECRET',
+    'API_AGENT_FS_API_KEY',
+    'KAPSO_WEBHOOK_HMAC_SECRET',
+    'SENTRY_TEST_APP_WEBHOOK_SECRET',
+    'TELEMETRY_CH_AUTH',
+    'HACK_AGENT_FS_ADMIN_KEY',
+    'X_CLIENT_SECRET'
+  )
+  OR key GLOB 'connection.*.secret';

package/src/be/migrations/216_task_resolved_effort.sql

@@ -0,0 +1,5 @@
+-- The reasoning effort a task's session actually ran at. `effort` stays the
+-- requested value (a task-level pin); the effective one usually comes from the
+-- agent's REASONING_EFFORT_OVERRIDE and was never recorded. NULL means the
+-- harness default applied, or the row predates this column.
+ALTER TABLE agent_tasks ADD COLUMN resolvedEffort TEXT;