@desplega.ai/agent-swarm 1.92.0 → 1.92.2

package/src/providers/claude-adapter.ts

@@ -72,9 +72,8 @@ async function cleanupTaskFile(pid: number): Promise<void> {
 /**
  * Parse `CLAUDE_BINARY` into argv prefix tokens.
  *
- * Accepts a single binary name (`"claude"`, `"shannon"`), an absolute path,
- * or a whitespace-separated command string (`"bunx @dexh/shannon"`,
- * `"npx -y @dexh/shannon"`). Trim + split on `/\s+/`. No shell parsing, no
+ * Accepts a single binary name (`"claude"`), an absolute path, or a
+ * whitespace-separated command string. Trim + split on `/\s+/`. No shell parsing, no
  * quote handling — keep it tiny and predictable. Empty / missing → `["claude"]`.
  *
  * Exported for unit testing.
@@ -109,6 +108,15 @@ export function resolveClaudeBinary(
 }
 
 const CLAUDE_BRIDGE_BINARY = "claude-bridge";
+const CLAUDE_BRIDGE_LOCAL_AUTH_ARG = "--desplega-local-auth";
+const LEGACY_CLAUDE_BRIDGE_COMPAT_BINARY = "shan" + "non";
+const CLAUDE_BRIDGE_LOCAL_AUTH_ENV_VARS = [
+  "ANTHROPIC_API_KEY",
+  "ANTHROPIC_AUTH_TOKEN",
+  "ANTHROPIC_BASE_URL",
+  "ANTHROPIC_CUSTOM_HEADERS",
+  "ANTHROPIC_MODEL",
+] as const;
 
 /**
  * Parse a boolean env toggle. Only true/1 enable and false/0 disable; unset
@@ -147,14 +155,33 @@ function resolveClaudeBinaryArgv(
   return { raw, argv: parseClaudeBinary(raw), useClaudeBridge };
 }
 
+function isLegacyClaudeBridgeCompatBinary(raw: string): boolean {
+  return raw.toLowerCase().includes(LEGACY_CLAUDE_BRIDGE_COMPAT_BINARY);
+}
+
+function withClaudeBridgeAuthArgs(
+  argv: readonly string[],
+  sourceEnv: Record<string, string | undefined>,
+): string[] {
+  if (sourceEnv.CLAUDE_CODE_OAUTH_TOKEN) {
+    return [...argv];
+  }
+
+  if (CLAUDE_BRIDGE_LOCAL_AUTH_ENV_VARS.some((name) => sourceEnv[name])) {
+    return [...argv, CLAUDE_BRIDGE_LOCAL_AUTH_ARG];
+  }
+
+  return [...argv];
+}
+
 /**
  * Pre-seed `~/.claude.json` so the per-project trust-dialog ("Quick safety
  * check: Is this a project you trust?") doesn't block on first run.
  *
  * Mirrors the onboarding-skip hack in `Dockerfile.worker` (which writes
  * `hasCompletedOnboarding` and `bypassPermissionsModeAccepted`). When the
- * resolved binary contains "shannon", claude runs inside tmux and shannon
- * does NOT auto-accept the dialog, so the pane hangs forever. Writing
+ * resolved binary runs interactive claude inside tmux, claude does NOT
+ * reliably auto-accept the dialog, so the pane can hang forever. Writing
  * `projects[cwd].hasTrustDialogAccepted = true` (and `hasCompletedProjectOnboarding`)
  * tells claude-code the cwd is pre-trusted.
  *
@@ -832,54 +859,59 @@ export class ClaudeAdapter implements ProviderAdapter {
 
     const model = config.model || "opus";
 
-    const credType = validateClaudeCredentials(config.env || process.env);
+    const sourceEnv = config.env || process.env;
+    const credType = validateClaudeCredentials(sourceEnv);
     console.log(`\x1b[2m[claude]\x1b[0m Using credential: ${credType}`);
 
     // Resolve the argv prefix. Same flags (`-p`, `--model`, ...) work across
     // alternates; only argv[0..n] changes. Prefer SWARM_USE_CLAUDE_BRIDGE=true
     // for the Desplega-owned bridge. CLAUDE_BINARY remains as the low-level
-    // override for custom binaries and the deprecated shannon path.
+    // override for custom binaries and the legacy third-party bridge path.
     //
     // `config.env` carries the swarm_config overlay (resolved repo > agent > global
     // by `fetchResolvedEnv` in src/commands/runner.ts), so operators can flip
     // a worker's binary via `set-config CLAUDE_BINARY=...` without a restart.
     // Falls back to process.env, then "claude". See `resolveClaudeBinary` above.
     //
-    // See `docs-site/.../shannon-experimental.mdx` for the user-facing guide
+    // See `docs-site/.../claude-bridge-experimental.mdx` for the user-facing guide
     // and `runbooks/harness-providers.md` for engineering notes.
     const {
       raw: claudeBinaryRaw,
       argv: claudeBinaryArgv,
       useClaudeBridge,
-    } = resolveClaudeBinaryArgv(config.env || process.env);
-    const isShannon = claudeBinaryRaw.toLowerCase().includes("shannon");
-    const configuredClaudeBinaryRaw = resolveClaudeBinary(config.env || process.env);
-    if (configuredClaudeBinaryRaw.toLowerCase().includes("shannon")) {
+    } = resolveClaudeBinaryArgv(sourceEnv);
+    const isLegacyBridgeCompat = isLegacyClaudeBridgeCompatBinary(claudeBinaryRaw);
+    const effectiveClaudeBinaryArgv = useClaudeBridge
+      ? withClaudeBridgeAuthArgs(claudeBinaryArgv, sourceEnv)
+      : claudeBinaryArgv;
+    const isInteractiveTmuxClaude = isLegacyBridgeCompat || useClaudeBridge;
+    const configuredClaudeBinaryRaw = resolveClaudeBinary(sourceEnv);
+    if (isLegacyClaudeBridgeCompatBinary(configuredClaudeBinaryRaw)) {
       console.warn(
-        "\x1b[33m[claude]\x1b[0m CLAUDE_BINARY=shannon is deprecated; set SWARM_USE_CLAUDE_BRIDGE=true to use @desplega.ai/claude-bridge.",
+        `\x1b[33m[claude]\x1b[0m CLAUDE_BINARY=${LEGACY_CLAUDE_BRIDGE_COMPAT_BINARY} is deprecated; set SWARM_USE_CLAUDE_BRIDGE=true to use @desplega.ai/claude-bridge.`,
       );
     }
 
     console.log(
-      `\x1b[2m[${config.role}]\x1b[0m Resolved claude binary: ${claudeBinaryArgv.join(" ")} (useClaudeBridge: ${useClaudeBridge}, isShannon: ${isShannon})`,
+      `\x1b[2m[${config.role}]\x1b[0m Resolved claude binary: ${effectiveClaudeBinaryArgv.join(" ")} (useClaudeBridge: ${useClaudeBridge}, legacyBridgeCompat: ${isLegacyBridgeCompat})`,
     );
 
-    // Fail fast: shannon and claude-bridge both shell out to tmux. If it's
+    // Fail fast: claude-bridge and its legacy compatibility path both shell
+    // out to tmux. If it's
     // missing, surface a clear error here rather than letting startup fail
     // opaquely.
-    if ((isShannon || useClaudeBridge) && !Bun.which("tmux")) {
-      const label = useClaudeBridge ? "SWARM_USE_CLAUDE_BRIDGE=true" : "CLAUDE_BINARY=shannon";
+    if (isInteractiveTmuxClaude && !Bun.which("tmux")) {
+      const label = useClaudeBridge
+        ? "SWARM_USE_CLAUDE_BRIDGE=true"
+        : `CLAUDE_BINARY=${LEGACY_CLAUDE_BRIDGE_COMPAT_BINARY}`;
       throw new Error(
         `${label} requires 'tmux' on PATH (install via apt/brew). See runbooks/harness-providers.md.`,
       );
     }
 
-    // Shannon drives `claude` in tmux — claude's per-project trust dialog
-    // (first-run "Is this a project you trust?") hangs the pane because shannon
-    // doesn't auto-accept it. Pre-seed `~/.claude.json` so the dialog never
-    // prompts. Idempotent; no-op when already trusted. Engineering rationale:
-    // `runbooks/harness-providers.md` § "Trust-dialog pre-seed".
-    if (isShannon) {
+    // Claude Bridge and its legacy compatibility path drive interactive
+    // `claude` in tmux, where the first-run trust dialog can block startup.
+    if (isInteractiveTmuxClaude) {
       try {
         await preseedClaudeTrustDialog(config.cwd);
       } catch (err) {
@@ -944,7 +976,7 @@ export class ClaudeAdapter implements ProviderAdapter {
       taskFilePath,
       taskFilePid,
       sessionMcpConfig,
-      claudeBinaryArgv,
+      effectiveClaudeBinaryArgv,
       systemPromptFile,
     );
   }

package/src/script-workflows/workflow-ctx.ts

@@ -124,10 +124,11 @@ export function buildWorkflowCtx(input: {
     status: "completed" | "failed",
     result?: unknown,
     error?: string,
+    durationMs?: number,
   ): Promise<void> {
     const body = (await fetchJson(`/api/internal/script-runs/${input.runId}/steps`, {
       method: "POST",
-      body: JSON.stringify({ stepKey: label, stepType, config, status, result, error }),
+      body: JSON.stringify({ stepKey: label, stepType, config, status, result, error, durationMs }),
     })) as StepWriteResponse;
     if (!("ok" in body)) throw new Error(`Failed to write journal step ${label}`);
   }
@@ -140,13 +141,16 @@ export function buildWorkflowCtx(input: {
   ): Promise<unknown> {
     const replayed = await completedStep(label);
     if (replayed.found) return replayed.result;
+    const startedAt = Date.now();
     try {
       const result = await execute();
-      await writeStep(label, stepType, config, "completed", result);
+      const durationMs = Date.now() - startedAt;
+      await writeStep(label, stepType, config, "completed", result, undefined, durationMs);
       return result;
     } catch (err) {
+      const durationMs = Date.now() - startedAt;
       const error = err instanceof Error ? err.message : String(err);
-      await writeStep(label, stepType, config, "failed", undefined, error);
+      await writeStep(label, stepType, config, "failed", undefined, error, durationMs);
       throw err;
     }
   }

package/src/scripts-runtime/sdk-allowlist.ts

@@ -115,6 +115,7 @@ export const SDK_TOOL_NAME_MAP = {
   // ── skills ──
   skill_list: "skill-list",
   skill_get: "skill-get",
+  skill_getFile: "skill-get-file",
   skill_search: "skill-search",
   skill_create: "skill-create",
   skill_update: "skill-update",

package/src/scripts-runtime/swarm-sdk.ts

@@ -290,6 +290,19 @@ function bridgeRequestFor(name: string, args: unknown): BridgeRequest | null {
       if (!id) throw new Error("skill_get requires string `id`");
       return { method: "GET", path: `/api/skills/${encodeURIComponent(id)}` };
     }
+    case "skill_getFile": {
+      const skillId = typeof body.skillId === "string" ? body.skillId : undefined;
+      const path = typeof body.path === "string" ? body.path : undefined;
+      if (!skillId) throw new Error("skill_getFile requires string `skillId`");
+      if (!path) throw new Error("skill_getFile requires string `path`");
+      return {
+        method: "GET",
+        path: `/api/skills/${encodeURIComponent(skillId)}/files/${path
+          .split("/")
+          .map(encodeURIComponent)
+          .join("/")}`,
+      };
+    }
     case "skill_search":
       return { method: "POST", path: "/api/skills/search", body };
     case "skill_delete": {

package/src/scripts-runtime/types/stdlib.d.ts

@@ -298,6 +298,7 @@ declare module "swarm-sdk" {
       includeBuiltin?: boolean;
     }): Promise<unknown>;
     skill_get(args: { id: string }): Promise<unknown>;
+    skill_getFile(args: { skillId: string; path: string }): Promise<unknown>;
     skill_search(args: { query: string; limit?: number }): Promise<unknown>;
     skill_create(args: Record<string, unknown>): Promise<unknown>;
     skill_update(args: Record<string, unknown>): Promise<unknown>;

package/src/scripts-runtime/types/swarm-sdk.d.ts

@@ -280,6 +280,7 @@ declare module "swarm-sdk" {
       includeBuiltin?: boolean;
     }): Promise<unknown>;
     skill_get(args: { id: string }): Promise<unknown>;
+    skill_getFile(args: { skillId: string; path: string }): Promise<unknown>;
     skill_search(args: { query: string; limit?: number }): Promise<unknown>;
     skill_create(args: Record<string, unknown>): Promise<unknown>;
     skill_update(args: Record<string, unknown>): Promise<unknown>;

package/src/server.ts

@@ -86,6 +86,7 @@ import { registerSendTaskTool } from "./tools/send-task";
 import {
   registerSkillCreateTool,
   registerSkillDeleteTool,
+  registerSkillGetFileTool,
   registerSkillGetTool,
   registerSkillInstallRemoteTool,
   registerSkillInstallTool,
@@ -329,6 +330,7 @@ export function createServer() {
   registerSkillUpdateTool(server);
   registerSkillDeleteTool(server);
   registerSkillGetTool(server);
+  registerSkillGetFileTool(server);
   registerSkillListTool(server);
   registerSkillSearchTool(server);
   registerSkillInstallTool(server);

package/src/tasks/worker-follow-up.ts

@@ -2,6 +2,7 @@ import {
   createTaskExtended,
   getActiveTaskCount,
   getAgentById,
+  getDependentTasks,
   getLeadAgent,
   getTaskAttachments,
   getTaskById,
@@ -115,6 +116,17 @@ export function createWorkerTaskFollowUp(args: {
       task_id: task.id,
     });
     followUpDescription = failedResult.text;
+
+    // Enrich with cascade info: list dependents that were cascade-failed.
+    const cascadedDeps = getDependentTasks(task.id, { includeTerminal: true }).filter(
+      (t) => t.status === "failed" && t.failureReason?.includes("Blocked dependency"),
+    );
+    if (cascadedDeps.length > 0) {
+      const depLines = cascadedDeps.map(
+        (d) => `- ${d.id.slice(0, 8)} — "${d.task.slice(0, 100)}" (${d.failureReason})`,
+      );
+      followUpDescription += `\n\n⚠️ Cascade impact: ${cascadedDeps.length} dependent task(s) were also failed because they depend on this task:\n${depLines.join("\n")}`;
+    }
   }
 
   return createTaskExtended(followUpDescription, {