@desplega.ai/agent-swarm 1.93.0 → 1.95.0

package/src/providers/opencode-adapter.ts

@@ -20,6 +20,7 @@ import {
 import { validateOpencodeCredentials } from "../utils/credentials";
 import { fetchInstalledMcpServers } from "../utils/mcp-server-fetcher";
 import { scrubSecrets } from "../utils/secret-scrubber";
+import { resolveSlashSkillPrompt } from "./codex-skill-resolver";
 import { CTX_MODE_NUDGE_EVERY } from "./ctx-mode-env";
 import { readPkgVersion } from "./harness-version";
 import type {
@@ -102,6 +103,13 @@ function isAssistantMessage(msg: unknown): msg is AssistantMessage {
 }
 
 const DOCKER_PLUGIN_PATH = "/home/worker/.config/opencode/plugins/agent-swarm.ts";
+
+function defaultOpencodeSkillsDir(): string {
+  if (process.env.OPENCODE_SKILLS_DIR) {
+    return process.env.OPENCODE_SKILLS_DIR;
+  }
+  return join(process.env.HOME ?? "/home/worker", ".opencode", "skills");
+}
 const MODEL_CACHE_REFRESH_TIMEOUT_MS = 15_000;
 
 function isOpenRouterModel(model: string | undefined): boolean {
@@ -286,10 +294,15 @@ export class OpencodeSession implements ProviderSession {
       type: "session_init",
       sessionId: this._sessionId,
       provider,
+      harnessVariant: "stock",
       ...(harnessVariantMeta ? { harnessVariantMeta } : {}),
     });
   }
 
+  emitProviderEvent(event: ProviderEvent): void {
+    this.emit(event);
+  }
+
   onEvent(listener: (event: ProviderEvent) => void): void {
     const wasEmpty = this.listeners.length === 0;
     this.listeners.push(listener);
@@ -737,13 +750,19 @@ export class OpencodeAdapter implements ProviderAdapter {
 
     let promptRefreshAttempted = false;
     let promptRefreshPromise: Promise<boolean> | undefined;
+    let session: OpencodeSession | undefined;
     const sendPrompt = async () => {
+      const resolvedPrompt = await resolveSlashSkillPrompt(config.prompt, {
+        providerLabel: "opencode",
+        skillsDir: defaultOpencodeSkillsDir(),
+        emit: (event) => session?.emitProviderEvent(event),
+      });
       await client.session.prompt({
         path: { id: sessionId },
         query: { directory: config.cwd },
         body: {
           agent: agentName,
-          parts: [{ type: "text", text: config.prompt }],
+          parts: [{ type: "text", text: resolvedPrompt }],
         },
       });
     };
@@ -759,7 +778,7 @@ export class OpencodeAdapter implements ProviderAdapter {
       return await promptRefreshPromise;
     };
 
-    const session = new OpencodeSession(
+    session = new OpencodeSession(
       sessionId,
       server,
       config.model,

package/src/providers/pi-mono-adapter.ts

@@ -25,6 +25,7 @@ import {
   SessionManager,
 } from "@earendil-works/pi-coding-agent";
 import { type TSchema, Type } from "typebox";
+import { classifyAwsSdkError } from "../utils/aws-error-classifier";
 import { scrubSecrets } from "../utils/secret-scrubber";
 import { readPkgVersion } from "./harness-version";
 import { createSwarmHooksExtension } from "./pi-mono-extension";
@@ -73,40 +74,85 @@ function modelToCredKeys(modelStr: string | undefined): string[] | null {
   return null;
 }
 
+/**
+ * Run a single `ListFoundationModels` call against the AWS Bedrock management
+ * API to verify that the active credential chain is valid for Bedrock in the
+ * configured region. Returns the client directly (callers discard the model
+ * list — only the throw/no-throw distinction is the signal).
+ *
+ * Dynamically imported so the API binary never loads `@aws-sdk/client-bedrock`.
+ * Tests inject a stub via `CredCheckOptions.bedrockProbe` instead.
+ */
+async function runBedrockSdkProbe(region: string): Promise<void> {
+  const { BedrockClient, ListFoundationModelsCommand } = await import("@aws-sdk/client-bedrock");
+  const client = new BedrockClient({ region });
+  await client.send(new ListFoundationModelsCommand({}));
+}
+
 /**
  * Pi-mono is satisfied by ANY of:
- *   1. `MODEL_OVERRIDE` selects the `amazon-bedrock` provider — credential
- *      resolution is delegated to the AWS SDK's default chain at first
- *      inference call. agent-swarm does no presence check; if creds are
- *      missing the SDK error surfaces in the session log.
+ *   1. `BEDROCK_AUTH_MODE=sdk` — or `MODEL_OVERRIDE` selects the
+ *      `amazon-bedrock` provider (prefix-inference fallback when
+ *      `BEDROCK_AUTH_MODE` is absent). A real `ListFoundationModels` probe
+ *      is issued via the AWS SDK default credential chain. Success →
+ *      `ready:true, satisfiedBy:"sdk-delegated"`; failure → `ready:false`
+ *      with a classified hint. The probe is worker-only (the pi dynamic-import
+ *      arm in `checkProviderCredentials`); the API binary never imports the SDK.
  *   2. `~/.pi/agent/auth.json` exists.
- *   3. `MODEL_OVERRIDE` is set to a provider-prefixed model — only the
- *      matching provider's key is required.
+ *   3. `MODEL_OVERRIDE` is set to a non-Bedrock provider-prefixed model — only
+ *      the matching provider's key is required.
  *   4. `MODEL_OVERRIDE` is empty / unprefixed — any one of the supported
  *      keys (ANTHROPIC_API_KEY / OPENROUTER_API_KEY / OPENAI_API_KEY) is
  *      enough.
  *
- * Bedrock is checked first so a stale `auth.json` (Anthropic / OpenRouter
- * creds from a previous login) doesn't get falsely reported as the
- * satisfying source when the model is actually going to AWS.
+ * The Bedrock branch is checked first so a stale `auth.json` (Anthropic /
+ * OpenRouter creds from a previous login) doesn't get falsely reported as
+ * the satisfying source when the model is actually going to AWS.
  */
-export function checkPiMonoCredentials(
+export async function checkPiMonoCredentials(
   env: Record<string, string | undefined>,
   opts: CredCheckOptions = {},
-): CredStatus {
-  if (env.MODEL_OVERRIDE?.toLowerCase().startsWith("amazon-bedrock/")) {
-    return {
-      ready: true,
-      missing: [],
-      satisfiedBy: "sdk-delegated",
-      hint: "AWS SDK will resolve credentials at first Bedrock call (env, ~/.aws/*, SSO, IMDS, etc.).",
-    };
+): Promise<CredStatus> {
+  // Determine Bedrock SDK mode:
+  //   - Explicit:  BEDROCK_AUTH_MODE=sdk
+  //   - Fallback:  BEDROCK_AUTH_MODE absent AND MODEL_OVERRIDE starts with
+  //                "amazon-bedrock/" (preserves today's prefix-inference semantics)
+  // BEDROCK_AUTH_MODE=bearer is declared/validated but the full bearer-token
+  // path is out of scope for PR1 — it falls through to the standard auth check.
+  const bedrockAuthMode = env.BEDROCK_AUTH_MODE?.toLowerCase();
+  const isBedrockSdk =
+    bedrockAuthMode === "sdk" ||
+    (bedrockAuthMode === undefined &&
+      env.MODEL_OVERRIDE?.toLowerCase().startsWith("amazon-bedrock/"));
+
+  if (isBedrockSdk) {
+    const region = env.AWS_REGION ?? "us-east-1";
+    const probe = opts.bedrockProbe ?? (() => runBedrockSdkProbe(region));
+    try {
+      await probe();
+      return {
+        ready: true,
+        missing: [],
+        satisfiedBy: "sdk-delegated",
+        hint: `AWS SDK credentials verified via ListFoundationModels (region: ${region}).`,
+      };
+    } catch (err) {
+      const errorMessage = err instanceof Error ? err.message : String(err);
+      const classification = classifyAwsSdkError(errorMessage);
+      return {
+        ready: false,
+        missing: [],
+        hint:
+          classification?.message ??
+          `AWS Bedrock credential probe failed (region: ${region}): ${errorMessage}`,
+      };
+    }
   }
 
   const homeDir = opts.homeDir ?? env.HOME ?? "/root";
-  const probe = opts.fs?.existsSync ?? existsSync;
+  const fsProbe = opts.fs?.existsSync ?? existsSync;
   const authFile = `${homeDir}/.pi/agent/auth.json`;
-  if (probe(authFile)) {
+  if (fsProbe(authFile)) {
     return { ready: true, missing: [], satisfiedBy: "file" };
   }
 
@@ -361,6 +407,18 @@ export class PiMonoSession implements ProviderSession {
    * surface it directly.
    */
   private prevOutputTokens = 0;
+  /**
+   * Terminal error message captured from structured pi-coding-agent events.
+   *
+   * Set by `message_end` (assistant turn with `stopReason==='error'` — covers
+   * NON-retryable failures, including AWS auth which never enters pi's retry
+   * loop) and by `auto_retry_end` with `success:false` (the definitive terminal
+   * failure after the retryable class — throttle / 5xx / timeout — exhausts).
+   * Cleared on recovery: a successful `message_end` or an `auto_retry_end` with
+   * `success:true` resets it to null, so a recovered error never surfaces as a
+   * false failure. Evaluated once at session end in `runSession()`.
+   */
+  private terminalError: string | null = null;
 
   constructor(agentSession: AgentSession, config: ProviderSessionConfig, createdSymlink: boolean) {
     this.agentSession = agentSession;
@@ -376,6 +434,7 @@ export class PiMonoSession implements ProviderSession {
       type: "session_init",
       sessionId: this._sessionId,
       provider: "pi",
+      harnessVariant: "stock",
       ...(piVersion ? { harnessVariantMeta: { version: piVersion } } : {}),
     });
 
@@ -424,6 +483,25 @@ export class PiMonoSession implements ProviderSession {
     switch (event.type) {
       case "message_end": {
         // Pi emits message_end for user, assistant, and tool-result messages.
+        // An assistant turn that ended in `stopReason==='error'` is a failed
+        // turn — track it as the (so far) terminal error. This is the ONLY
+        // structured signal for NON-retryable failures (AWS auth: ExpiredToken
+        // / CredentialsProviderError), which never enter pi's retry loop.
+        const endMsg = event.message as {
+          role?: string;
+          stopReason?: string;
+          errorMessage?: string;
+        };
+        if (endMsg.role === "assistant") {
+          if (endMsg.stopReason === "error") {
+            // Candidate terminal failure. May still be cleared by a successful
+            // retry (auto_retry_end success / a later good message_end).
+            this.terminalError = endMsg.errorMessage ?? this.terminalError ?? "Unknown error";
+            break;
+          }
+          // A successful assistant turn means any prior error has recovered.
+          this.terminalError = null;
+        }
         // Only assistant text should be printed or used as fallback output.
         const text = extractPiAssistantText(event.message);
         if (text) {
@@ -517,12 +595,18 @@ export class PiMonoSession implements ProviderSession {
           result: event.result,
         });
         break;
-      case "auto_retry_start":
-        this.emit({
-          type: "raw_stderr",
-          content: `[pi-mono] Auto-retry attempt ${event.attempt}/${event.maxAttempts}: ${event.errorMessage}\n`,
-        });
+      case "auto_retry_end": {
+        // Definitive terminal signal for the RETRYABLE error class
+        // (throttle / 5xx / timeout). pi-coding-agent emits success:false with
+        // `finalError` only after every retry attempt is exhausted; success:true
+        // means the turn recovered, so clear any tracked error.
+        if (event.success) {
+          this.terminalError = null;
+        } else {
+          this.terminalError = event.finalError ?? this.terminalError ?? "Unknown error";
+        }
         break;
+      }
     }
   }
 
@@ -540,6 +624,26 @@ export class PiMonoSession implements ProviderSession {
       const stats = this.agentSession.getSessionStats();
       const cost = this.buildCostData(stats);
 
+      // A structured terminal error from pi-coding-agent events is failure by
+      // definition (the agent already exhausted retries or hit a non-retryable
+      // error). Surface it so the session-chat red box fires and the task fails,
+      // exactly like sibling adapters. AWS errors get a categorized, actionable
+      // message; anything else surfaces its raw error text.
+      if (this.terminalError) {
+        const classification = classifyAwsSdkError(this.terminalError);
+        const message = classification?.message ?? this.terminalError;
+        const category = classification?.category;
+        this.emit({ type: "error", message, category });
+        return {
+          exitCode: 1,
+          sessionId: this._sessionId,
+          cost,
+          isError: true,
+          errorCategory: category,
+          failureReason: message,
+        };
+      }
+
       this.emit({
         type: "result",
         cost,
@@ -555,13 +659,26 @@ export class PiMonoSession implements ProviderSession {
       };
     } catch (err) {
       const errorMessage = err instanceof Error ? err.message : String(err);
+      // Defense-in-depth: AWS SDK failures surface as structured events (handled
+      // above in runSession), not thrown exceptions, so this catch is for genuine
+      // unexpected throws (MCP / transport / etc). Still classify in case an AWS
+      // signature ever reaches here, so the red box fires like sibling adapters.
+      const awsCatchError = classifyAwsSdkError(errorMessage);
+      if (awsCatchError) {
+        this.emit({
+          type: "error",
+          message: awsCatchError.message,
+          category: awsCatchError.category,
+        });
+      }
       this.emit({ type: "raw_stderr", content: `[pi-mono] Error: ${errorMessage}\n` });
 
       return {
         exitCode: 1,
         sessionId: this._sessionId,
         isError: true,
-        failureReason: errorMessage,
+        errorCategory: awsCatchError?.category,
+        failureReason: awsCatchError?.message ?? errorMessage,
       };
     } finally {
       await this.logFileHandle.end();

package/src/providers/types.ts

@@ -188,8 +188,20 @@ export interface CredStatus {
  * pi/opencode predicates probe the filesystem for `~/.codex/auth.json`,
  * `~/.pi/agent/auth.json`, `~/.local/share/opencode/auth.json`. Tests inject
  * a fake `fs` + `homeDir` to exercise the file-vs-env branches deterministically.
+ *
+ * `bedrockProbe` is an injectable for the Bedrock SDK probe path in
+ * `checkPiMonoCredentials`. In production it is left undefined and the
+ * function dynamically imports `@aws-sdk/client-bedrock` to run a real
+ * `ListFoundationModels` call. Tests inject a stub to avoid hitting AWS.
  */
 export interface CredCheckOptions {
   homeDir?: string;
   fs?: { existsSync(p: string): boolean };
+  /**
+   * Injectable for Bedrock SDK credential probe. When provided, called instead
+   * of the real `@aws-sdk/client-bedrock` `ListFoundationModels` call.
+   * Should throw on auth/access failure (with an AWS SDK-shaped error message)
+   * or resolve on success.
+   */
+  bedrockProbe?: () => Promise<void>;
 }

package/src/scheduler/scheduler.ts

@@ -3,7 +3,7 @@ import { CronExpressionParser } from "cron-parser";
 import { getDb, getDueScheduledTasks, getScheduledTaskById, updateScheduledTask } from "@/be/db";
 import { scheduleContextKey } from "@/tasks/context-key";
 import { createTaskWithSiblingAwareness } from "@/tasks/sibling-awareness";
-import type { ScheduledTask } from "@/types";
+import type { AgentTask, ScheduledTask } from "@/types";
 import type { ExecutorRegistry } from "@/workflows/executors/registry";
 import { handleScheduleTrigger } from "@/workflows/triggers";
 
@@ -11,6 +11,24 @@ let schedulerInterval: ReturnType<typeof setInterval> | null = null;
 let isProcessing = false;
 let executorRegistry: ExecutorRegistry | null = null;
 
+export function createStandaloneScheduleTask(
+  schedule: ScheduledTask,
+  extraTags: string[] = [],
+): AgentTask {
+  return createTaskWithSiblingAwareness(schedule.taskTemplate, {
+    creatorAgentId: schedule.createdByAgentId,
+    taskType: schedule.taskType,
+    tags: [...schedule.tags, "scheduled", `schedule:${schedule.name}`, ...extraTags],
+    priority: schedule.priority,
+    agentId: schedule.targetAgentId,
+    model: schedule.model,
+    modelTier: schedule.modelTier,
+    scheduleId: schedule.id,
+    source: "schedule",
+    contextKey: scheduleContextKey({ scheduleId: schedule.id }),
+  });
+}
+
 /**
  * Recover missed scheduled task runs from downtime.
  * Fires ONE catch-up run per schedule (not N missed runs).
@@ -45,17 +63,7 @@ async function recoverMissedSchedules(): Promise<void> {
 
       if (!triggeredWorkflows) {
         const tx = getDb().transaction(() => {
-          createTaskWithSiblingAwareness(schedule.taskTemplate, {
-            creatorAgentId: schedule.createdByAgentId,
-            taskType: schedule.taskType,
-            tags: [...schedule.tags, "scheduled", `schedule:${schedule.name}`, "recovered"],
-            priority: schedule.priority,
-            agentId: schedule.targetAgentId,
-            model: schedule.model,
-            scheduleId: schedule.id,
-            source: "schedule",
-            contextKey: scheduleContextKey({ scheduleId: schedule.id }),
-          });
+          createStandaloneScheduleTask(schedule, ["recovered"]);
         });
         tx();
       }
@@ -150,17 +158,7 @@ async function executeSchedule(schedule: ScheduledTask): Promise<void> {
     if (!triggeredWorkflows) {
       // No workflows linked — create standalone task (existing behavior)
       getDb().transaction(() => {
-        createTaskWithSiblingAwareness(schedule.taskTemplate, {
-          creatorAgentId: schedule.createdByAgentId,
-          taskType: schedule.taskType,
-          tags: [...schedule.tags, "scheduled", `schedule:${schedule.name}`],
-          priority: schedule.priority,
-          agentId: schedule.targetAgentId,
-          model: schedule.model,
-          scheduleId: schedule.id,
-          source: "schedule",
-          contextKey: scheduleContextKey({ scheduleId: schedule.id }),
-        });
+        createStandaloneScheduleTask(schedule);
       })();
     }
 
@@ -341,17 +339,7 @@ export async function runScheduleNow(scheduleId: string): Promise<void> {
   if (!triggeredWorkflows) {
     // No workflows linked — create standalone task (existing behavior)
     getDb().transaction(() => {
-      createTaskWithSiblingAwareness(schedule.taskTemplate, {
-        creatorAgentId: schedule.createdByAgentId,
-        taskType: schedule.taskType,
-        tags: [...schedule.tags, "scheduled", `schedule:${schedule.name}`, "manual-run"],
-        priority: schedule.priority,
-        agentId: schedule.targetAgentId,
-        model: schedule.model,
-        scheduleId: schedule.id,
-        source: "schedule",
-        contextKey: scheduleContextKey({ scheduleId: schedule.id }),
-      });
+      createStandaloneScheduleTask(schedule, ["manual-run"]);
     })();
   }
 

package/src/server-user.ts

@@ -1,6 +1,7 @@
 import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
 import * as z from "zod";
 import pkg from "../package.json";
+import { ModelTierSchema } from "./model-tiers";
 import {
   cancelTaskHandler,
   cancelTaskInputSchema,
@@ -28,9 +29,14 @@ const userSendTaskInputSchema = z.object({
   tags: z.array(z.string()).optional().describe("Tags for filtering (e.g., ['urgent'])."),
   priority: z.number().int().min(0).max(100).optional().describe("Priority 0-100 (default: 50)."),
   model: z
-    .enum(["haiku", "sonnet", "opus", "fable"])
+    .string()
+    .trim()
+    .min(1)
     .optional()
-    .describe("Model to use for this task ('haiku', 'sonnet', 'opus', or 'fable')."),
+    .describe("Concrete model override interpreted by the assignee's harness/provider."),
+  modelTier: ModelTierSchema.optional().describe(
+    "Portable model tier: 'smol', 'regular', 'smart', or 'ultra'. Resolved by the assignee's harness/provider.",
+  ),
 });
 
 export function createUserServer(user: User): McpServer {

package/src/slack/responses.ts

@@ -15,6 +15,20 @@ import {
 // Re-export for backward compatibility
 export { markdownToSlack } from "./blocks";
 
+export type SlackUpdateResult = "ok" | "not_found" | "failed";
+
+function classifySlackUpdateError(error: unknown): SlackUpdateResult {
+  const errorCode = (error as { data?: { error?: string } } | undefined)?.data?.error;
+  if (
+    errorCode === "message_not_found" ||
+    errorCode === "channel_not_found" ||
+    errorCode === "thread_not_found"
+  ) {
+    return "not_found";
+  }
+  return "failed";
+}
+
 const isDev = process.env.ENV === "development";
 
 /**
@@ -140,12 +154,12 @@ export async function updateProgressInPlace(
   task: AgentTask,
   progress: string,
   messageTs: string,
-): Promise<boolean> {
+): Promise<SlackUpdateResult> {
   const app = getSlackApp();
-  if (!app || !task.slackChannelId || !task.agentId) return false;
+  if (!app || !task.slackChannelId || !task.agentId) return "failed";
 
   const agent = getAgentById(task.agentId);
-  if (!agent) return false;
+  if (!agent) return "failed";
 
   const blocks = buildProgressBlocks({ agentName: agent.name, taskId: task.id, progress });
 
@@ -157,10 +171,17 @@ export async function updateProgressInPlace(
       // biome-ignore lint/suspicious/noExplicitAny: Block Kit objects
       blocks: blocks as any,
     });
-    return true;
+    return "ok";
   } catch (error) {
-    console.error(`[Slack] Failed to update progress in-place:`, error);
-    return false;
+    const result = classifySlackUpdateError(error);
+    if (result === "not_found") {
+      console.warn(
+        `[Slack] Progress message missing for task ${task.id} ts=${messageTs}; will repost`,
+      );
+    } else {
+      console.error(`[Slack] Failed to update progress in-place:`, error);
+    }
+    return result;
   }
 }
 
@@ -233,9 +254,9 @@ export async function updateTreeMessage(
   messageTs: string,
   blocks: unknown[],
   fallbackText: string,
-): Promise<boolean> {
+): Promise<SlackUpdateResult> {
   const app = getSlackApp();
-  if (!app) return false;
+  if (!app) return "failed";
 
   try {
     await app.client.chat.update({
@@ -245,10 +266,17 @@ export async function updateTreeMessage(
       // biome-ignore lint/suspicious/noExplicitAny: Block Kit objects
       blocks: blocks as any,
     });
-    return true;
+    return "ok";
   } catch (error) {
-    console.error(`[Slack] Failed to update tree message:`, error);
-    return false;
+    const result = classifySlackUpdateError(error);
+    if (result === "not_found") {
+      console.warn(
+        `[Slack] Tree message missing for channel=${channelId} ts=${messageTs}; will repost`,
+      );
+    } else {
+      console.error(`[Slack] Failed to update tree message:`, error);
+    }
+    return result;
   }
 }