@desplega.ai/agent-swarm 1.172.0 → 2.0.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,6 +88,7 @@ export type AgentTaskRow = {
   model: string | null;
   modelTier: string | null;
   effort: string | null;
+  resolvedEffort?: string | null;
   resolvedModel?: string | null;
   modelSource?: string | null;
   modelAlias?: string | null;
@@ -154,6 +156,7 @@ type AgentTaskSummaryRow = Pick<
   | "modelSource"
   | "modelAlias"
   | "effort"
+  | "resolvedEffort"
   | "provider"
   | "requestedByUserId"
   | "progress"
@@ -207,6 +210,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 +319,9 @@ 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,
     scheduleId: row.scheduleId ?? undefined,
     workflowRunId: row.workflowRunId ?? undefined,
     workflowRunStepId: row.workflowRunStepId ?? undefined,
@@ -381,6 +388,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,
@@ -1035,6 +1045,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 +1501,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";
@@ -205,7 +211,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 +303,21 @@ export {
   findTaskByGitHub,
   findTaskByVcs,
   getAgentCurrentTask,
+  getAgentWorkingOnContextKey,
   getAgentWorkingOnThread,
   getAllTasks,
   getChildTasks,
   getCompletedSlackTasks,
   getInProgressSlackTasks,
   getInProgressTasksByContextKey,
+  getLatestActiveTaskByContextKey,
   getLatestActiveTaskInThread,
+  getLatestLeadTaskByContextKey,
   getLatestLeadTaskInThread,
   getLatestScriptRunStepTaskByContextKey,
   getLatestTaskByContextKey,
   getMostRecentTaskInThread,
+  getPendingChatRelayTasks,
   getPendingSlackRelayTasks,
   getRecentlyFinishedWorkerTasks,
   getSlackTasksMissingTree,
@@ -313,13 +328,19 @@ export {
   getTasksByAgentId,
   getTasksByStatus,
   getTasksCount,
+  giveUpStaleChatRelays,
   hasNonTerminalRerouteDecisionChild,
   hasNonTerminalResumeChild,
   isLinearTrackerContextKey,
+  markChatRelayAttempted,
+  markChatRelayDelivered,
+  markChatRelayGivenUp,
   markFinalizedSlackRelaysDelivered,
   markSlackRelayAttempted,
   markSlackRelayDelivered,
   markTasksNotified,
+  type PendingChatRelay,
+  recordChatRelayError,
   resetTasksNotified,
   type TaskFilters,
 } from "./db/tasks/read";
@@ -782,7 +803,8 @@ export async function getSlackOutcomeMessage(taskId: string): Promise<SlackMessa
  *
  * The join is `agent_tasks.parentTaskId` — `defer-task` sets it on the
  * schedule and `createStandaloneScheduleTask` passes it through, so the
- * wake-up task points back at the task whose card announced the wait.
+ * wake-up task points back at the task whose card announced the wait. Follow
+ * subsequent re-defers to the latest wake, keeping the original card open.
  * `deferredAt` (not the `deferred` tag) identifies the deferring task,
  * because the wake-up task inherits the tag.
  */
@@ -790,15 +812,30 @@ export async function getResolvableDeferralOutcomes(
   limit = 50,
 ): Promise<{ card: SlackMessageRecord; deferredTaskId: string; wakeTaskId: string }[]> {
   const rows = await getDbClient().query<SlackMessageRow & { wake_task_id: string }>(
-    `SELECT card.*, wake.id AS wake_task_id
-       FROM slack_messages card
-       JOIN agent_tasks deferred ON deferred.id = card.task_id
-       JOIN agent_tasks wake ON wake.parentTaskId = deferred.id AND wake.taskType = 'deferred'
+    `WITH RECURSIVE chain(card_id, task_id) AS (
+         SELECT card.id, deferred.id FROM slack_messages card
+         JOIN agent_tasks deferred ON deferred.id = card.task_id
+         WHERE card.kind = 'outcome' AND deferred.deferredAt IS NOT NULL
+           AND card.deferral_resolved_at IS NULL AND card.finalized_at IS NOT NULL
+           AND card.ts NOT LIKE 'pending:%'
+         UNION
+         SELECT chain.card_id, wake.id FROM chain
+         JOIN agent_tasks parent ON parent.id = chain.task_id AND parent.deferredAt IS NOT NULL
+         JOIN agent_tasks wake ON wake.parentTaskId = parent.id AND wake.taskType = 'deferred'
+       )
+       SELECT card.*, wake.id AS wake_task_id
+       FROM chain
+       JOIN slack_messages card ON card.id = chain.card_id
+       JOIN agent_tasks wake ON wake.id = chain.task_id AND wake.id != card.task_id
        WHERE card.kind = 'outcome'
          AND card.finalized_at IS NOT NULL
          AND card.deferral_resolved_at IS NULL
          AND card.ts NOT LIKE 'pending:%'
-         AND deferred.deferredAt IS NOT NULL
+         AND NOT EXISTS (
+           SELECT 1 FROM agent_tasks child
+           WHERE child.parentTaskId = wake.id AND child.taskType = 'deferred'
+         )
+         AND (wake.deferredAt IS NULL OR wake.finishedAt > card.updated_at)
          AND wake.status IN ('completed', 'failed', 'cancelled')
        ORDER BY wake.finishedAt ASC
        LIMIT ?`,
@@ -4359,7 +4396,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 = {
@@ -6326,6 +6364,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 = {
@@ -6354,6 +6393,7 @@ function rowToSwarmConfig(row: SwarmConfigRow): SwarmConfig {
       createdAt: row.createdAt,
       lastUpdatedAt: row.lastUpdatedAt,
       encrypted: isEncrypted,
+      exportToEnv: effectiveExportToEnv(row.key, row.exportToEnv !== 0),
     };
   }
 
@@ -6380,6 +6420,7 @@ function rowToSwarmConfig(row: SwarmConfigRow): SwarmConfig {
     createdAt: row.createdAt,
     lastUpdatedAt: row.lastUpdatedAt,
     encrypted: isEncrypted,
+    exportToEnv: effectiveExportToEnv(row.key, row.exportToEnv !== 0),
   };
 }
 
@@ -6534,7 +6575,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);
@@ -6588,10 +6629,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);
@@ -6625,17 +6672,30 @@ export async function upsertSwarmConfig(data: {
           );
 
     if (existing) {
+      // COALESCE keeps the stored flag when the caller did not send one.
       return await getDbClient().get<SwarmConfigRow>(
-        `UPDATE swarm_config SET value = ?, isSecret = ?, envPath = ?, description = ?, encrypted = ?, lastUpdatedAt = ?
+        `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, existing.id],
+        [
+          storedValue,
+          isSecret,
+          envPath,
+          description,
+          encryptedFlag,
+          now,
+          restricted ? 1 : 0,
+          data.exportToEnv === undefined ? null : data.exportToEnv ? 1 : 0,
+          existing.id,
+        ],
       );
     }
 
     const id = crypto.randomUUID();
+    const exportToEnv = restricted ? 0 : (data.exportToEnv ?? defaultExportToEnv(data.key)) ? 1 : 0;
     return await getDbClient().get<SwarmConfigRow>(
-      `INSERT INTO swarm_config (id, scope, scopeId, key, value, isSecret, envPath, description, createdAt, lastUpdatedAt, encrypted)
-         VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?) RETURNING *`,
+      `INSERT INTO swarm_config (id, scope, scopeId, key, value, isSecret, envPath, description, createdAt, lastUpdatedAt, encrypted, exportToEnv)
+         VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?) RETURNING *`,
       [
         id,
         data.scope,
@@ -6648,6 +6708,7 @@ export async function upsertSwarmConfig(data: {
         now,
         now,
         encryptedFlag,
+        exportToEnv,
       ],
     );
   });

package/src/be/migrations/213_script_connections_sql.sql

@@ -0,0 +1,79 @@
+-- SQL script connections (kind = 'sql').
+--
+-- A sql connection stores no HTTP auth (auth_type stays 'none'); its
+-- auth_config_key holds the swarm_config key of the encrypted Postgres DSN,
+-- resolved only on the API server. SQLite cannot alter a CHECK constraint, so
+-- the table is rebuilt with the full current column set (117 rebuild + the
+-- embedded auth columns). No new columns.
+--
+-- The migration runner disables foreign-key enforcement for the pass, so the
+-- DROP does not cascade into script_credential_bindings.managed_by_connection_id
+-- and the RENAME keeps the stable name that FK points to (same as 117).
+
+DROP TABLE IF EXISTS script_connections_new;
+
+CREATE TABLE script_connections_new (
+  id TEXT PRIMARY KEY,
+  slug TEXT NOT NULL,
+  display_name TEXT,
+  kind TEXT NOT NULL CHECK(kind IN ('raw', 'openapi', 'mcp', 'graphql', 'sql')),
+  scope TEXT NOT NULL DEFAULT 'global' CHECK(scope IN ('global', 'agent', 'repo')),
+  scope_id TEXT,
+  base_url TEXT,
+  base_url_source TEXT NOT NULL DEFAULT 'user' CHECK(base_url_source IN ('user', 'spec')),
+  allowed_hosts_json TEXT NOT NULL DEFAULT '[]',
+  credential_binding_id TEXT REFERENCES script_credential_bindings(id) ON DELETE SET NULL,
+  openapi_spec_source_kind TEXT CHECK(openapi_spec_source_kind IN ('url', 'inline', 'agent_fs', 'vendored')),
+  openapi_spec_source TEXT,
+  openapi_spec_json TEXT,
+  openapi_spec_etag TEXT,
+  openapi_spec_fetched_at TEXT,
+  mcp_server_id TEXT REFERENCES mcp_servers(id) ON DELETE SET NULL,
+  generated_types TEXT,
+  generated_runtime_json TEXT,
+  generated_at TEXT,
+  generation_error TEXT,
+  enabled INTEGER NOT NULL DEFAULT 1,
+  version INTEGER NOT NULL DEFAULT 1,
+  created_at TEXT NOT NULL DEFAULT (datetime('now')),
+  updated_at TEXT NOT NULL DEFAULT (datetime('now')),
+  created_by TEXT REFERENCES users(id),
+  updated_by TEXT REFERENCES users(id),
+  auth_type TEXT NOT NULL DEFAULT 'none'
+    CHECK(auth_type IN ('none', 'bearer', 'header', 'query', 'oauth')),
+  auth_config_key TEXT,
+  auth_authorization_id TEXT REFERENCES oauth_authorizations(id) ON DELETE SET NULL,
+  auth_param_name TEXT,
+  auth_template_override TEXT,
+  auth_hosts_override_json TEXT,
+  CHECK(scope = 'global' OR scope_id IS NOT NULL),
+  CHECK(kind != 'openapi' OR openapi_spec_json IS NOT NULL),
+  CHECK(kind != 'mcp' OR mcp_server_id IS NOT NULL),
+  CHECK(kind != 'sql' OR auth_config_key IS NOT NULL)
+);
+
+INSERT INTO script_connections_new (
+  id, slug, display_name, kind, scope, scope_id, base_url, base_url_source, allowed_hosts_json,
+  credential_binding_id, openapi_spec_source_kind, openapi_spec_source, openapi_spec_json,
+  openapi_spec_etag, openapi_spec_fetched_at, mcp_server_id, generated_types,
+  generated_runtime_json, generated_at, generation_error, enabled, version, created_at,
+  updated_at, created_by, updated_by, auth_type, auth_config_key, auth_authorization_id,
+  auth_param_name, auth_template_override, auth_hosts_override_json
+)
+SELECT
+  id, slug, display_name, kind, scope, scope_id, base_url, base_url_source, allowed_hosts_json,
+  credential_binding_id, openapi_spec_source_kind, openapi_spec_source, openapi_spec_json,
+  openapi_spec_etag, openapi_spec_fetched_at, mcp_server_id, generated_types,
+  generated_runtime_json, generated_at, generation_error, enabled, version, created_at,
+  updated_at, created_by, updated_by, auth_type, auth_config_key, auth_authorization_id,
+  auth_param_name, auth_template_override, auth_hosts_override_json
+FROM script_connections;
+
+DROP TABLE script_connections;
+ALTER TABLE script_connections_new RENAME TO script_connections;
+
+CREATE UNIQUE INDEX IF NOT EXISTS idx_script_connections_slug_scope
+  ON script_connections(slug, scope, COALESCE(scope_id, ''));
+
+CREATE INDEX IF NOT EXISTS idx_script_connections_kind_enabled
+  ON script_connections(kind, enabled);

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;