@desplega.ai/agent-swarm 1.152.2 → 1.154.0

package/src/be/db.ts

@@ -141,10 +141,15 @@ import { normalizeDate, normalizeDateRequired } from "./date-utils";
 import {
   type AgentRow,
   configureAgentDependencies,
+  ExtensionAgentAssignmentError,
   getActiveTaskCount,
   getAgentById,
   getAllAgents,
   isAgentEligibleForTask,
+  isExtensionAgent,
+  NOT_EXTENSION_AGENT_SQL,
+  ReservedAgentRoleError,
+  reservedRoleViolation,
   rowToAgent,
 } from "./db/agents";
 import {
@@ -172,6 +177,9 @@ export {
   buildRoutingAffinityFromAgent,
   createAgent,
   deleteAgent,
+  EXTENSION_AGENT_ROLE,
+  ExtensionAgentAssignmentError,
+  extensionAgentAssignmentError,
   getActiveTaskCount,
   getAgentById,
   getAgentHarnessProviders,
@@ -181,9 +189,13 @@ export {
   hasCapacity,
   incrementEmptyPollCount,
   isAgentEligibleForTask,
+  isExtensionAgent,
   isPoolAffinityEnforcementEnabled,
   listAgentsWithCredStatusByProvider,
   MAX_EMPTY_POLLS,
+  NOT_EXTENSION_AGENT_SQL,
+  ReservedAgentRoleError,
+  reservedRoleViolation,
   resetEmptyPollCount,
   setAgentHarnessProvider,
   shouldBlockPolling,
@@ -427,6 +439,10 @@ export interface SlackMessageRecord {
   finalizedAt?: string;
   streamChunksAppended: number;
   conclusionKind?: SlackConclusionKind;
+  /** Set once a deferral card has been rewritten into its resolved state. */
+  deferralResolvedAt?: string;
+  /** Set with `deferralResolvedAt` when the rewrite was given up on. */
+  deferralAbandonedAt?: string;
   createdAt: string;
   updatedAt: string;
 }
@@ -449,6 +465,8 @@ type SlackMessageRow = {
   finalized_at: string | null;
   stream_chunks_appended: number;
   conclusion_kind: SlackConclusionKind | null;
+  deferral_resolved_at: string | null;
+  deferral_abandoned_at: string | null;
   created_at: string;
   updated_at: string;
 };
@@ -466,6 +484,8 @@ function rowToSlackMessage(row: SlackMessageRow): SlackMessageRecord {
     finalizedAt: row.finalized_at ?? undefined,
     streamChunksAppended: row.stream_chunks_appended,
     conclusionKind: row.conclusion_kind ?? undefined,
+    deferralResolvedAt: row.deferral_resolved_at ?? undefined,
+    deferralAbandonedAt: row.deferral_abandoned_at ?? undefined,
     createdAt: row.created_at,
     updatedAt: row.updated_at,
   };
@@ -675,6 +695,57 @@ export async function getSlackOutcomeMessage(taskId: string): Promise<SlackMessa
   return row ? rowToSlackMessage(row) : null;
 }
 
+/**
+ * Deferral outcome cards whose wake-up task has since reached a terminal
+ * state, and which have not been rewritten into that resolved state yet.
+ *
+ * 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.
+ * `deferredAt` (not the `deferred` tag) identifies the deferring task,
+ * because the wake-up task inherits the tag.
+ */
+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'
+       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 wake.status IN ('completed', 'failed', 'cancelled')
+       ORDER BY wake.finishedAt ASC
+       LIMIT ?`,
+    [limit],
+  );
+  return rows.map((row) => ({
+    card: rowToSlackMessage(row),
+    deferredTaskId: row.task_id!,
+    wakeTaskId: row.wake_task_id,
+  }));
+}
+
+/**
+ * Mark a deferral card as resolved, so the resolution pass skips it after.
+ * `abandoned` records that the rewrite was given up on, which hands the
+ * answer back to the wake-up's own outcome card.
+ */
+export async function markSlackDeferralResolved(
+  id: string,
+  options: { abandoned?: boolean } = {},
+): Promise<void> {
+  const now = new Date().toISOString();
+  await getDbClient().run(
+    "UPDATE slack_messages SET deferral_resolved_at = ?, deferral_abandoned_at = ? WHERE id = ?",
+    [now, options.abandoned ? now : null, id],
+  );
+}
+
 export async function getSlackTreeMessages(): Promise<SlackMessageRecord[]> {
   const rows = await getDbClient().query<SlackMessageRow>(
     `SELECT tree.*
@@ -1662,6 +1733,7 @@ type TaskSteeringMessageRow = {
   status: string;
   delivered_mode: string | null;
   source: string;
+  sender_name?: string | null;
   created_by_kind: string;
   created_by_user_id: string | null;
   created_by_agent_id: string | null;
@@ -1672,7 +1744,20 @@ type TaskSteeringMessageRow = {
   handled_note: string | null;
 };
 
+// Resolve names in the API so workers need no database access or identity lookups.
+const STEERING_MESSAGE_SELECT = `SELECT m.*,
+  CASE m.created_by_kind WHEN 'user' THEN u.name WHEN 'agent' THEN a.name END AS sender_name
+  FROM task_steering_messages m
+  LEFT JOIN users u ON m.created_by_kind = 'user' AND u.id = m.created_by_user_id
+  LEFT JOIN agents a ON m.created_by_kind = 'agent' AND a.id = m.created_by_agent_id`;
+
 function rowToSteeringMessage(row: TaskSteeringMessageRow): SteeringMessage {
+  const senderId =
+    row.created_by_kind === "user" ? row.created_by_user_id : row.created_by_agent_id;
+  const senderLabel =
+    row.created_by_kind === "system"
+      ? "system"
+      : `${row.sender_name?.trim() || senderId || "Unknown"} (${row.created_by_kind})`;
   return {
     id: row.id,
     taskId: row.task_id,
@@ -1681,6 +1766,7 @@ function rowToSteeringMessage(row: TaskSteeringMessageRow): SteeringMessage {
     status: row.status as SteeringStatus,
     deliveredMode: (row.delivered_mode as SteerMode | null) ?? undefined,
     source: row.source as SteeringSource,
+    senderLabel,
     createdByKind: row.created_by_kind as SteeringMessage["createdByKind"],
     createdByUserId: row.created_by_user_id ?? undefined,
     createdByAgentId: row.created_by_agent_id ?? undefined,
@@ -1739,7 +1825,7 @@ export async function createSteeringMessage(
     });
   } catch {}
 
-  return rowToSteeringMessage(row);
+  return (await getSteeringMessageById(id))!;
 }
 
 export async function getSteeringMessagesForTask(
@@ -1748,15 +1834,15 @@ export async function getSteeringMessagesForTask(
 ): Promise<SteeringMessage[]> {
   const rows = opts?.status
     ? await getDbClient().query<TaskSteeringMessageRow>(
-        `SELECT * FROM task_steering_messages
-           WHERE task_id = ? AND status = ?
-           ORDER BY created_at ASC, rowid ASC`,
+        `${STEERING_MESSAGE_SELECT}
+           WHERE m.task_id = ? AND m.status = ?
+           ORDER BY m.created_at ASC, m.rowid ASC`,
         [taskId, opts.status],
       )
     : await getDbClient().query<TaskSteeringMessageRow>(
-        `SELECT * FROM task_steering_messages
-           WHERE task_id = ?
-           ORDER BY created_at ASC, rowid ASC`,
+        `${STEERING_MESSAGE_SELECT}
+           WHERE m.task_id = ?
+           ORDER BY m.created_at ASC, m.rowid ASC`,
         [taskId],
       );
   return rows.map(rowToSteeringMessage);
@@ -1764,8 +1850,8 @@ export async function getSteeringMessagesForTask(
 
 export async function getSteeringMessageById(id: string): Promise<SteeringMessage | null> {
   const row = await getDbClient().get<TaskSteeringMessageRow>(
-    `SELECT * FROM task_steering_messages
-       WHERE id = ?`,
+    `${STEERING_MESSAGE_SELECT}
+       WHERE m.id = ?`,
     [id],
   );
   return row ? rowToSteeringMessage(row) : null;
@@ -1777,8 +1863,7 @@ export async function getPendingSteeringForTask(taskId: string): Promise<Steerin
 
 export async function getPendingSteeringForAgent(agentId: string): Promise<SteeringMessage[]> {
   const rows = await getDbClient().query<TaskSteeringMessageRow>(
-    `SELECT m.*
-       FROM task_steering_messages m
+    `${STEERING_MESSAGE_SELECT}
        JOIN agent_tasks t ON t.id = m.task_id
        WHERE t.agentId = ? AND m.status = 'pending'
        ORDER BY m.created_at ASC, m.rowid ASC`,
@@ -1816,7 +1901,7 @@ export async function markSteeringDelivered(
     } catch {}
   }
 
-  return row ? rowToSteeringMessage(row) : null;
+  return row ? await getSteeringMessageById(id) : null;
 }
 
 export async function markSteeringHandled(
@@ -1832,7 +1917,7 @@ export async function markSteeringHandled(
        RETURNING *`,
     [note ?? null, id],
   );
-  return row ? rowToSteeringMessage(row) : null;
+  return row ? await getSteeringMessageById(id) : null;
 }
 
 export async function markSteeringPromoted(
@@ -1847,7 +1932,7 @@ export async function markSteeringPromoted(
        RETURNING *`,
     [promotedTaskId, id],
   );
-  return row ? rowToSteeringMessage(row) : null;
+  return row ? await getSteeringMessageById(id) : null;
 }
 
 export async function cancelPendingSteeringForTask(taskId: string): Promise<number> {
@@ -2475,6 +2560,17 @@ export async function createTaskExtended(
   // (explicit `leadOnly`/`capabilities`, or a lead-only ratchet) still gates
   // as before.
   const targetAgentId = options.agentId ?? options.offeredTo;
+  // Extension identities (`ext:<name>`, role "extension") are API principals,
+  // never executors. This is the shared chokepoint for every creation path
+  // (send-task, POST /api/tasks, schedules, workflow agent-task nodes, script
+  // runs, apps, Slack fan-out, pre.task.create hook rewrites).
+  for (const id of new Set([options.agentId, options.offeredTo])) {
+    if (!id) continue;
+    const target = await getAgentById(id);
+    if (target && isExtensionAgent(target)) {
+      throw new ExtensionAgentAssignmentError(target);
+    }
+  }
   if (options.routingAffinity && targetAgentId && !routingAffinityIsInheritedProvenance) {
     const target = await getAgentById(targetAgentId);
     if (!target || !isAgentEligibleForTask(target, { routingAffinity: options.routingAffinity })) {
@@ -2763,6 +2859,9 @@ export async function acceptTask(taskId: string, agentId: string): Promise<Agent
   const task = await getTaskById(taskId);
   if (!task) return null;
   const agent = await getAgentById(agentId);
+  // Extension identities never take work, including offers left over from
+  // before creation-time rejection existed.
+  if (isExtensionAgent(agent)) return null;
   if (
     (task.routingAffinity?.leadOnly || task.routingAffinityInvalid) &&
     (!agent || !isAgentEligibleForTask(agent, task))
@@ -3053,6 +3152,7 @@ export async function claimOfferedTask(taskId: string, agentId: string): Promise
   if (!task) return null;
   if (task.status !== "offered" || task.offeredTo !== agentId) return null;
   const agent = await getAgentById(agentId);
+  if (isExtensionAgent(agent)) return null;
   if (
     (task.routingAffinity?.leadOnly || task.routingAffinityInvalid) &&
     (!agent || !isAgentEligibleForTask(agent, task))
@@ -3291,6 +3391,8 @@ export async function updateAgentProfile(
     expectedHashes?: ProfileExpectedHashes;
     /** Called once per field dropped because its expected hash was stale. */
     onConflict?: (conflict: ProfileSyncConflict) => void;
+    /** Only the extension identity lifecycle may grant the reserved extension role. */
+    allowExtensionRole?: boolean;
   },
 ): Promise<Agent | null> {
   return await getDbClient().transaction(async (tx) => {
@@ -3298,6 +3400,11 @@ export async function updateAgentProfile(
     const current = await tx.get<AgentRow>("SELECT * FROM agents WHERE id = ?", [id]);
     if (!current) return null;
 
+    const roleViolation = reservedRoleViolation(current.role, updates.role, {
+      allowExtensionRole: guard?.allowExtensionRole,
+    });
+    if (roleViolation) throw new ReservedAgentRoleError(roleViolation);
+
     // Compare with the old metadata before replacing it. Persist refreshed defaults
     // atomically so both running workers and restarted workers see matching blobs.
     const previous = rowToAgent(current);
@@ -5474,6 +5581,8 @@ type ScheduledTaskRow = {
   nextRunAt: string | null;
   createdByAgentId: string | null;
   parentTaskId: string | null;
+  requestedDelayMs: number | null;
+  requestedRunAt: string | null;
   timezone: string;
   consecutiveErrors: number | null;
   lastErrorAt: string | null;
@@ -5524,6 +5633,8 @@ function rowToScheduledTask(row: ScheduledTaskRow): ScheduledTask {
     nextRunAt: normalizeDate(row.nextRunAt) ?? undefined,
     createdByAgentId: row.createdByAgentId ?? undefined,
     parentTaskId: row.parentTaskId ?? undefined,
+    requestedDelayMs: row.requestedDelayMs ?? undefined,
+    requestedRunAt: normalizeDate(row.requestedRunAt) ?? undefined,
     timezone: row.timezone,
     consecutiveErrors: row.consecutiveErrors ?? 0,
     lastErrorAt: normalizeDate(row.lastErrorAt) ?? undefined,
@@ -5675,6 +5786,13 @@ export interface CreateScheduledTaskData {
   createdByAgentId?: string;
   /** Only `defer-task` sets this — the task the schedule's run continues. */
   parentTaskId?: string;
+  /**
+   * Only `defer-task` sets these — the delay the caller actually asked for,
+   * kept because the scheduler clears `nextRunAt` once a one_time schedule
+   * fires. Write-once provenance; nothing reads them to decide when to run.
+   */
+  requestedDelayMs?: number;
+  requestedRunAt?: string;
   timezone?: string;
   model?: string;
   modelTier?: ModelTier;
@@ -5697,11 +5815,12 @@ export async function createScheduledTask(data: CreateScheduledTaskData): Promis
     `INSERT INTO scheduled_tasks (
         id, "key", name, description, cronExpression, intervalMs, taskTemplate,
         taskType, tags, priority, targetAgentId, enabled, nextRunAt,
-        createdByAgentId, parentTaskId, timezone, model, modelTier, scheduleType,
+        createdByAgentId, parentTaskId, requestedDelayMs, requestedRunAt,
+        timezone, model, modelTier, scheduleType,
         targetType, workflowId, scriptName, scriptArgs, params, requiredParams, requires,
         createdAt, lastUpdatedAt,
         created_by, updated_by
-      ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?) RETURNING *`,
+      ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?) RETURNING *`,
     [
       id,
       normalizeAssetKey(data.key ?? defaultAssetKey("schedule", id)),
@@ -5718,6 +5837,8 @@ export async function createScheduledTask(data: CreateScheduledTaskData): Promis
       data.nextRunAt ?? null,
       data.createdByAgentId ?? null,
       data.parentTaskId ?? null,
+      data.requestedDelayMs ?? null,
+      data.requestedRunAt ?? null,
       data.timezone ?? "UTC",
       data.model ?? null,
       data.modelTier ?? null,
@@ -12565,9 +12686,10 @@ export async function getSwarmMetrics(): Promise<SwarmMetrics> {
 
   const groupCounts = async (
     table: string,
+    where?: string,
   ): Promise<{ total: number; by_status: Record<string, number> }> => {
     const rows = await client.query<{ status: string; count: number }>(
-      `SELECT status, COUNT(*) AS count FROM ${table} GROUP BY status`,
+      `SELECT status, COUNT(*) AS count FROM ${table}${where ? ` WHERE ${where}` : ""} GROUP BY status`,
     );
     const by_status: Record<string, number> = {};
     let total = 0;
@@ -12589,7 +12711,7 @@ export async function getSwarmMetrics(): Promise<SwarmMetrics> {
 
   return {
     tasks: await groupCounts("agent_tasks"),
-    agents: await groupCounts("agents"),
+    agents: await groupCounts("agents", NOT_EXTENSION_AGENT_SQL),
     workflows: { total: workflowRow?.total ?? 0, enabled: workflowRow?.enabled ?? 0 },
     pages: { total: pagesRow?.count ?? 0 },
     sessions: { active: sessionsRow?.count ?? 0 },

package/src/be/extensions/db.ts

@@ -20,8 +20,12 @@ export type InstallExtensionArgs = {
   createdBy?: string | null;
   activate?: boolean;
   changeReason?: string | null;
+  /** HTTP worker upserts must not claim another creator's name. */
+  ownerOnly?: string;
 };
 
+export class ExtensionOwnershipError extends Error {}
+
 export type InstallExtensionResult = {
   extension: Extension;
   isNew: boolean;
@@ -60,6 +64,19 @@ export async function installExtension(
       args.manifest.name,
     ]);
     const existing = existingRow ? rowToExtension(existingRow) : null;
+    if (existing && args.ownerOnly && existing.createdByAgentId !== args.ownerOnly) {
+      throw new ExtensionOwnershipError("Forbidden: extension belongs to another owner");
+    }
+    if (
+      existing?.enabled &&
+      args.ownerOnly &&
+      ((args.config !== undefined && JSON.stringify(args.config) !== existing.configJson) ||
+        (args.priority !== undefined && args.priority !== existing.priority))
+    ) {
+      throw new ExtensionOwnershipError(
+        "Forbidden: only a lead or operator may change live extension configuration",
+      );
+    }
     const now = new Date().toISOString();
 
     if (!existing) {
@@ -313,6 +330,7 @@ export async function updateExtensionMeta(
     config?: Record<string, unknown>;
     description?: string;
     updatedBy?: string | null;
+    ownerOnly?: string;
   },
 ): Promise<Extension | null> {
   const sets: string[] = [];
@@ -329,14 +347,21 @@ export async function updateExtensionMeta(
     sets.push("description = ?");
     values.push(args.description);
   }
-  if (sets.length === 0) return getExtensionById(id);
+  if (sets.length === 0 && !args.ownerOnly) return getExtensionById(id);
 
   sets.push("updated_by = ?", "updatedAt = ?");
   values.push(args.updatedBy ?? null, new Date().toISOString(), id);
+  // The enabled check must be part of the write: a lead may enable the draft
+  // after the HTTP handler has authorized it but before this UPDATE executes.
+  const ownerCondition = args.ownerOnly ? " AND createdByAgentId = ? AND enabled = 0" : "";
+  if (args.ownerOnly) values.push(args.ownerOnly);
   const row = await getDbClient().get<ExtensionRow>(
-    `UPDATE extensions SET ${sets.join(", ")} WHERE id = ? RETURNING *`,
+    `UPDATE extensions SET ${sets.join(", ")} WHERE id = ?${ownerCondition} RETURNING *`,
     values,
   );
+  if (!row && args.ownerOnly) {
+    throw new ExtensionOwnershipError("Forbidden: extension must be your own disabled draft");
+  }
   return row ? rowToExtension(row) : null;
 }
 
@@ -401,8 +426,14 @@ export async function recordExtensionFailure(
   return row ? rowToExtension(row) : null;
 }
 
-export async function deleteExtension(id: string): Promise<boolean> {
-  const result = await getDbClient().run("DELETE FROM extensions WHERE id = ?", [id]);
+export async function deleteExtension(id: string, ownerOnly?: string): Promise<boolean> {
+  const result = await getDbClient().run(
+    `DELETE FROM extensions WHERE id = ?${ownerOnly ? " AND createdByAgentId = ? AND enabled = 0" : ""}`,
+    ownerOnly ? [id, ownerOnly] : [id],
+  );
+  if (result.changes === 0 && ownerOnly) {
+    throw new ExtensionOwnershipError("Forbidden: extension must be your own disabled draft");
+  }
   return result.changes > 0;
 }
 

package/src/be/memory/raters/llm.ts

@@ -17,6 +17,7 @@
  * touch `bun:sqlite` or `src/be/db`. The boundary check enforces it.
  */
 import { z } from "zod";
+import { getMemoryRaterNames } from "../../../utils/memory-raters";
 import { ClaudeCliLlmRaterClient, type LlmRaterClient, type LlmRaterResult } from "./llm-client";
 import {
   type MemoryRater,
@@ -246,12 +247,7 @@ ${memoryBlock}`;
  * path — strict opt-in so existing deployments are byte-identical when unset.
  */
 export function isLlmRaterEnabled(): boolean {
-  const raw = process.env.MEMORY_RATERS;
-  if (!raw || raw.trim() === "") return false;
-  return raw
-    .split(",")
-    .map((s) => s.trim())
-    .includes("llm");
+  return getMemoryRaterNames().includes("llm");
 }
 
 /** Memory snapshot returned by `GET /api/memory/retrievals`. */

package/src/be/memory/raters/noop.ts

@@ -1,9 +1,8 @@
 import type { MemoryRater, RatingEvent } from "./types";
 
 /**
- * Default rater. Emits no events, makes no DB calls. Selected when
- * MEMORY_RATERS is unset or empty so the framework defaults to behaving
- * byte-identically to pre-rater builds.
+ * Disabled rater. Emits no events, makes no DB calls. Selected when
+ * MEMORY_RATERS is explicitly empty or no configured names are recognized.
  */
 export class NoopRater implements MemoryRater {
   readonly name = "noop";

package/src/be/memory/raters/registry.ts

@@ -1,3 +1,4 @@
+import { getMemoryRaterNames } from "../../../utils/memory-raters";
 import { ExplicitSelfRatingRater } from "./explicit-self";
 import { ImplicitCitationRater } from "./implicit-citation";
 import { LlmRater } from "./llm";
@@ -8,7 +9,8 @@ import type { MemoryRater } from "./types";
  * Plan: thoughts/taras/plans/2026-05-05-memory-rater-v1.5/step-1.md §4
  *
  * `MEMORY_RATERS` env — comma-separated list of rater names. Defaults to
- * `[NoopRater]` when unset/empty so existing deployments stay byte-identical.
+ * `implicit-citation,explicit-self` when unset. An explicit empty value selects
+ * `[NoopRater]`.
  *
  * `MEMORY_RATER_WEIGHTS` env — optional `name:multiplier,...` overrides.
  * Multiplier is applied to every emitted RatingEvent.weight before
@@ -43,15 +45,7 @@ const FACTORIES: Record<string, RaterFactory> = {
 export const SERVER_RATERS = new Set<string>(["implicit-citation"]);
 
 export function getRegisteredRaters(): MemoryRater[] {
-  const raw = process.env.MEMORY_RATERS;
-  if (!raw || raw.trim() === "") {
-    return [new NoopRater()];
-  }
-
-  const names = raw
-    .split(",")
-    .map((s) => s.trim())
-    .filter((s) => s.length > 0);
+  const names = getMemoryRaterNames();
 
   const raters: MemoryRater[] = [];
   for (const name of names) {

package/src/be/migrations/157_defer_provenance_and_marker.sql

@@ -0,0 +1,27 @@
+-- Persist what `defer-task` was actually ASKED for, alongside the derived
+-- `nextRunAt`. The scheduler nulls `nextRunAt` once a one_time schedule fires,
+-- so without these columns the requested-delay distribution is unrecoverable
+-- after the wake-up runs.
+--
+-- Exactly one of the two is ever set (defer-task rejects both/neither), and
+-- neither is read by the scheduler — they are write-once provenance.
+ALTER TABLE scheduled_tasks ADD COLUMN requestedDelayMs INTEGER;
+ALTER TABLE scheduled_tasks ADD COLUMN requestedRunAt TEXT;
+
+-- Marks a task that ENDED in a deferral, so renderers can tell "parked" from
+-- "done" on a row whose status is `completed` either way.
+--
+-- The `deferred` tag cannot answer this: `defer-task` adds it to the deferring
+-- task, and the wake-up task it schedules inherits the same tag — so a wake-up
+-- child that simply finished is tag-identical to one that deferred again.
+ALTER TABLE agent_tasks ADD COLUMN deferredAt TEXT;
+
+-- Set once a deferral's ⏳ outcome card has been rewritten into its resolved
+-- state, so the resolution pass rewrites each card exactly once instead of on
+-- every render tick.
+ALTER TABLE slack_messages ADD COLUMN deferral_resolved_at TEXT;
+
+-- Set alongside `deferral_resolved_at` when the rewrite was given up on
+-- (Slack refused it, or it kept failing). The wake-up's answer then never
+-- reached the ⏳ card, so the wake-up posts its own outcome card instead.
+ALTER TABLE slack_messages ADD COLUMN deferral_abandoned_at TEXT;

package/src/be/models-catalog.ts

@@ -34,6 +34,8 @@ export type CatalogProviderId = (typeof CATALOG_PROVIDER_IDS)[number];
  * of the picker between models.dev listing gaps.
  */
 export const PINNED_MODELSDEV_ENTRIES = [
+  // Official launch metadata; retain until models.dev catches up. Verified 2026-09-22.
+  "anthropic/claude-opus-5-5",
   "anthropic/claude-mythos-5",
   "anthropic/claude-sonnet-5",
   "amazon-bedrock/anthropic.claude-sonnet-5",