@desplega.ai/agent-swarm 1.152.2 → 1.154.0

package/dist/pi-mono-adapter-c4ggemhz.js

@@ -0,0 +1,1316 @@
+import {
+  DefaultResourceLoader,
+  ModelRuntime,
+  SessionManager,
+  createAgentSession,
+  getAgentDir
+} from "./cli-rxkqvngf.js";
+import"./cli-5bfdm1ah.js";
+import {
+  readPkgVersion
+} from "./cli-2djtr51b.js";
+import {
+  summarizeSession
+} from "./cli-fdzg6jhf.js";
+import {
+  checkToolLoop,
+  clearToolHistory
+} from "./cli-hp1n6zq3.js";
+import {
+  applyReasoningEffort
+} from "./cli-avkd6mqv.js";
+import"./cli-vj6h9kc2.js";
+import"./cli-7nxes1hs.js";
+import {
+  buildRatingsFromLlm,
+  fetchRetrievalsForTask,
+  getMemoryRaterNames,
+  postRatings
+} from "./cli-3bkz2p7j.js";
+import"./cli-e7d20cty.js";
+import {
+  swarmRuntimeInstanceId
+} from "./cli-re8z5p8p.js";
+import {
+  DEFAULT_OPENROUTER_BASE_URL,
+  getOpenRouterBaseUrl
+} from "./cli-3dpj7atn.js";
+import {
+  exports_typebox,
+  getBuiltinModel,
+  getBuiltinModels
+} from "./cli-8sea27q4.js";
+import {
+  McpHttpClient
+} from "./cli-epan13p1.js";
+import"./cli-bsakbbkm.js";
+import"./cli-3er6gcsn.js";
+import"./cli-ej6gbxfb.js";
+import"./cli-sd0mxa3c.js";
+import"./cli-w5e1d1vv.js";
+import {
+  init_secret_scrubber,
+  scrubSecrets
+} from "./cli-r2ap2czm.js";
+import"./cli-pw9rj5t9.js";
+import"./cli-5b6b62tz.js";
+import"./cli-btbzvq95.js";
+import"./cli-1m2e086m.js";
+import"./cli-mcnhgnn1.js";
+import"./cli-bzr0ftht.js";
+import {
+  __require,
+  __toESM
+} from "./cli-bc05qbss.js";
+
+// src/providers/pi-mono-adapter.ts
+import { existsSync, lstatSync, symlinkSync, unlinkSync } from "node:fs";
+import { join } from "node:path";
+
+// src/utils/aws-error-classifier.ts
+var AWS_ERROR_RULES = [
+  {
+    patterns: [
+      /ExpiredToken(?:Exception)?/,
+      /CredentialsProviderError/,
+      /Unable to locate credentials/,
+      /security token.*expired/i,
+      /expired.*security token/i,
+      /InvalidSignatureException/,
+      /UnrecognizedClientException/
+    ],
+    category: "aws-auth",
+    message: "AWS credentials have expired or are missing. " + "Run `aws sso login` (or refresh your credentials via `aws configure`) and retry."
+  },
+  {
+    patterns: [
+      /ThrottlingException/,
+      /TooManyRequestsException/,
+      /ServiceQuotaExceededException/,
+      /Rate exceeded/
+    ],
+    category: "aws-throttle",
+    message: "AWS Bedrock request was throttled (rate limit or quota exceeded). " + "Wait and retry, or request a quota increase in the AWS Service Quotas console."
+  },
+  {
+    patterns: [/AccessDeniedException/, /not authorized to perform/i],
+    category: "aws-access",
+    message: "AWS authorization denied for Bedrock. " + "Verify the IAM role/user has the `bedrock:InvokeModel` permission for the target model ARN and region."
+  },
+  {
+    patterns: [
+      /ValidationException/,
+      /ResourceNotFoundException/,
+      /ModelTimeoutException/,
+      /ModelNotReadyException/
+    ],
+    category: "aws-model",
+    message: "AWS Bedrock model error: the model ID may be invalid, unavailable in this region, or not yet ready. " + "Verify MODEL_OVERRIDE and the AWS region in your environment."
+  }
+];
+function classifyAwsSdkError(text) {
+  if (!text)
+    return null;
+  for (const rule of AWS_ERROR_RULES) {
+    if (rule.patterns.some((re) => re.test(text))) {
+      return { category: rule.category, message: rule.message };
+    }
+  }
+  return null;
+}
+
+// src/providers/pi-mono-adapter.ts
+init_secret_scrubber();
+
+// src/providers/pi-mono-extension.ts
+init_secret_scrubber();
+function apiHeaders(config) {
+  return {
+    "Content-Type": "application/json",
+    ...config.apiKey ? { Authorization: `Bearer ${config.apiKey}` } : {},
+    "X-Agent-ID": config.agentId
+  };
+}
+function fireAndForget(url, init) {
+  fetch(url, init).catch(() => {});
+}
+async function isTaskCancelled(config) {
+  try {
+    const resp = await fetch(`${config.apiUrl}/cancelled-tasks?taskId=${encodeURIComponent(config.taskId)}`, { method: "GET", headers: apiHeaders(config) });
+    if (!resp.ok)
+      return { cancelled: false };
+    const data = await resp.json();
+    const match = data.cancelled?.find((t) => t.id === config.taskId);
+    return match ? { cancelled: true, reason: match.failureReason } : { cancelled: false };
+  } catch {
+    return { cancelled: false };
+  }
+}
+async function checkShouldBlockPolling(config) {
+  try {
+    const resp = await fetch(`${config.apiUrl}/me`, {
+      method: "GET",
+      headers: apiHeaders(config)
+    });
+    if (!resp.ok)
+      return false;
+    const data = await resp.json();
+    return data.shouldBlockPolling === true;
+  } catch {
+    return false;
+  }
+}
+async function fetchTaskDetails(config) {
+  try {
+    const resp = await fetch(`${config.apiUrl}/api/tasks/${config.taskId}`, {
+      method: "GET",
+      headers: apiHeaders(config)
+    });
+    if (!resp.ok)
+      return null;
+    return await resp.json();
+  } catch {
+    return null;
+  }
+}
+async function syncIdentityFilesToServer(config, changeSource = "session_sync") {
+  const updates = {};
+  const paths = {
+    soulMd: "/workspace/SOUL.md",
+    identityMd: "/workspace/IDENTITY.md",
+    toolsMd: "/workspace/TOOLS.md"
+  };
+  for (const [key, path] of Object.entries(paths)) {
+    try {
+      const file = Bun.file(path);
+      if (await file.exists()) {
+        const content = await file.text();
+        if (content.trim() && content.length <= 65536) {
+          updates[key] = content;
+        }
+      }
+    } catch {}
+  }
+  if (Object.keys(updates).length === 0)
+    return;
+  try {
+    await fetch(`${config.apiUrl}/api/agents/${config.agentId}/profile`, {
+      method: "PUT",
+      headers: apiHeaders(config),
+      body: JSON.stringify({ ...updates, changeSource })
+    });
+  } catch {}
+}
+async function syncSetupScriptToServer(config, changeSource = "session_sync") {
+  try {
+    const file = Bun.file("/workspace/start-up.sh");
+    if (!await file.exists())
+      return;
+    const raw = await file.text();
+    if (!raw.trim())
+      return;
+    const markerStart = "# === Agent-managed setup (from DB) ===";
+    const markerEnd = "# === End agent-managed setup ===";
+    const startIdx = raw.indexOf(markerStart);
+    const endIdx = raw.indexOf(markerEnd);
+    let content;
+    if (startIdx !== -1 && endIdx !== -1) {
+      content = raw.substring(startIdx + markerStart.length, endIdx).trim();
+    } else {
+      content = raw.replace(/^#!\/bin\/bash\n/, "").trim();
+    }
+    if (!content || content.length > 65536)
+      return;
+    await fetch(`${config.apiUrl}/api/agents/${config.agentId}/profile`, {
+      method: "PUT",
+      headers: apiHeaders(config),
+      body: JSON.stringify({ setupScript: content, changeSource })
+    });
+  } catch {}
+}
+async function autoIndexMemoryFile(config, editedPath) {
+  try {
+    const fileContent = await Bun.file(editedPath).text();
+    const isShared = editedPath.startsWith("/workspace/shared/");
+    const fileName = editedPath.split("/").pop() ?? "unnamed";
+    await fetch(`${config.apiUrl}/api/memory/index`, {
+      method: "POST",
+      headers: apiHeaders(config),
+      body: JSON.stringify({
+        agentId: config.agentId,
+        content: fileContent,
+        name: fileName.replace(/\.\w+$/, ""),
+        scope: isShared ? "swarm" : "agent",
+        source: "file_index",
+        sourcePath: editedPath
+      })
+    });
+  } catch {}
+}
+async function fetchConcurrentContext(config) {
+  try {
+    const resp = await fetch(`${config.apiUrl}/api/concurrent-context`, {
+      method: "GET",
+      headers: apiHeaders(config)
+    });
+    if (!resp.ok)
+      return null;
+    const data = await resp.json();
+    const lines = [];
+    if (data.processingInboxMessages.length > 0) {
+      lines.push("=== CONCURRENT SESSION AWARENESS ===");
+      lines.push("");
+      lines.push("**Other sessions are currently processing these inbox messages:**");
+      for (const msg of data.processingInboxMessages) {
+        const preview = msg.content.length > 120 ? `${msg.content.slice(0, 120)}...` : msg.content;
+        lines.push(`- [${msg.source}] "${preview}" (received ${msg.createdAt})`);
+      }
+    }
+    if (data.recentTaskDelegations.length > 0) {
+      if (lines.length === 0)
+        lines.push("=== CONCURRENT SESSION AWARENESS ===");
+      lines.push("");
+      lines.push("**Recent task delegations (last 5 min):**");
+      for (const task of data.recentTaskDelegations) {
+        const preview = task.task.length > 120 ? `${task.task.slice(0, 120)}...` : task.task;
+        lines.push(`- "${preview}" → ${task.agentName ?? "unassigned"} [${task.status}]`);
+      }
+    }
+    if (data.activeSwarmTasks.length > 0) {
+      if (lines.length === 0)
+        lines.push("=== CONCURRENT SESSION AWARENESS ===");
+      lines.push("");
+      lines.push("**Currently active tasks across the swarm:**");
+      for (const task of data.activeSwarmTasks) {
+        const preview = task.task.length > 100 ? `${task.task.slice(0, 100)}...` : task.task;
+        lines.push(`- ${task.agentName ?? "unassigned"}: "${preview}" [${task.status}]`);
+      }
+    }
+    if (lines.length > 0) {
+      lines.push("");
+      lines.push("IMPORTANT: Avoid duplicating work that is already being handled by other sessions or agents.");
+      lines.push("=== END CONCURRENT SESSION AWARENESS ===");
+      return lines.join(`
+`);
+    }
+    return null;
+  } catch {
+    return null;
+  }
+}
+async function summarizeSessionForPi(config, sessionFile, deps = {}) {
+  if (!sessionFile) {
+    console.warn("session_summary skipped (pi): session transcript file unavailable");
+    return;
+  }
+  const _runSummarize = deps.runSummarize ?? summarizeSession;
+  const _fetchRetrievals = deps.fetchRetrievalsForTask ?? fetchRetrievalsForTask;
+  const _postRatings = deps.postRatings ?? postRatings;
+  const _buildRatings = deps.buildRatingsFromLlm ?? buildRatingsFromLlm;
+  try {
+    let transcript = "";
+    try {
+      const fullTranscript = await Bun.file(sessionFile).text();
+      transcript = fullTranscript.length > 20000 ? fullTranscript.slice(-20000) : fullTranscript;
+    } catch (err) {
+      console.warn(scrubSecrets(`session_summary skipped (pi): cannot read ${sessionFile}: ${String(err)}`));
+      return;
+    }
+    if (transcript.length <= 100) {
+      console.warn(`session_summary skipped (pi): transcript too short (${transcript.length} chars)`);
+      return;
+    }
+    const sourceTaskId = config.taskId;
+    const agentId = config.agentId;
+    if (!sourceTaskId || !agentId) {
+      console.warn(`session_summary skipped (pi): ${!sourceTaskId ? "task id unavailable" : "agent id unavailable"}`);
+      return;
+    }
+    const taskDetails = await fetchTaskDetails(config).catch(() => null);
+    const wantRatings = getMemoryRaterNames().includes("llm");
+    const retrievals = wantRatings ? await _fetchRetrievals({
+      apiUrl: config.apiUrl,
+      apiKey: config.apiKey,
+      agentId,
+      taskId: sourceTaskId
+    }).catch(() => []) : [];
+    const result = await _runSummarize({
+      harness: "pi",
+      transcript,
+      retrievals,
+      taskContext: {
+        sourceTaskId,
+        agentId,
+        prompt: taskDetails?.task
+      },
+      apiUrl: config.apiUrl,
+      apiKey: config.apiKey,
+      env: config.env
+    });
+    if (!result) {
+      console.warn("session_summary skipped (pi): summarizer returned no result");
+      return;
+    }
+    const summary = result.summary.trim();
+    if (summary.length <= 20 || summary.toLowerCase().includes("no significant learnings")) {
+      console.debug(`session_summary skipped (pi): summary failed quality gate (${summary.length} chars)`);
+      return;
+    }
+    const indexResp = await fetch(`${config.apiUrl}/api/memory/index`, {
+      method: "POST",
+      headers: apiHeaders(config),
+      body: JSON.stringify({
+        scope: "agent",
+        source: "session_summary",
+        sourceTaskId,
+        content: summary,
+        name: "session-summary",
+        agentId
+      })
+    });
+    if (!indexResp.ok) {
+      const text = await indexResp.text().catch(() => "");
+      console.error("session_summary: /api/memory/index POST failed (pi):", indexResp.status, text);
+      return;
+    }
+    if (wantRatings && result.ratings && result.ratings.length > 0) {
+      const ratingEvents = _buildRatings(result.ratings, retrievals);
+      if (ratingEvents.length > 0) {
+        await _postRatings({
+          apiUrl: config.apiUrl,
+          apiKey: config.apiKey,
+          agentId,
+          taskId: sourceTaskId,
+          events: ratingEvents
+        }).catch((err) => console.error("session_summary: postRatings failed (pi):", err));
+      }
+    }
+  } catch (err) {
+    console.error("session_summary failed (pi):", err);
+  }
+}
+function createSwarmHooksExtension(config) {
+  return (pi) => {
+    let lastContextPostTime = 0;
+    pi.on("session_start", async (_event, _ctx) => {
+      fireAndForget(`${config.apiUrl}/ping`, {
+        method: "POST",
+        headers: apiHeaders(config)
+      });
+      if (config.taskId) {
+        await clearToolHistory(config.taskId);
+      }
+      if (config.isLead) {
+        const ctx = await fetchConcurrentContext(config);
+        if (ctx) {
+          console.log(ctx);
+        }
+      }
+    });
+    pi.on("tool_call", async (event, _ctx) => {
+      if (!config.isLead && config.taskId) {
+        const { cancelled, reason } = await isTaskCancelled(config);
+        if (cancelled) {
+          const cancelReason = reason || "Task cancelled by lead or creator";
+          return {
+            block: true,
+            reason: `\uD83D\uDED1 TASK CANCELLED: Your current task (${config.taskId.slice(0, 8)}) has been cancelled. Reason: "${cancelReason}". ` + `Stop working on this task immediately. Do NOT continue making tool calls. ` + `Use store-progress to acknowledge the cancellation and mark the task as failed, then wait for new tasks.`
+          };
+        }
+      }
+      if (!config.isLead && config.taskId) {
+        const toolName = event.toolName;
+        const toolInput = "input" in event ? event.input : {};
+        const loopResult = await checkToolLoop(config.taskId, toolName, toolInput);
+        if (loopResult.blocked) {
+          return {
+            block: true,
+            reason: `LOOP DETECTED: ${loopResult.reason} ` + "Stop repeating this action and try a fundamentally different approach. " + "If you're truly stuck, use store-progress to report the blocker."
+          };
+        }
+        if (loopResult.severity === "warning" && loopResult.reason) {
+          console.log(`Warning: ${loopResult.reason}`);
+        }
+      }
+      if (event.toolName?.endsWith("poll-task")) {
+        const shouldBlock = await checkShouldBlockPolling(config);
+        if (shouldBlock) {
+          return {
+            block: true,
+            reason: "\uD83D\uDED1 POLLING LIMIT REACHED: You have exceeded the maximum empty poll attempts. " + "EXIT NOW - do not make any more tool calls."
+          };
+        }
+      }
+      return;
+    });
+    pi.on("tool_result", async (event, ctx) => {
+      if (!config.isLead && config.taskId) {
+        fireAndForget(`${config.apiUrl}/api/active-sessions/heartbeat/${config.taskId}`, {
+          method: "PUT",
+          headers: apiHeaders(config)
+        });
+      }
+      fireAndForget(`${config.apiUrl}/api/agents/${config.agentId}/activity`, {
+        method: "PUT",
+        headers: apiHeaders(config)
+      });
+      const usage = ctx.getContextUsage?.();
+      if (config.taskId && usage?.tokens != null) {
+        const now = Date.now();
+        if (now - lastContextPostTime >= 30000) {
+          lastContextPostTime = now;
+          fireAndForget(`${config.apiUrl}/api/tasks/${config.taskId}/context`, {
+            method: "POST",
+            headers: apiHeaders(config),
+            body: JSON.stringify({
+              eventType: "progress",
+              sessionId: `pi-${config.taskId}`,
+              contextUsedTokens: usage.tokens,
+              contextTotalTokens: usage.contextWindow,
+              contextPercent: usage.percent
+            })
+          });
+        }
+      }
+      const toolName = event.toolName;
+      const input = event.input;
+      const editedPath = input?.file_path || input?.path;
+      if ((toolName === "write" || toolName === "edit") && editedPath) {
+        if (editedPath === "/workspace/SOUL.md" || editedPath === "/workspace/IDENTITY.md" || editedPath === "/workspace/TOOLS.md") {
+          syncIdentityFilesToServer(config, "self_edit");
+        }
+        if (editedPath.startsWith("/workspace/start-up")) {
+          syncSetupScriptToServer(config, "self_edit");
+        }
+        if (editedPath.startsWith("/workspace/personal/memory/") || editedPath.startsWith("/workspace/shared/memory/")) {
+          autoIndexMemoryFile(config, editedPath);
+        }
+      }
+      if (config.isLead && event.toolName?.endsWith("send-task")) {
+        console.log("Task sent successfully. Monitor progress using the get-task-details tool periodically.");
+      }
+      return;
+    });
+    pi.on("context", async (_event, ctx) => {
+      if (!config.taskId)
+        return;
+      try {
+        const taskDetails = await fetchTaskDetails(config);
+        if (taskDetails) {
+          const reminder = [
+            "=== GOAL REMINDER (injected before context compaction) ===",
+            `Task ID: ${taskDetails.id}`,
+            `Task: ${taskDetails.task}`
+          ];
+          if (taskDetails.progress) {
+            reminder.push(`Current Progress: ${taskDetails.progress}`);
+          }
+          reminder.push("=== Continue working on this task after compaction ===");
+          console.log(reminder.join(`
+`));
+        }
+      } catch {}
+      const usage = ctx.getContextUsage?.();
+      if (usage) {
+        fireAndForget(`${config.apiUrl}/api/tasks/${config.taskId}/context`, {
+          method: "POST",
+          headers: apiHeaders(config),
+          body: JSON.stringify({
+            eventType: "compaction",
+            sessionId: `pi-${config.taskId}`,
+            contextUsedTokens: usage.tokens ?? undefined,
+            contextTotalTokens: usage.contextWindow,
+            contextPercent: usage.percent ?? undefined
+          })
+        });
+      }
+      return;
+    });
+    pi.on("input", async (_event, _ctx) => {
+      if (!config.isLead && config.taskId) {
+        const { cancelled, reason } = await isTaskCancelled(config);
+        if (cancelled) {
+          const cancelReason = reason || "Task cancelled by lead or creator";
+          console.log(`\uD83D\uDED1 TASK CANCELLED: ${cancelReason}. Stop working and use store-progress to acknowledge.`);
+          return { action: "handled" };
+        }
+      }
+      return;
+    });
+    pi.on("session_shutdown", async (_event, ctx) => {
+      const usage = ctx.getContextUsage?.();
+      if (config.taskId && usage) {
+        await fetch(`${config.apiUrl}/api/tasks/${config.taskId}/context`, {
+          method: "POST",
+          headers: apiHeaders(config),
+          body: JSON.stringify({
+            eventType: "completion",
+            sessionId: `pi-${config.taskId}`,
+            contextTotalTokens: usage.contextWindow,
+            contextPercent: usage.percent ?? undefined,
+            contextUsedTokens: usage.tokens ?? undefined
+          })
+        }).catch(() => {});
+      }
+      await syncIdentityFilesToServer(config);
+      await syncSetupScriptToServer(config);
+      const sessionFile = ctx.sessionManager.getSessionFile?.();
+      if (!process.env.SKIP_SESSION_SUMMARY) {
+        await summarizeSessionForPi(config, sessionFile);
+      } else {
+        console.debug("session_summary skipped (pi): SKIP_SESSION_SUMMARY is set");
+      }
+      fireAndForget(`${config.apiUrl}/close`, {
+        method: "POST",
+        headers: apiHeaders(config)
+      });
+    });
+  };
+}
+// src/providers/pi-mono-adapter.ts
+function modelToCredKeys(modelStr) {
+  if (!modelStr)
+    return null;
+  const lower = modelStr.toLowerCase();
+  if (lower === "opus" || lower === "sonnet" || lower === "haiku") {
+    return ["ANTHROPIC_API_KEY", "OPENROUTER_API_KEY"];
+  }
+  if (modelStr.includes("/")) {
+    const provider = modelStr.slice(0, modelStr.indexOf("/")).toLowerCase();
+    if (provider === "anthropic")
+      return ["ANTHROPIC_API_KEY"];
+    if (provider === "openrouter")
+      return ["OPENROUTER_API_KEY"];
+    if (provider === "openai")
+      return ["OPENAI_API_KEY"];
+    if (provider === "google")
+      return ["GOOGLE_API_KEY"];
+  }
+  return null;
+}
+function getHarnessDrivableBedrockModels() {
+  try {
+    return getBuiltinModels("amazon-bedrock").map((m) => ({ id: m.id, name: m.name }));
+  } catch {
+    return [];
+  }
+}
+async function runBedrockSdkProbeAndEnumerate(region) {
+  const { BedrockClient, ListFoundationModelsCommand, ListInferenceProfilesCommand } = await import("./index-kkeftv5h.js").then((m)=>__toESM(m.default,1));
+  const client = new BedrockClient({ region });
+  const invocable = new Set;
+  const fmResponse = await client.send(new ListFoundationModelsCommand({ byInferenceType: "ON_DEMAND", byOutputModality: "TEXT" }));
+  for (const m of fmResponse.modelSummaries ?? []) {
+    if (m.modelId && m.modelLifecycle?.status === "ACTIVE") {
+      invocable.add(m.modelId);
+    }
+  }
+  const profileResponse = await client.send(new ListInferenceProfilesCommand({}));
+  for (const p of profileResponse.inferenceProfileSummaries ?? []) {
+    if (p.inferenceProfileId) {
+      invocable.add(p.inferenceProfileId);
+    }
+  }
+  return getHarnessDrivableBedrockModels().filter((m) => invocable.has(m.id));
+}
+async function checkPiMonoCredentials(env, opts = {}) {
+  const bedrockAuthMode = env.BEDROCK_AUTH_MODE?.toLowerCase();
+  const isBedrockBearer = bedrockAuthMode === "bearer";
+  const isBedrockSdk = bedrockAuthMode === "sdk" || bedrockAuthMode === undefined && env.MODEL_OVERRIDE?.toLowerCase().startsWith("amazon-bedrock/");
+  if (isBedrockBearer && !env.AWS_BEARER_TOKEN_BEDROCK) {
+    return {
+      ready: false,
+      missing: ["AWS_BEARER_TOKEN_BEDROCK"],
+      hint: "BEDROCK_AUTH_MODE=bearer requires AWS_BEARER_TOKEN_BEDROCK (a Bedrock API key); set it, or use BEDROCK_AUTH_MODE=sdk to authenticate through the AWS credential chain.",
+      bedrockModels: [],
+      bedrockRegion: env.AWS_REGION ?? ""
+    };
+  }
+  if (isBedrockSdk || isBedrockBearer) {
+    const region = env.AWS_REGION;
+    if (!region) {
+      return {
+        ready: false,
+        missing: [],
+        hint: "AWS_REGION is not set — set it to the region where your Bedrock models are accessible so model enumeration matches the inference region.",
+        bedrockModels: [],
+        bedrockRegion: ""
+      };
+    }
+    const probe = opts.bedrockProbe ?? (() => runBedrockSdkProbeAndEnumerate(region));
+    try {
+      const probeResult = await probe();
+      const bedrockModels = Array.isArray(probeResult) ? probeResult : [];
+      return {
+        ready: true,
+        missing: [],
+        satisfiedBy: isBedrockBearer ? "env" : "sdk-delegated",
+        hint: `Bedrock models invocable in ${region} enumerated (${bedrockModels.length} usable; ListFoundationModels + ListInferenceProfiles).`,
+        bedrockModels,
+        bedrockRegion: 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 enumeration failed (region: ${region}): ${errorMessage}`,
+        bedrockModels: [],
+        bedrockRegion: region
+      };
+    }
+  }
+  const homeDir = opts.homeDir ?? env.HOME ?? "/root";
+  const fsProbe = opts.fs?.existsSync ?? existsSync;
+  const authFile = `${homeDir}/.pi/agent/auth.json`;
+  if (fsProbe(authFile)) {
+    return { ready: true, missing: [], satisfiedBy: "file" };
+  }
+  const requiredKeys = modelToCredKeys(env.MODEL_OVERRIDE);
+  if (requiredKeys) {
+    if (requiredKeys.some((k) => env[k])) {
+      return { ready: true, missing: [], satisfiedBy: "env" };
+    }
+    const keyList = requiredKeys.join(" / ");
+    return {
+      ready: false,
+      missing: [...requiredKeys, authFile],
+      hint: `MODEL_OVERRIDE=${env.MODEL_OVERRIDE} requires one of ${keyList}; or run \`pi auth login\` to create ${authFile}.`
+    };
+  }
+  if (env.ANTHROPIC_API_KEY || env.OPENROUTER_API_KEY || env.OPENAI_API_KEY) {
+    return { ready: true, missing: [], satisfiedBy: "env" };
+  }
+  return {
+    ready: false,
+    missing: ["ANTHROPIC_API_KEY", "OPENROUTER_API_KEY", "OPENAI_API_KEY", authFile],
+    hint: "Set one of ANTHROPIC_API_KEY / OPENROUTER_API_KEY / OPENAI_API_KEY (any one suffices), or run `pi auth login` to create ~/.pi/agent/auth.json."
+  };
+}
+function jsonSchemaToTypeBox(schema) {
+  return exports_typebox.Unsafe(schema);
+}
+function mcpToolsToDefinitions(mcpClient, tools) {
+  return tools.map((tool) => ({
+    name: tool.name,
+    label: tool.name,
+    description: tool.description || tool.name,
+    parameters: jsonSchemaToTypeBox(tool.inputSchema),
+    async execute(_toolCallId, params) {
+      const result = await mcpClient.callTool(tool.name, params);
+      const text = result.content.map((c) => c.text ?? "").filter(Boolean).join(`
+`);
+      if (result.isError) {
+        throw new Error(text || `Tool ${tool.name} failed with no error message`);
+      }
+      return {
+        content: [{ type: "text", text: text || "(no output)" }],
+        details: undefined
+      };
+    }
+  }));
+}
+var ANTHROPIC_SHORTNAME_OPENROUTER_MIRROR = {
+  fable: "anthropic/claude-fable-5",
+  opus: "anthropic/claude-opus-4.8",
+  sonnet: "anthropic/claude-sonnet-5",
+  haiku: "anthropic/claude-haiku-4.5"
+};
+function envHasAnthropicCred(env) {
+  return !!(env.ANTHROPIC_API_KEY || env.ANTHROPIC_OAUTH_TOKEN);
+}
+var PI_RUNTIME_API_KEYS = [
+  ["OPENROUTER_API_KEY", "openrouter"],
+  ["ANTHROPIC_API_KEY", "anthropic"],
+  ["OPENAI_API_KEY", "openai"],
+  ["GOOGLE_API_KEY", "google"]
+];
+async function createPiRuntimeAuth(env = process.env) {
+  const modelRuntime = await ModelRuntime.create();
+  for (const [envKey, provider] of PI_RUNTIME_API_KEYS) {
+    const apiKey = env[envKey];
+    if (apiKey) {
+      await modelRuntime.setRuntimeApiKey(provider, apiKey);
+    }
+  }
+  return modelRuntime;
+}
+var OPENROUTER_OVERRIDE_MARKER = ".agent-swarm-openrouter-override.json";
+async function readJsonFile(path) {
+  try {
+    const file = Bun.file(path);
+    if (!await file.exists())
+      return;
+    const parsed = JSON.parse(await file.text());
+    return typeof parsed === "object" && parsed !== null ? parsed : undefined;
+  } catch {
+    return;
+  }
+}
+async function ensureOpenRouterModelsOverride(agentDir, env = process.env) {
+  const baseUrl = getOpenRouterBaseUrl(env);
+  const modelsPath = join(agentDir, "models.json");
+  const markerPath = join(agentDir, OPENROUTER_OVERRIDE_MARKER);
+  if (baseUrl === DEFAULT_OPENROUTER_BASE_URL) {
+    await revertOpenRouterModelsOverride(modelsPath, markerPath);
+    return;
+  }
+  let existing = {};
+  try {
+    const file = Bun.file(modelsPath);
+    if (await file.exists()) {
+      existing = JSON.parse(await file.text());
+    }
+  } catch (err) {
+    console.warn(`[pi-mono] ${modelsPath} is unreadable/invalid (${err instanceof Error ? err.message : err}); rewriting with the OpenRouter gateway override`);
+    existing = {};
+  }
+  const providers = typeof existing.providers === "object" && existing.providers !== null ? existing.providers : {};
+  const openrouter = typeof providers.openrouter === "object" && providers.openrouter !== null ? providers.openrouter : {};
+  const priorMarker = await readJsonFile(markerPath);
+  const currentBaseUrl = typeof openrouter.baseUrl === "string" ? openrouter.baseUrl : undefined;
+  const previous = priorMarker ? priorMarker.previous : currentBaseUrl !== baseUrl ? currentBaseUrl : undefined;
+  const next = {
+    ...existing,
+    providers: {
+      ...providers,
+      openrouter: { ...openrouter, baseUrl }
+    }
+  };
+  await Bun.write(modelsPath, `${JSON.stringify(next, null, 2)}
+`);
+  const marker = {
+    baseUrl,
+    ...previous !== undefined ? { previous } : {}
+  };
+  await Bun.write(markerPath, `${JSON.stringify(marker, null, 2)}
+`);
+}
+async function revertOpenRouterModelsOverride(modelsPath, markerPath) {
+  const marker = await readJsonFile(markerPath);
+  if (!marker)
+    return;
+  const removeMarker = () => Bun.file(markerPath).delete();
+  const existing = await readJsonFile(modelsPath);
+  if (!existing) {
+    await removeMarker();
+    return;
+  }
+  const providers = typeof existing.providers === "object" && existing.providers !== null ? { ...existing.providers } : undefined;
+  const openrouter = providers && typeof providers.openrouter === "object" && providers.openrouter !== null ? { ...providers.openrouter } : undefined;
+  if (!providers || !openrouter || openrouter.baseUrl !== marker.baseUrl) {
+    await removeMarker();
+    return;
+  }
+  if (marker.previous !== undefined) {
+    openrouter.baseUrl = marker.previous;
+  } else {
+    delete openrouter.baseUrl;
+  }
+  if (Object.keys(openrouter).length === 0) {
+    delete providers.openrouter;
+  } else {
+    providers.openrouter = openrouter;
+  }
+  const next = { ...existing, providers };
+  if (Object.keys(providers).length === 0) {
+    delete next.providers;
+  }
+  if (Object.keys(next).length === 0) {
+    await Bun.file(modelsPath).delete();
+  } else {
+    await Bun.write(modelsPath, `${JSON.stringify(next, null, 2)}
+`);
+  }
+  await removeMarker();
+}
+function resolveModel(modelStr, env = process.env) {
+  if (!modelStr)
+    return;
+  const lower = modelStr.toLowerCase();
+  const isAnthropicShortname = lower === "opus" || lower === "sonnet" || lower === "haiku" || lower === "fable";
+  if (isAnthropicShortname && !envHasAnthropicCred(env) && env.OPENROUTER_API_KEY) {
+    const orModelId = ANTHROPIC_SHORTNAME_OPENROUTER_MIRROR[lower];
+    if (orModelId) {
+      try {
+        return getBuiltinModel("openrouter", orModelId);
+      } catch {}
+    }
+  }
+  const shortnames = {
+    fable: ["anthropic", "claude-fable-5"],
+    opus: ["anthropic", "claude-opus-4-8"],
+    sonnet: ["anthropic", "claude-sonnet-5"],
+    haiku: ["anthropic", "claude-haiku-4-5-20251001"]
+  };
+  const mapping = shortnames[lower];
+  if (mapping) {
+    try {
+      return getBuiltinModel(mapping[0], mapping[1]);
+    } catch {
+      return;
+    }
+  }
+  if (modelStr.includes("/")) {
+    const slashIdx = modelStr.indexOf("/");
+    const provider = modelStr.slice(0, slashIdx);
+    const modelId = modelStr.slice(slashIdx + 1);
+    try {
+      return getBuiltinModel(provider, modelId);
+    } catch {
+      return;
+    }
+  }
+  for (const provider of ["anthropic", "openai", "google"]) {
+    try {
+      return getBuiltinModel(provider, modelStr);
+    } catch {}
+  }
+  return;
+}
+function createAgentsMdSymlink(cwd) {
+  const claudeMd = join(cwd, "CLAUDE.md");
+  const agentsMd = join(cwd, "AGENTS.md");
+  if (existsSync(claudeMd) && !existsSync(agentsMd)) {
+    try {
+      symlinkSync("CLAUDE.md", agentsMd);
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  return false;
+}
+function cleanupAgentsMdSymlink(cwd) {
+  const agentsMd = join(cwd, "AGENTS.md");
+  try {
+    if (existsSync(agentsMd) && lstatSync(agentsMd).isSymbolicLink()) {
+      unlinkSync(agentsMd);
+    }
+  } catch {}
+}
+function extractTextContent(content) {
+  if (typeof content === "string")
+    return content.trim();
+  if (!Array.isArray(content))
+    return "";
+  return content.filter((c) => typeof c === "object" && c !== null && c.type === "text").map((c) => c.text || "").join("").trim();
+}
+function extractPiAssistantText(message) {
+  if (!message || typeof message !== "object")
+    return "";
+  const msg = message;
+  if (msg.role !== "assistant")
+    return "";
+  return extractTextContent(msg.content);
+}
+
+class PiMonoSession {
+  listeners = [];
+  eventQueue = [];
+  _sessionId;
+  completionPromise;
+  agentSession;
+  config;
+  createdSymlink;
+  logFileHandle;
+  lastEmittedMessage = "";
+  lastAssistantText = "";
+  sessionStartedAt = Date.now();
+  prevOutputTokens = 0;
+  terminalError = null;
+  appliedReasoningEffort;
+  sessionEnded = false;
+  constructor(agentSession, config, createdSymlink, appliedReasoningEffort = null) {
+    this.agentSession = agentSession;
+    this.config = config;
+    this.createdSymlink = createdSymlink;
+    this.appliedReasoningEffort = appliedReasoningEffort;
+    this.logFileHandle = Bun.file(config.logFile).writer();
+    this._sessionId = agentSession.sessionId;
+    this.sessionStartedAt = Date.now();
+    const piVersion = readPkgVersion("@earendil-works/pi-coding-agent");
+    this.emit({
+      type: "session_init",
+      sessionId: this._sessionId,
+      provider: "pi",
+      harnessVariant: "stock",
+      ...piVersion ? { harnessVariantMeta: { version: piVersion } } : {}
+    });
+    this.agentSession.subscribe((event) => this.handleAgentEvent(event));
+    this.completionPromise = this.runSession();
+  }
+  reportedModel() {
+    const m = this.agentSession.model;
+    if (m)
+      return `${m.provider}/${m.id}`;
+    return this.config.model;
+  }
+  emit(event) {
+    const scrubbed = event.type === "raw_log" || event.type === "raw_stderr" ? { ...event, content: scrubSecrets(event.content) } : event;
+    this.logFileHandle.write(`${JSON.stringify({ ...scrubbed, timestamp: new Date().toISOString() })}
+`);
+    if (this.listeners.length > 0) {
+      for (const listener of this.listeners) {
+        listener(scrubbed);
+      }
+    } else {
+      this.eventQueue.push(scrubbed);
+    }
+  }
+  handleAgentEvent(event) {
+    switch (event.type) {
+      case "message_end": {
+        const endMsg = event.message;
+        if (endMsg.role === "assistant") {
+          if (endMsg.stopReason === "error") {
+            this.terminalError = endMsg.errorMessage ?? this.terminalError ?? "Unknown error";
+            break;
+          }
+          this.terminalError = null;
+        }
+        const text = extractPiAssistantText(event.message);
+        if (text) {
+          this.lastAssistantText = text;
+        }
+        if (text && text !== this.lastEmittedMessage) {
+          const model = this.reportedModel();
+          this.emit({
+            type: "raw_log",
+            content: JSON.stringify({
+              type: "assistant",
+              message: {
+                role: "assistant",
+                content: [{ type: "text", text }],
+                model
+              }
+            })
+          });
+          this.emit({ type: "message", role: "assistant", content: text });
+          this.lastEmittedMessage = text;
+        }
+        const usage = this.agentSession.getContextUsage();
+        if (usage && usage.tokens != null) {
+          const stats = this.agentSession.getSessionStats();
+          const currOutput = stats?.tokens?.output ?? 0;
+          const outputDelta = Math.max(0, currOutput - this.prevOutputTokens);
+          this.prevOutputTokens = currOutput;
+          this.emit({
+            type: "context_usage",
+            contextUsedTokens: usage.tokens,
+            contextTotalTokens: usage.contextWindow,
+            contextPercent: usage.percent ?? 0,
+            outputTokens: outputDelta,
+            contextFormula: "pi-delegated"
+          });
+        }
+        break;
+      }
+      case "tool_execution_start": {
+        const model = this.reportedModel();
+        this.emit({
+          type: "raw_log",
+          content: JSON.stringify({
+            type: "assistant",
+            message: {
+              role: "assistant",
+              content: [
+                { type: "tool_use", id: event.toolCallId, name: event.toolName, input: event.args }
+              ],
+              model
+            }
+          })
+        });
+        this.emit({
+          type: "tool_start",
+          toolCallId: event.toolCallId,
+          toolName: event.toolName,
+          args: event.args
+        });
+        break;
+      }
+      case "tool_execution_end":
+        this.emit({
+          type: "raw_log",
+          content: JSON.stringify({
+            type: "assistant",
+            message: {
+              role: "assistant",
+              content: [
+                {
+                  type: "tool_result",
+                  tool_use_id: event.toolCallId,
+                  content: typeof event.result === "string" ? event.result : JSON.stringify(event.result)
+                }
+              ]
+            }
+          })
+        });
+        this.emit({
+          type: "tool_end",
+          toolCallId: event.toolCallId,
+          toolName: event.toolName,
+          result: event.result
+        });
+        break;
+      case "auto_retry_end": {
+        if (event.success) {
+          this.terminalError = null;
+        } else {
+          this.terminalError = event.finalError ?? this.terminalError ?? "Unknown error";
+        }
+        break;
+      }
+    }
+  }
+  async runSession() {
+    try {
+      await this.agentSession.prompt(this.config.prompt, {
+        source: "rpc"
+      });
+      await this.waitForIdle();
+      const stats = this.agentSession.getSessionStats();
+      const cost = this.buildCostData(stats);
+      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,
+          appliedReasoningEffort: this.appliedReasoningEffort
+        };
+      }
+      this.emit({
+        type: "result",
+        cost,
+        isError: false
+      });
+      return {
+        exitCode: 0,
+        sessionId: this._sessionId,
+        cost,
+        output: this.lastAssistantText || undefined,
+        isError: false,
+        appliedReasoningEffort: this.appliedReasoningEffort
+      };
+    } catch (err) {
+      const errorMessage = err instanceof Error ? err.message : String(err);
+      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}
+` });
+      return {
+        exitCode: 1,
+        sessionId: this._sessionId,
+        isError: true,
+        errorCategory: awsCatchError?.category,
+        failureReason: awsCatchError?.message ?? errorMessage,
+        appliedReasoningEffort: this.appliedReasoningEffort
+      };
+    } finally {
+      this.sessionEnded = true;
+      await this.logFileHandle.end();
+      if (this.createdSymlink) {
+        cleanupAgentsMdSymlink(this.config.cwd);
+      }
+      this.agentSession.dispose();
+    }
+  }
+  waitForIdle() {
+    return new Promise((resolve) => {
+      if (!this.agentSession.isStreaming) {
+        resolve();
+        return;
+      }
+      const unsub = this.agentSession.subscribe((event) => {
+        if (event.type === "agent_end") {
+          unsub();
+          resolve();
+        }
+      });
+    });
+  }
+  buildCostData(stats) {
+    return {
+      sessionId: "",
+      taskId: this.config.taskId,
+      agentId: this.config.agentId,
+      totalCostUsd: stats.cost || 0,
+      inputTokens: stats.tokens.input,
+      outputTokens: stats.tokens.output,
+      cacheReadTokens: stats.tokens.cacheRead,
+      cacheWriteTokens: stats.tokens.cacheWrite,
+      durationMs: Date.now() - this.sessionStartedAt,
+      numTurns: stats.userMessages + stats.assistantMessages,
+      model: this.reportedModel(),
+      isError: false,
+      provider: "pi"
+    };
+  }
+  get sessionId() {
+    return this._sessionId;
+  }
+  onEvent(listener) {
+    this.listeners.push(listener);
+    for (const event of this.eventQueue) {
+      listener(event);
+    }
+    this.eventQueue = [];
+  }
+  async waitForCompletion() {
+    return this.completionPromise;
+  }
+  async abort() {
+    await this.agentSession.abort();
+  }
+  async deliverSteering({ mode, text }) {
+    if (this.sessionEnded) {
+      return { delivered: false, reason: "pi session already completed" };
+    }
+    try {
+      if (mode === "steer")
+        await this.agentSession.steer(text);
+      else
+        await this.agentSession.followUp(text);
+      return { delivered: true, mode };
+    } catch (err) {
+      return { delivered: false, reason: String(err) };
+    }
+  }
+}
+
+class PiMonoAdapter {
+  name = "pi";
+  traits = {
+    hasMcp: true,
+    nativeSkillDiscovery: true,
+    hasLocalEnvironment: true,
+    steerModes: ["steer", "queue"]
+  };
+  lastCwd = ".";
+  async createSession(config) {
+    this.lastCwd = config.cwd;
+    console.log(`\x1B[2m[${config.role}]\x1B[0m \x1B[35m▸\x1B[0m Spawning pi-mono for task ${config.taskId.slice(0, 8)}`);
+    const createdSymlink = createAgentsMdSymlink(config.cwd);
+    let customTools = [];
+    if (config.apiUrl && config.apiKey) {
+      try {
+        const mcpClient = new McpHttpClient(config.apiUrl, config.apiKey, config.agentId, config.taskId);
+        const runtimeInstanceId = swarmRuntimeInstanceId();
+        if (runtimeInstanceId) {
+          mcpClient.customHeaders["X-Runtime-Instance-ID"] = runtimeInstanceId;
+        }
+        await mcpClient.initialize();
+        const tools = await mcpClient.listTools();
+        customTools = mcpToolsToDefinitions(mcpClient, tools);
+        console.log(`\x1B[2m[${config.role}]\x1B[0m Discovered ${tools.length} MCP tools from swarm`);
+      } catch (err) {
+        console.warn(`\x1B[33m[${config.role}] Failed to discover MCP tools: ${err}\x1B[0m`);
+      }
+      try {
+        const mcpServersRes = await fetch(`${config.apiUrl}/api/agents/${config.agentId}/mcp-servers?resolveSecrets=true`, {
+          headers: {
+            Authorization: `Bearer ${config.apiKey}`,
+            "X-Agent-ID": config.agentId
+          }
+        });
+        if (mcpServersRes.ok) {
+          const mcpServersData = await mcpServersRes.json();
+          const httpServers = mcpServersData.servers.filter((s) => s.isActive && s.isEnabled && (s.transport === "http" || s.transport === "sse") && s.url);
+          for (const srv of httpServers) {
+            try {
+              const srvClient = new McpHttpClient(srv.url, "", "");
+              srvClient.useRawUrl = true;
+              let parsedHeaders = {};
+              try {
+                parsedHeaders = srv.headers ? JSON.parse(srv.headers) : {};
+              } catch {}
+              srvClient.customHeaders = {
+                ...parsedHeaders,
+                ...srv.resolvedHeaders || {}
+              };
+              await srvClient.initialize();
+              const srvTools = await srvClient.listTools();
+              const prefixed = mcpToolsToDefinitions(srvClient, srvTools).map((t) => ({
+                ...t,
+                name: `mcp__${srv.name}__${t.name}`
+              }));
+              customTools.push(...prefixed);
+              console.log(`\x1B[2m[${config.role}]\x1B[0m Discovered ${srvTools.length} tools from MCP server "${srv.name}"`);
+            } catch (srvErr) {
+              console.warn(`\x1B[33m[${config.role}] Failed to discover tools from MCP server "${srv.name}": ${srvErr}\x1B[0m`);
+            }
+          }
+        }
+      } catch {}
+    }
+    const sessionEnv = config.env ?? process.env;
+    await ensureOpenRouterModelsOverride(getAgentDir(), sessionEnv);
+    const builtinModel = resolveModel(config.model, sessionEnv);
+    const modelRuntime = await createPiRuntimeAuth(sessionEnv);
+    const model = builtinModel ? modelRuntime.getModel(builtinModel.provider, builtinModel.id) ?? builtinModel : builtinModel;
+    const swarmExtension = createSwarmHooksExtension({
+      apiUrl: config.apiUrl,
+      apiKey: config.apiKey,
+      agentId: config.agentId,
+      taskId: config.taskId,
+      isLead: config.role === "lead",
+      env: sessionEnv
+    });
+    const resourceLoader = new DefaultResourceLoader({
+      cwd: config.cwd,
+      agentDir: getAgentDir(),
+      appendSystemPrompt: config.systemPrompt ? [config.systemPrompt] : undefined,
+      extensionFactories: [swarmExtension]
+    });
+    const reasoningApplication = applyReasoningEffort("pi", config.model, config.reasoningEffort);
+    const reasoningSessionOptions = reasoningApplication.kind === "pi-session" ? reasoningApplication.sessionOptions : {};
+    const appliedReasoningEffort = reasoningApplication.kind === "pi-session" ? config.reasoningEffort ?? null : null;
+    const sessionOptions = {
+      cwd: config.cwd,
+      model,
+      customTools,
+      resourceLoader,
+      modelRuntime,
+      ...reasoningSessionOptions
+    };
+    const { session } = await createAgentSession(sessionOptions);
+    return new PiMonoSession(session, config, createdSymlink, appliedReasoningEffort);
+  }
+  async canResume(sessionId) {
+    try {
+      const sessionManager = SessionManager.create(this.lastCwd);
+      const sessions = await sessionManager.list?.();
+      return sessions?.some((s) => s.id === sessionId) ?? false;
+    } catch {
+      return false;
+    }
+  }
+  formatCommand(commandName) {
+    return `/skill:${commandName}`;
+  }
+}
+export {
+  PiMonoAdapter,
+  PiMonoSession,
+  checkPiMonoCredentials,
+  createPiRuntimeAuth,
+  ensureOpenRouterModelsOverride,
+  extractPiAssistantText,
+  mcpToolsToDefinitions,
+  resolveModel,
+  runBedrockSdkProbeAndEnumerate
+};