@desplega.ai/agent-swarm 1.152.2 → 1.154.0

package/src/tools/defer-task.ts

@@ -18,7 +18,6 @@ import { getTaskOutputValidationError } from "@/tasks/terminal-result-guard";
 import { assertOwnsTask, ownerCtx } from "@/tools/task-tool-ctx";
 import { createToolRegistrar, swarmToolOutputSchema, toolErr, toolOk } from "@/tools/utils";
 import { isTerminalTaskStatus } from "@/types";
-import { getAppUrl } from "@/utils/constants";
 
 /** Thrown inside the transaction to abort and roll back the schedule INSERT. */
 class DeferAbortedError extends Error {}
@@ -55,7 +54,7 @@ function partsInTz(date: Date, tz: string) {
 }
 
 /**
- * "today"/"tomorrow" or "MM-dd" plus "HH:MM:ss", both computed in `tz`.
+ * "today"/"tomorrow" or "MM-dd" plus "HH:MM", both computed in `tz`.
  * Falls back to UTC (parts still computed correctly) if `tz` is not a valid
  * IANA zone — the caller decides whether to label the fallback.
  */
@@ -71,7 +70,9 @@ function formatDeferralDateTime(
     zone = "UTC";
   }
   const t = partsInTz(target, zone);
-  const time = `${t.hour}:${t.minute}:${t.second}`;
+  // Minute precision: this string is read by a human deciding whether to wait,
+  // and the wake-up is scheduler-polled anyway, so seconds were false precision.
+  const time = `${t.hour}:${t.minute}`;
   const n = partsInTz(now, zone);
   if (t.year === n.year && t.month === n.month && t.day === n.day) return { date: "today", time };
   const tm = partsInTz(new Date(now.getTime() + 86_400_000), zone);
@@ -98,38 +99,59 @@ async function resolveRequesterTimezone(
   return { tz: "UTC", isFallback: true };
 }
 
-/** First line of `note`, `Pending:` prefix stripped, capped to ~100 chars. */
-function renderShortDesc(note: string, max = 100): string {
-  const firstLine = (note.split("\n")[0] ?? "").trim().replace(/^pending:\s*/i, "");
-  if (firstLine.length <= max) return firstLine;
-  return `${firstLine.slice(0, max - 1).trimEnd()}…`;
+/** "Researcher", "Researcher and Picateclas", "A, B and C". */
+function joinNames(names: string[]): string {
+  if (names.length < 2) return names[0] ?? "";
+  return `${names.slice(0, -1).join(", ")} and ${names[names.length - 1]}`;
+}
+
+/**
+ * Who a `wakeOn` deferral is waiting on, in the card's words: the distinct
+ * agent names behind the watched tasks, or a bare count when none of them is
+ * assigned (an unassigned watched task has no name a human would recognise).
+ */
+export function renderWaitingOn(agentNames: string[], watchedCount: number): string {
+  const named = joinNames([...new Set(agentNames.filter((name) => name.trim()))]);
+  if (named) return named;
+  return `${watchedCount} task${watchedCount === 1 ? "" : "s"}`;
+}
+
+/** "today at 18:38" / "tomorrow at 18:38" / "on 09-24 at 18:38". */
+function renderWhen(nextRunAt: string, tz: string, isFallbackTz: boolean): string {
+  const { date, time } = formatDeferralDateTime(new Date(nextRunAt), new Date(), tz);
+  const timeLabel = isFallbackTz ? `${time} UTC` : time;
+  const day = date === "today" || date === "tomorrow" ? date : `on ${date}`;
+  return `${day} at ${timeLabel}`;
 }
 
 /**
  * Human-facing deferral text for tasks without an outputSchema — this is what
- * lands verbatim in a human's Slack thread as the task's terminal output.
- * One line: `Deferred until {date} {time} ([shortId](url)) -> {short desc}`.
- * No ISO timestamp, no bare UUID, no checks list, no `Pending:` prefix —
- * those stay in the task log. The `[text](url)` link is plain GFM markdown:
- * `markdownToSlack` (src/slack/blocks.ts) already down-converts it to a
- * readable `text (url)` fallback for Slack, and it reads fine verbatim in
- * the non-Slack task-output row / UI too.
+ * lands verbatim in a human's Slack thread as the task's terminal output, and
+ * in the UI's task-detail output row.
+ *
+ * It answers one question — when does this come back — in the two shapes a
+ * deferral actually has:
+ *
+ *   time-based  (no wakeOn)  `Checking back today at 18:38`
+ *   event-based (wakeOn)     `Waiting on Researcher — or today at 18:38 at the latest`
+ *
+ * A wakeOn deferral always carries a time ceiling too (`delayMs`/`runAt` is
+ * required), so the "both" wording is the only event shape reachable — which
+ * is also the honest one: the event resumes it, the ceiling guarantees it.
+ *
+ * Deliberately absent: the agent's `note` (written for the wake-up agent, not
+ * for a human — it goes to the task log and the wake-up task's template), the
+ * `checks` list, the schedule UUID and its app.agent-swarm.dev link. The glyph
+ * is added by the Slack renderer, matching how ✅/❌ outcomes are composed.
  */
 function renderHumanFacingDeferral(
-  note: string,
   nextRunAt: string,
-  scheduleId: string,
   tz: string,
   isFallbackTz: boolean,
+  waitingOn: string | undefined,
 ): string {
-  const now = new Date();
-  const target = new Date(nextRunAt);
-  const { date, time } = formatDeferralDateTime(target, now, tz);
-  const timeLabel = isFallbackTz ? `${time} UTC` : time;
-  const shortId = scheduleId.slice(0, 8);
-  const link = `[${shortId}](${getAppUrl()}/schedules/${scheduleId})`;
-  const shortDesc = renderShortDesc(note);
-  return `Deferred until ${date} ${timeLabel} (${link}) -> ${shortDesc}`;
+  const when = renderWhen(nextRunAt, tz, isFallbackTz);
+  return waitingOn ? `Waiting on ${waitingOn} — or ${when} at the latest` : `Checking back ${when}`;
 }
 
 export const registerDeferTaskTool = (server: McpServer) => {
@@ -284,6 +306,7 @@ export const registerDeferTaskTool = (server: McpServer) => {
 
       try {
         const committed = await getDbClient().transaction(async () => {
+          const watchedAgentNames: string[] = [];
           for (const watchedId of watchedTaskIds) {
             if (watchedId === taskId)
               throw new DeferAbortedError("Cannot wake on the task being deferred.");
@@ -293,6 +316,11 @@ export const registerDeferTaskTool = (server: McpServer) => {
               throw new DeferAbortedError(
                 `Watched task ${watchedId} is already ${watched.status}; read its result instead of deferring.`,
               );
+            // Resolved now, not at render time: the card is baked into the
+            // task's terminal output, and an agent can be renamed or removed
+            // between the deferral and whoever reads the thread later.
+            const watchedAgent = watched.agentId ? await getAgentById(watched.agentId) : null;
+            if (watchedAgent?.name) watchedAgentNames.push(watchedAgent.name);
           }
           const schedule = await createScheduledTask({
             // Unique name (`getScheduledTaskByName` is a unique lookup). The UUID
@@ -308,6 +336,10 @@ export const registerDeferTaskTool = (server: McpServer) => {
             taskType: "deferred",
             tags: ["deferred"],
             priority: task.priority,
+            // Provenance: `nextRunAt` is cleared once this one_time schedule
+            // fires, so the requested delay is only recoverable from here.
+            requestedDelayMs: delayMs,
+            requestedRunAt: runAt,
             // No `model`: a concrete provider model pinned now can be
             // incompatible with the assignee/provider at wake-up, especially
             // after a delay. Only the portable modelTier travels — mirrors
@@ -344,9 +376,15 @@ export const registerDeferTaskTool = (server: McpServer) => {
 
           const terminalOutput = task.outputSchema
             ? output!
-            : renderHumanFacingDeferral(note, nextRunAt, schedule.id, requesterTz, isFallbackTz);
+            : renderHumanFacingDeferral(
+                nextRunAt,
+                requesterTz,
+                isFallbackTz,
+                wakeOn ? renderWaitingOn(watchedAgentNames, watchedTaskIds.length) : undefined,
+              );
           const completed = await completeTask(taskId, terminalOutput, {
             addTags: ["deferred"],
+            deferredAt: new Date().toISOString(),
           });
           if (!completed) {
             // Another writer terminally completed/failed/cancelled this task

package/src/tools/extension-common.ts

@@ -10,6 +10,7 @@ const extensionListItemSchema = z.looseObject({
   name: z.string().optional(),
   version: z.number().optional(),
   activeVersion: z.number().optional(),
+  createdByAgentId: z.string().nullable().optional(),
   enabled: z.boolean().optional(),
   status: z.string().optional(),
   priority: z.number().optional(),
@@ -21,6 +22,7 @@ export const extensionToolOutputSchema = swarmToolOutputSchema({
   name: z.string().optional(),
   version: z.number().optional(),
   activeVersion: z.number().optional(),
+  createdByAgentId: z.string().nullable().optional(),
   enabled: z.boolean().optional(),
   status: z.string().optional(),
   priority: z.number().optional(),
@@ -38,6 +40,8 @@ export function coerceExtensionSummary(entry: unknown) {
   const extension = isRecord(entry) ? entry : {};
   return {
     id: typeof extension.id === "string" ? extension.id : undefined,
+    createdByAgentId:
+      typeof extension.createdByAgentId === "string" ? extension.createdByAgentId : null,
     name: typeof extension.name === "string" ? extension.name : undefined,
     version: typeof extension.version === "number" ? extension.version : undefined,
     activeVersion:

package/src/tools/extension-install.ts

@@ -9,7 +9,7 @@ import {
 } from "./extension-common";
 
 export const EXTENSION_INSTALL_DESCRIPTION =
-  "Validate and store a TypeScript extension bundle (manifest plus a files map with one hooks.ts). Fetch the hook contract first: GET /api/extensions/type-defs returns swarm-extension.d.ts with every event and modify shape. The extension remains disabled until a lead, operator, or dashboard user enables it with extension-enable.";
+  "Any authenticated agent may create and install its own TypeScript extension bundle (manifest plus a files map with one hooks.ts). Fetch the hook contract first: GET /api/extensions/type-defs returns swarm-extension.d.ts with every event and modify shape. The installing agent is recorded as createdByAgentId. Workers may install subsequent versions only for their own extensions; those versions remain inactive. A new extension remains disabled until a lead, operator, or dashboard user enables it with extension-enable.";
 
 function extensionInstallResult(data: unknown, fallbackName: string) {
   const body = data as {

package/src/tools/extension-list.ts

@@ -24,11 +24,12 @@ function extensionListItems(data: unknown): ExtensionListItem[] {
 }
 
 function renderExtensionsTable(extensions: ExtensionListItem[]): string {
-  const header = "| Name | Version | Active | Enabled | Status | Priority | Failures |";
-  const divider = "| --- | ---: | ---: | --- | --- | ---: | ---: |";
+  const header =
+    "| Name | Owner agent | Version | Active | Enabled | Status | Priority | Failures |";
+  const divider = "| --- | --- | ---: | ---: | --- | --- | ---: | ---: |";
   const rows = extensions.map(
     (extension) =>
-      `| ${extension.name ?? "?"} | ${extension.version ?? "?"} | ${extension.activeVersion ?? "?"} | ${extension.enabled ?? false} | ${extension.status ?? "unknown"} | ${extension.priority ?? "?"} | ${extension.consecutiveFailures ?? 0} |`,
+      `| ${extension.name ?? "?"} | ${extension.createdByAgentId ?? "operator/user"} | ${extension.version ?? "?"} | ${extension.activeVersion ?? "?"} | ${extension.enabled ?? false} | ${extension.status ?? "unknown"} | ${extension.priority ?? "?"} | ${extension.consecutiveFailures ?? 0} |`,
   );
   return [header, divider, ...rows].join("\n");
 }

package/src/tools/join-swarm.ts

@@ -84,7 +84,7 @@ export const registerJoinSwarmTool = (server: McpServer) => {
 
       try {
         const agent = await getDbClient().transaction(async () => {
-          const agents = await getAllAgents();
+          const agents = await getAllAgents({ includeExtensions: true });
 
           const existingIdAgent = agents.find((agent) => agent.id === agentId);
 

package/src/tools/schedules/create-schedule.ts

@@ -3,7 +3,14 @@ import { CronExpressionParser } from "cron-parser";
 import * as z from "zod";
 import { authorizeAssetKeyWrite } from "@/be/asset-key-auth";
 import { resolveTaskAuditUserId } from "@/be/audit-user";
-import { createScheduledTask, getAgentById, getScheduledTaskByName, getWorkflow } from "@/be/db";
+import {
+  createScheduledTask,
+  extensionAgentAssignmentError,
+  getAgentById,
+  getScheduledTaskByName,
+  getWorkflow,
+  isExtensionAgent,
+} from "@/be/db";
 import { getScript } from "@/be/scripts/db";
 import { calculateNextRun } from "@/scheduler";
 import { createToolRegistrar, swarmToolOutputSchema, toolErr, toolOk } from "@/tools/utils";
@@ -229,6 +236,9 @@ export const registerCreateScheduleTool = (server: McpServer) => {
         if (!agent) {
           return toolErr(`Target agent not found: ${targetAgentId}`);
         }
+        if (isExtensionAgent(agent)) {
+          return toolErr(extensionAgentAssignmentError(agent));
+        }
       }
 
       // Cross-field targetType validation

package/src/tools/schedules/patch-schedule.ts

@@ -4,10 +4,12 @@ import * as z from "zod";
 import { authorizeAssetKeyWrite } from "@/be/asset-key-auth";
 import { resolveTaskAuditUserId } from "@/be/audit-user";
 import {
+  extensionAgentAssignmentError,
   getAgentById,
   getScheduledTaskById,
   getScheduledTaskByName,
   getWorkflow,
+  isExtensionAgent,
   updateScheduledTask,
 } from "@/be/db";
 import { mergeScheduleTiming, validateRecurringTiming } from "@/be/schedules/validate";
@@ -187,6 +189,9 @@ export const registerPatchScheduleTool = (server: McpServer) => {
         if (!agent) {
           return toolErr(`Target agent not found: ${targetAgentId}`);
         }
+        if (isExtensionAgent(agent)) {
+          return toolErr(extensionAgentAssignmentError(agent));
+        }
       }
 
       // Check if new name conflicts with existing

package/src/tools/schedules/update-schedule.ts

@@ -4,10 +4,12 @@ import * as z from "zod";
 import { authorizeAssetKeyWrite } from "@/be/asset-key-auth";
 import { resolveTaskAuditUserId } from "@/be/audit-user";
 import {
+  extensionAgentAssignmentError,
   getAgentById,
   getScheduledTaskById,
   getScheduledTaskByName,
   getWorkflow,
+  isExtensionAgent,
   updateScheduledTask,
 } from "@/be/db";
 import { mergeScheduleTiming, validateRecurringTiming } from "@/be/schedules/validate";
@@ -186,6 +188,9 @@ export const registerUpdateScheduleTool = (server: McpServer) => {
         if (!agent) {
           return toolErr(`Target agent not found: ${targetAgentId}`);
         }
+        if (isExtensionAgent(agent)) {
+          return toolErr(extensionAgentAssignmentError(agent));
+        }
       }
 
       // Check if new name conflicts with existing

package/src/tools/send-task.ts

@@ -4,6 +4,7 @@ import { AssetKeyAuthorizationError, authorizeAssetKeyWrite } from "@/be/asset-k
 import { resolveTaskAuditUserId } from "@/be/audit-user";
 import {
   createTaskExtended,
+  extensionAgentAssignmentError,
   findCompletedTaskInThread,
   findExistingLinearTrackerContextWork,
   findRecentCancelledTaskInThread,
@@ -13,6 +14,7 @@ import {
   getTaskById,
   getUserById,
   hasCapacity,
+  isExtensionAgent,
 } from "@/be/db";
 import { repointTrackerSyncBySwarmId } from "@/be/db-queries/tracker";
 import { applyPreTaskCreate } from "@/extensions/apply-task-create";
@@ -562,6 +564,10 @@ export async function sendTaskHandler(
       };
     }
 
+    if (isExtensionAgent(agent)) {
+      return { success: false, message: extensionAgentAssignmentError(agent) };
+    }
+
     if (taskOptions.routingAffinity?.leadOnly && !agent.isLead) {
       return {
         success: false,

package/src/tools/utils.ts

@@ -275,7 +275,7 @@ const storeProgressBlockedWaitingNudge = (r: SwarmToolResult): string | undefine
   if (!r.ok) return undefined;
   const ms = (r.data as { blockedWaitingElapsedMs?: unknown } | undefined)?.blockedWaitingElapsedMs;
   if (typeof ms !== "number") return undefined;
-  return `That reads as blocked-waiting, ${formatIdleDuration(ms)} since your last update — call defer-task so a wake-up task resumes you instead of polling manually.`;
+  return `That reads as blocked-waiting, ${formatIdleDuration(ms)} since your last update — keep working if you can, and if the wait is genuinely long, defer-task is one way to resume later instead of polling.`;
 };
 
 const workflowLongScriptTimeoutNudge = (r: SwarmToolResult): string | undefined => {

package/src/types.ts

@@ -136,16 +136,22 @@ export const DEFAULT_MODEL_TIER_MAP: Record<ProviderName, Record<ModelTier, stri
     ultra: "gpt-5.6-sol",
   },
   pi: {
-    smol: "openrouter/deepseek/deepseek-v4-flash",
-    regular: "openrouter/deepseek/deepseek-v4-flash",
-    smart: "openrouter/deepseek/deepseek-v4-pro",
-    ultra: "openrouter/anthropic/claude-opus-4.8",
+    smol: "openrouter/deepseek/deepseek-v4.1-flash",
+    regular: "openrouter/deepseek/deepseek-v4.1-flash",
+    smart: "openrouter/deepseek/deepseek-v4-pro-0813",
+    ultra: "openrouter/anthropic/claude-opus-5.5",
   },
   opencode: {
-    smol: "openrouter/deepseek/deepseek-v4-flash",
-    regular: "openrouter/deepseek/deepseek-v4-flash",
-    smart: "openrouter/deepseek/deepseek-v4-pro",
-    ultra: "openrouter/anthropic/claude-opus-4.8",
+    smol: "openrouter/deepseek/deepseek-v4.1-flash",
+    regular: "openrouter/deepseek/deepseek-v4.1-flash",
+    smart: "openrouter/deepseek/deepseek-v4-pro-0813",
+    ultra: "openrouter/anthropic/claude-opus-5.5",
+  },
+  dsh: {
+    smol: "openrouter/deepseek/deepseek-v4.1-flash",
+    regular: "openrouter/deepseek/deepseek-v4.1-flash",
+    smart: "openrouter/deepseek/deepseek-v4-pro-0813",
+    ultra: "openrouter/anthropic/claude-opus-5.5",
   },
   devin: {
     smol: "devin",
@@ -367,6 +373,7 @@ export const ProviderNameSchema = z.enum([
   "claude-managed",
   "opencode",
   "acp",
+  "dsh",
 ]);
 export type ProviderName = z.infer<typeof ProviderNameSchema>;
 
@@ -401,6 +408,8 @@ export const SteeringMessageSchema = z
     status: SteeringStatusSchema,
     deliveredMode: SteerModeSchema.optional(),
     source: SteeringSourceSchema,
+    /** Display label resolved by the API from the sender identity. */
+    senderLabel: z.string().optional(),
     createdByKind: z.enum(["user", "agent", "system"]),
     createdByUserId: z.string().optional(),
     createdByAgentId: z.string().optional(),
@@ -455,6 +464,7 @@ export const PROVIDER_STEER_CAPABILITIES: Record<ProviderName, SteerMode[]> = {
   // single in-flight turn and the only interrupt is `session/cancel` (abort).
   // Advertise nothing rather than promise semantics we can't honor.
   acp: [],
+  dsh: [],
 };
 
 export type DevinProviderMeta = {
@@ -474,6 +484,7 @@ export type ProviderMetaMap = {
   "claude-managed": NoProviderMeta;
   opencode: NoProviderMeta;
   acp: NoProviderMeta;
+  dsh: NoProviderMeta;
 };
 
 export const FollowUpConfigSchema = z
@@ -624,6 +635,12 @@ export const AgentTaskSchema = z
     // Pause tracking
     wasPaused: z.boolean().default(false),
 
+    // Set by `defer-task` when this task ends in a deferral. The task's status
+    // is `completed` either way, so this is what tells "parked, resuming in a
+    // wake-up task" apart from "done" — see `isDeferredTask` in
+    // src/slack/task-output.ts.
+    deferredAt: z.iso.datetime().optional(),
+
     // Context usage aggregates
     compactionCount: z.number().int().min(0).optional(),
     peakContextPercent: z.number().min(0).max(100).optional(),
@@ -1644,6 +1661,11 @@ export const ScheduledTaskSchema = z
     // Set only by `defer-task`: the task this schedule wakes up to continue.
     // Passed through as the created task's `parentTaskId`.
     parentTaskId: z.string().optional(),
+    // Set only by `defer-task`: what the caller asked for, kept because the
+    // scheduler clears `nextRunAt` once a one_time schedule fires. Exactly one
+    // of the two is present. Provenance only — never read to schedule a run.
+    requestedDelayMs: z.number().int().positive().optional(),
+    requestedRunAt: z.iso.datetime().optional(),
     timezone: z.string().default("UTC"),
     consecutiveErrors: z.number().int().min(0).default(0),
     lastErrorAt: z.iso.datetime().optional(),

package/src/utils/context-window.ts

@@ -29,6 +29,7 @@ const CONTEXT_WINDOW_DEFAULTS: Record<string, number> = {
   // Anthropic Fable / Mythos tier
   "claude-fable-5-1": 1_000_000,
   "claude-mythos-5-1": 1_000_000,
+  "claude-opus-5-5": 1_000_000,
   "claude-opus-5": 1_000_000,
   "claude-fable-5": 1_000_000,
   "claude-mythos-5": 1_000_000,

package/src/utils/credentials.ts

@@ -8,6 +8,7 @@ export const CREDENTIAL_POOL_VARS = [
   "OPENAI_API_KEY",
   "CODEX_OAUTH",
   "DEVIN_API_KEY",
+  "DEEPSEEK_API_KEY",
 ] as const;
 
 /**
@@ -26,6 +27,7 @@ export const PROVIDER_CREDENTIAL_VARS: Record<string, readonly string[]> = {
   pi: ["OPENROUTER_API_KEY", "ANTHROPIC_API_KEY", "OPENAI_API_KEY"],
   codex: ["OPENAI_API_KEY", "CODEX_OAUTH"],
   devin: ["DEVIN_API_KEY"],
+  dsh: ["OPENROUTER_API_KEY", "DEEPSEEK_API_KEY"],
   opencode: ["OPENROUTER_API_KEY", "ANTHROPIC_API_KEY", "OPENAI_API_KEY"],
 };
 
@@ -57,6 +59,10 @@ const SLASH_MODEL_PROVIDERS = new Set(["opencode", "pi"]);
 export function getModelAwareCredentialVars(provider: string, model?: string): readonly string[] {
   const base = PROVIDER_CREDENTIAL_VARS[provider];
   if (!base) return CREDENTIAL_POOL_VARS;
+  // dsh has exact prefix routing; the generic slash rule only filters OpenAI keys.
+  if (provider === "dsh" && model) {
+    return model.startsWith("openrouter/") ? ["OPENROUTER_API_KEY"] : ["DEEPSEEK_API_KEY"];
+  }
   if (!SLASH_MODEL_PROVIDERS.has(provider) || !model) return base;
   if (model.includes("/")) {
     return base.filter((v) => v !== "OPENAI_API_KEY");
@@ -82,6 +88,8 @@ export function deriveProviderFromKeyType(keyType: string): string {
     case "OPENAI_API_KEY":
     case "CODEX_OAUTH":
       return "codex";
+    case "DEEPSEEK_API_KEY":
+      return "dsh";
     case "DEVIN_API_KEY":
       return "devin";
     default:

package/src/utils/internal-ai/complete-structured.ts

@@ -284,6 +284,14 @@ export async function completeStructured<TZod extends z.ZodTypeAny>(
     return null;
   }
 
+  // Dynamic IDs can be absent even though the typed catalog overload is non-nullable.
+  if (!model) {
+    console.error(
+      scrubSecrets(`internal-ai: unknown model ${provider}/${modelId} (callerTag=${callerTag})`),
+    );
+    return null;
+  }
+
   // The builtin catalog hardcodes openrouter.ai; OPENROUTER_BASE_URL reroutes
   // through a gateway (pi-ai's stream path uses `model.baseUrl` verbatim).
   // Resolved from the caller's session env when provided — swarm_config

package/src/utils/internal-ai/models.ts

@@ -17,10 +17,10 @@ export type CredentialKind = "openrouter" | "anthropic" | "openai" | "openai-cod
  * shellout, not pi-ai's `getModel`.
  */
 export const DEFAULT_MODEL: Record<CredentialKind, string> = {
-  openrouter: "openrouter/google/gemini-3-flash-preview",
+  openrouter: "openrouter/deepseek/deepseek-v4.1-flash",
   anthropic: "anthropic/claude-haiku-4-5",
-  openai: "openai/gpt-5.4-mini",
-  "openai-codex": "openai-codex/gpt-5.4-mini",
+  openai: "openai/gpt-6-luna",
+  "openai-codex": "openai-codex/gpt-6-luna",
   "claude-cli": "haiku",
 };
 
@@ -35,8 +35,8 @@ export function resolveModelString(kind: CredentialKind): string {
 
 /**
  * Split a `provider/model-id` string on the FIRST `/` so that OpenRouter
- * compound IDs like `openrouter/google/gemini-3-flash-preview` parse as
- * `("openrouter", "google/gemini-3-flash-preview")`. Mirrors the existing
+ * compound IDs like `openrouter/deepseek/deepseek-v4.1-flash` parse as
+ * `("openrouter", "deepseek/deepseek-v4.1-flash")`. Mirrors the existing
  * convention in `src/providers/pi-mono-adapter.ts:161-170`.
  */
 export function parseModelStr(modelStr: string): [provider: string, modelId: string] {

package/src/utils/memory-raters.ts

@@ -0,0 +1,3 @@
+// Keep the dependency-free resolver in the plugin bundle so opencode's isolated
+// runtime and the API/other workers execute the same defaults.
+export { getMemoryRaterNames } from "../../plugin/opencode-plugins/lib/memory-raters";

package/src/workflows/engine.ts

@@ -198,6 +198,14 @@ interface StepResult {
   successors: WorkflowNode[];
 }
 
+// A run may have overlapping resume walks. Keep ownership until the last walk
+// settles, including checkpointing and routing between executor calls.
+const activeWalks = new Map<string, number>();
+
+export function isWorkflowRunActive(runId: string): boolean {
+  return activeWalks.has(runId);
+}
+
 /**
  * Event-loop style graph walker.
  *
@@ -214,6 +222,26 @@ export async function walkGraph(
   workflowId?: string,
   secretKeys: Set<string> = new Set(),
   options: WorkflowExecutionOptions = {},
+): Promise<void> {
+  activeWalks.set(runId, (activeWalks.get(runId) ?? 0) + 1);
+  try {
+    await walkGraphOwned(def, runId, ctx, startNodes, registry, workflowId, secretKeys, options);
+  } finally {
+    const remaining = activeWalks.get(runId)! - 1;
+    if (remaining === 0) activeWalks.delete(runId);
+    else activeWalks.set(runId, remaining);
+  }
+}
+
+async function walkGraphOwned(
+  def: WorkflowDefinition,
+  runId: string,
+  ctx: Record<string, unknown>,
+  startNodes: WorkflowNode[],
+  registry: ExecutorRegistry,
+  workflowId?: string,
+  secretKeys: Set<string> = new Set(),
+  options: WorkflowExecutionOptions = {},
 ): Promise<void> {
   // Initial triggers carry the requester in options. Resumes, retries, and
   // recovery start from persisted state, so rehydrate it from the run.

package/src/workflows/recovery.ts

@@ -11,7 +11,7 @@ import {
   updateWorkflowRun,
 } from "../be/db";
 import { FAILED_TASK_OUTPUT_PREFIX } from "./constants";
-import { findReadyNodes, walkGraph } from "./engine";
+import { findReadyNodes, isWorkflowRunActive, walkGraph } from "./engine";
 import type { ExecutorRegistry } from "./executors/registry";
 import { getSecretInputKeys } from "./input";
 import { finalizeOrWait, resumeWaitState } from "./resume";
@@ -22,10 +22,10 @@ import {
 } from "./task-step-routing";
 
 /**
- * Recover incomplete workflow runs on server startup.
+ * Recover incomplete workflow runs on startup and during heartbeat sweeps.
  *
  * Two cases:
- * 1. `running` runs — were mid-execution when server died.
+ * 1. `running` runs without a live graph walk — interrupted execution.
  *    Find completed steps, compute ready nodes, continue walking.
  * 2. `waiting` runs — were waiting for a task that may have finished while we were down.
  *    Check if the linked task is done and resume/fail accordingly.
@@ -46,7 +46,7 @@ export async function recoverIncompleteRuns(registry: ExecutorRegistry): Promise
   recovered += await recoverWaitStates(registry);
 
   if (recovered > 0) {
-    console.log(`[workflows] Recovered ${recovered} incomplete run(s) on startup`);
+    console.log(`[workflows] Recovered ${recovered} incomplete run(s)`);
   }
 
   return recovered;
@@ -64,6 +64,7 @@ async function recoverRunningRuns(registry: ExecutorRegistry): Promise<number> {
 
   for (const runId of runningRunIds) {
     try {
+      if (isWorkflowRunActive(runId)) continue;
       const run = await getWorkflowRun(runId);
       if (!run || run.status !== "running") continue;
 
@@ -75,6 +76,8 @@ async function recoverRunningRuns(registry: ExecutorRegistry): Promise<number> {
 
       // Find the next nodes that are ready to execute
       const readyNodes = findReadyNodes(workflow.definition, completedNodeIds);
+      // DB reads above yield; a trigger/resume may have acquired the run meanwhile.
+      if (isWorkflowRunActive(runId)) continue;
       if (readyNodes.length === 0) {
         // All nodes completed or nothing is ready — mark as completed
         await updateWorkflowRun(runId, {