@desplega.ai/agent-swarm 1.173.0 → 2.0.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@desplega.ai/agent-swarm",
-  "version": "1.173.0",
+  "version": "2.0.0",
   "description": "agent-swarm.dev — an open-source operating system for AI work: a lead agent breaks goals into tasks, routes them to specialized workers such as Claude Code or Codex, runs each worker in an isolated container, and preserves shared memory, tools, schedules, and review gates so delegated work compounds across sessions.",
   "keywords": [
     "agent-swarm.dev",
@@ -168,11 +168,6 @@
     "docs:mcp": "bun scripts/generate-mcp-docs.ts",
     "docs:openapi": "bun scripts/generate-openapi.ts",
     "docs:business-use": "bun scripts/generate-business-use-docs.ts",
-    "pm2-start": "pm2 start ecosystem.config.cjs",
-    "pm2-stop": "pm2 stop ecosystem.config.cjs",
-    "pm2-restart": "pm2 restart ecosystem.config.cjs",
-    "pm2-logs": "pm2 logs swarm-api swarm-ui swarm-lead swarm-worker",
-    "pm2-status": "pm2 status swarm-api swarm-ui swarm-lead swarm-worker",
     "seed": "bun scripts/seed.ts",
     "seed:clean": "bun scripts/seed.ts --clean",
     "seed:people": "bun scripts/seed-people.ts",
@@ -180,7 +175,7 @@
   },
   "devDependencies": {
     "@biomejs/biome": "^2.3.10",
-    "@desplega.ai/slack-mock": "^0.4.0",
+    "@desplega.ai/slack-mock": "^0.4.1",
     "@desplega/model-catalog": "workspace:*",
     "@desplega/model-routing": "workspace:*",
     "@faker-js/faker": "^10.4.0",
@@ -205,13 +200,16 @@
   "dependencies": {
     "@agentclientprotocol/sdk": "1.8.0",
     "@ai-sdk/openai": "^3.0.41",
-    "@anthropic-ai/claude-agent-sdk": "0.3.299",
-    "@anthropic-ai/sdk": "^0.133.0",
+    "@anthropic-ai/claude-agent-sdk": "0.3.300",
+    "@anthropic-ai/sdk": "^0.134.0",
     "@asteasolutions/zod-to-openapi": "^8.0.0",
     "@aws-sdk/client-bedrock": "3.1048.0",
+    "@chat-adapter/discord": "4.41.1",
+    "@chat-adapter/slack": "4.41.1",
+    "@chat-adapter/teams": "4.41.1",
+    "@chat-adapter/telegram": "4.41.1",
     "@cursor/sdk": "1.0.37",
     "@desplega.ai/business-use": "^0.4.2",
-    "@desplega.ai/localtunnel": "^2.2.0",
     "@earendil-works/pi-agent-core": "^1.2.0",
     "@earendil-works/pi-ai": "^1.2.0",
     "@earendil-works/pi-coding-agent": "^1.2.0",
@@ -230,15 +228,16 @@
     "@opentelemetry/sdk-node": "^0.218.0",
     "@opentelemetry/semantic-conventions": "^1.41.1",
     "@slack/bolt": "^4.6.0",
+    "@slack/web-api": "7.13.0",
     "@types/react": "^19.2.7",
     "@x402/core": "^2.5.0",
     "@x402/evm": "^2.5.0",
     "@x402/fetch": "^2.5.0",
     "ai": "^6.0.116",
+    "chat": "4.41.1",
     "cron-parser": "^5.4.0",
     "date-fns": "^4.1.0",
     "e2b": "2.26.0",
-    "hono": "^4.12.3",
     "ink": "^6.5.1",
     "oauth4webapi": "^3.8.5",
     "openai": "^6.22.0",

package/src/be/config-refs.ts

@@ -0,0 +1,60 @@
+/**
+ * Config references: `{ "$config": "KEY" }` leaves inside a JSON config value
+ * that point at another config key (usually a secret). Pure, no DB access: the
+ * caller supplies the lookup and decides which keys are allowed.
+ */
+
+export interface ConfigRef {
+  $config: string;
+}
+
+/** True when `value` is exactly `{ "$config": "<non-empty string>" }`. */
+export function isConfigRef(value: unknown): value is ConfigRef {
+  if (value === null || typeof value !== "object" || Array.isArray(value)) return false;
+  const keys = Object.keys(value);
+  const ref = (value as { $config?: unknown }).$config;
+  return keys.length === 1 && keys[0] === "$config" && typeof ref === "string" && ref.length > 0;
+}
+
+export class ConfigRefError extends Error {
+  constructor(
+    message: string,
+    readonly missingKeys: string[],
+  ) {
+    super(message);
+    this.name = "ConfigRefError";
+  }
+}
+
+/**
+ * Replace every `{ "$config": "KEY" }` leaf in `value` with `lookup(KEY)`.
+ * Walks arrays and plain objects. Missing keys (lookup returns undefined) are
+ * collected and reported in one error. A lookup that throws (for example on a
+ * forbidden key) propagates as-is.
+ */
+export function resolveConfigRefs<T>(
+  value: unknown,
+  lookup: (key: string) => string | undefined,
+): T {
+  const missing = new Set<string>();
+
+  const walk = (node: unknown): unknown => {
+    if (isConfigRef(node)) {
+      const resolved = lookup(node.$config);
+      if (resolved === undefined) missing.add(node.$config);
+      return resolved;
+    }
+    if (Array.isArray(node)) return node.map(walk);
+    if (node !== null && typeof node === "object") {
+      return Object.fromEntries(Object.entries(node).map(([k, v]) => [k, walk(v)]));
+    }
+    return node;
+  };
+
+  const result = walk(value);
+  if (missing.size > 0) {
+    const keys = [...missing].sort();
+    throw new ConfigRefError(`Unresolved config reference(s): ${keys.join(", ")}`, keys);
+  }
+  return result as T;
+}

package/src/be/db/page-versions.ts

@@ -0,0 +1,15 @@
+import { getDbClient } from "./runtime";
+
+/**
+ * The page's edit counter, `MAX(page_versions.version) + 1`, or 1 before the
+ * first snapshot. Reads one indexed aggregate instead of every snapshot body:
+ * loading all versions of a large, often-edited page blocked the event loop
+ * for seconds per call.
+ */
+export async function getPageEditCounter(pageId: string): Promise<number> {
+  const row = await getDbClient().get<{ latest: number | null }>(
+    "SELECT MAX(version) AS latest FROM page_versions WHERE pageId = ?",
+    [pageId],
+  );
+  return (row?.latest ?? 0) + 1;
+}

package/src/be/db/runtime.ts

@@ -104,7 +104,34 @@ export function initDb(dbPath = "./agent-swarm-db.sqlite"): Database {
   db = new Database(dbPath, { create: true });
   console.log(`Database initialized at ${dbPath}`);
 
-  const database = db;
+  // Boot must finish before getDb() hands this handle out. A step below can
+  // throw SQLITE_BUSY while another connection holds the file, and the
+  // db-client retries BUSY by calling getDb() again. With `db` still assigned,
+  // that retry got a connection whose encryption key was never resolved, and
+  // the server died on "Encryption key not resolved yet". Drop the handle so
+  // the retry runs boot again.
+  const opened = db;
+  try {
+    return bootOpenedDb(opened, dbPath, resolvePromptTemplate, autoEncryptLegacyPlaintextSecrets);
+  } catch (error) {
+    if (db === opened) {
+      db = null;
+      try {
+        opened.close();
+      } catch {
+        // Already closed by the step that failed.
+      }
+    }
+    throw error;
+  }
+}
+
+function bootOpenedDb(
+  database: Database,
+  dbPath: string,
+  resolvePromptTemplate: typeof import("../db").resolvePromptTemplate,
+  autoEncryptLegacyPlaintextSecrets: typeof import("../db").autoEncryptLegacyPlaintextSecrets,
+): Database {
   database.run("PRAGMA journal_mode = WAL;");
   database.run("PRAGMA busy_timeout = 5000;");
   database.run("PRAGMA foreign_keys = ON;");
@@ -140,7 +167,7 @@ export function initDb(dbPath = "./agent-swarm-db.sqlite"): Database {
   // Old databases have CHECK(status IN ('pending','in_progress','completed','failed'))
   // which blocks 'cancelled', 'paused', 'offered', 'unassigned' statuses
   try {
-    const taskSchemaInfo = db
+    const taskSchemaInfo = database
       .prepare<{ sql: string | null }, []>(
         "SELECT sql FROM sqlite_master WHERE type = 'table' AND name = 'agent_tasks'",
       )
@@ -153,7 +180,7 @@ export function initDb(dbPath = "./agent-swarm-db.sqlite"): Database {
 
     if (needsStatusMigration) {
       console.log("[Migration] Removing restrictive CHECK constraint on agent_tasks.status");
-      db.run("PRAGMA foreign_keys=off");
+      database.run("PRAGMA foreign_keys=off");
 
       // Migrations run before this compatibility guard, so a legacy table now
       // carries every current column. Rebuilding from an old hard-coded column
@@ -169,12 +196,12 @@ export function initDb(dbPath = "./agent-swarm-db.sqlite"): Database {
       if (rebuiltSchemaSql === schemaSql || !/agent_tasks_new/i.test(rebuiltSchemaSql)) {
         throw new Error("Could not derive agent_tasks schema without legacy status CHECK");
       }
-      const columns = db
+      const columns = database
         .prepare<{ name: string }, []>('PRAGMA table_info("agent_tasks")')
         .all()
         .map((column) => `"${column.name.replaceAll('"', '""')}"`)
         .join(", ");
-      const schemaObjects = db
+      const schemaObjects = database
         .prepare<{ sql: string }, []>(
           `SELECT sql FROM sqlite_master
            WHERE tbl_name = 'agent_tasks'
@@ -194,13 +221,13 @@ export function initDb(dbPath = "./agent-swarm-db.sqlite"): Database {
         for (const sql of schemaObjects) database.run(sql);
       })();
 
-      db.run("PRAGMA foreign_keys=on");
+      database.run("PRAGMA foreign_keys=on");
       console.log("[Migration] Successfully removed CHECK constraint on agent_tasks.status");
     }
   } catch (e) {
     console.error("[Migration] Failed to update agent_tasks CHECK constraint:", e);
     try {
-      db.run("PRAGMA foreign_keys=on");
+      database.run("PRAGMA foreign_keys=on");
     } catch (cleanupError) {
       console.error("[Migration] Failed to re-enable SQLite foreign_keys pragma:", cleanupError);
     }
@@ -291,7 +318,7 @@ export function initDb(dbPath = "./agent-swarm-db.sqlite"): Database {
     throw err;
   }
 
-  return db;
+  return database;
 }
 
 export function getDb(path?: string): Database {

package/src/be/db/skill-name-resolution.ts

@@ -0,0 +1,36 @@
+import { getDbClient } from "./runtime";
+
+export type SwarmSkillNameResolution =
+  | { kind: "found"; skillId: string }
+  | { kind: "ambiguous"; skillIds: string[] }
+  | { kind: "none" };
+
+/**
+ * Resolve a swarm-scope skill name for `skill-get`.
+ *
+ * Migration 019 makes a name unique only per scope + owner, so a swarm name can
+ * match one ownerless row plus any number of agent-owned rows. Precedence:
+ * the ownerless row, then the caller's own row, then a single owned row.
+ * Several foreign-owned rows are ambiguous; the caller must pass a skillId.
+ *
+ * `getSkillByName(name, "swarm")` stays ownerless-only: the seeder relies on it.
+ */
+export async function resolveSwarmSkillByName(
+  name: string,
+  callerAgentId?: string,
+): Promise<SwarmSkillNameResolution> {
+  const rows = await getDbClient().query<{ id: string; ownerAgentId: string | null }>(
+    "SELECT id, ownerAgentId FROM skills WHERE name = ? AND scope = 'swarm' ORDER BY createdAt, id",
+    [name],
+  );
+
+  const ownerless = rows.find((row) => !row.ownerAgentId);
+  if (ownerless) return { kind: "found", skillId: ownerless.id };
+
+  const own = callerAgentId ? rows.find((row) => row.ownerAgentId === callerAgentId) : undefined;
+  if (own) return { kind: "found", skillId: own.id };
+
+  if (rows.length === 1) return { kind: "found", skillId: rows[0]!.id };
+  if (rows.length > 1) return { kind: "ambiguous", skillIds: rows.map((row) => row.id) };
+  return { kind: "none" };
+}

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);