@desplega.ai/agent-swarm 1.162.0 → 1.164.0

package/dist/cli-2ksgp01n.js

@@ -0,0 +1,933 @@
+import {
+  resolveSlashSkillPrompt
+} from "./cli-wgbezhw2.js";
+import {
+  CONTEXT_FORMULA,
+  clampContextPercent,
+  computeContextUsedUnified
+} from "./cli-6behs2bt.js";
+import {
+  applyReasoningEffort
+} from "./cli-cn53e7vc.js";
+import {
+  ampBillsCacheWrites,
+  resolveAmpModel
+} from "./cli-7xcgj20z.js";
+import {
+  swarmRuntimeInstanceId
+} from "./cli-re8z5p8p.js";
+import {
+  detachedProcessGroup,
+  listDescendantPids,
+  registerProcessGroup,
+  terminatePids,
+  terminateProcessGroup,
+  terminateProcessTree
+} from "./cli-zt3w1cn1.js";
+import {
+  init_secret_scrubber,
+  registerVolatileSecret,
+  scrubSecrets
+} from "./cli-nexqx4ve.js";
+
+// src/providers/amp-adapter.ts
+import { existsSync, readFileSync, renameSync, rmSync, writeFileSync } from "node:fs";
+import { mkdir, mkdtemp, rm, writeFile } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+init_secret_scrubber();
+var AMP_PACKAGE = "@ampcode/cli@0.0.1791216048-g3f2cac";
+var AMP_MCP_SERVER_NAME = "agent-swarm";
+var AMP_PLUGIN_MODE_KEY = "agent-swarm";
+var AMP_LIVE_TEST_TIMEOUT_MS = 5000;
+var AMP_EXPORT_TIMEOUT_MS = 20000;
+var AMP_EXPORT_RETRY_MS = 3000;
+var AMP_EXPORT_RETRIES = 1;
+var AMP_EXIT_AFTER_INPUT_MS = 60000;
+var AMP_STDERR_RECORD_MAX = 16384;
+var AMP_QUEUED_ECHO_MS = 30000;
+function checkAmpCredentials(env) {
+  return env.AMP_API_KEY?.trim() ? { ready: true, missing: [], satisfiedBy: "env" } : {
+    ready: false,
+    missing: ["AMP_API_KEY"],
+    hint: "Set AMP_API_KEY (an access token from ampcode.com/settings) for amp."
+  };
+}
+function resolveAmpBinary(env) {
+  return env.AMP_BINARY || Bun.which("amp", { PATH: env.PATH }) || null;
+}
+function ampEffort(level) {
+  return level === "off" ? "none" : level;
+}
+function buildAmpPlugin(options) {
+  const config = JSON.stringify({
+    baseMode: options.baseMode,
+    instructions: options.instructions,
+    model: options.pin ?? null,
+    reasoningEffort: options.reasoningEffort ?? null,
+    steeringInbox: options.steeringInbox ?? null
+  });
+  return `// @amp-agent-mode key=${AMP_PLUGIN_MODE_KEY} label=Agent Swarm
+// Generated by the agent-swarm worker for one task. Do not edit.
+import { readdirSync, readFileSync, renameSync, rmSync, writeFileSync } from "node:fs";
+
+export const description = "Agent Swarm worker mode generated for one task.";
+
+const CONFIG = ${config};
+
+/**
+ * Claim each queued message by renaming it (.json -> .taken), so the worker and
+ * this hook never both deliver one. A message handed to Amp becomes .read,
+ * naming the tool call whose result carries it, and stays until the worker sees
+ * the model that received that result answer: a crash before that leaves it for
+ * the worker to report as undelivered.
+ */
+function takeSteering(toolUseID: unknown): string[] {
+	if (!CONFIG.steeringInbox) return [];
+	let names: string[];
+	try {
+		names = readdirSync(CONFIG.steeringInbox).filter((name) => name.endsWith(".json")).sort();
+	} catch {
+		return [];
+	}
+	const texts: string[] = [];
+	for (const name of names) {
+		const path = CONFIG.steeringInbox + "/" + name;
+		const claimed = path + ".taken";
+		try {
+			renameSync(path, claimed);
+		} catch {
+			continue;
+		}
+		let text: string;
+		try {
+			text = JSON.parse(readFileSync(claimed, "utf8"));
+		} catch {
+			// Unreadable: dropped, and the worker reports it undelivered.
+			rmSync(claimed, { force: true });
+			continue;
+		}
+		texts.push(text);
+		try {
+			writeFileSync(claimed, JSON.stringify({ text, toolUseID }));
+			renameSync(claimed, path + ".read");
+		} catch {
+			// The worker treats a claim left as .taken as unconsumed.
+		}
+	}
+	return texts;
+}
+
+function withSteering(output: unknown, note: string): unknown {
+	if (Array.isArray(output)) return [...output, { type: "text", text: note }];
+	if (output === undefined || output === null) return note;
+	return (typeof output === "string" ? output : JSON.stringify(output)) + note;
+}
+
+export default function (amp: any) {
+	amp.on("tool.result", (event: any) => {
+		const texts = takeSteering(event.toolUseID);
+		if (texts.length === 0) return;
+		const note = texts.map((text) => "\\n\\n" + text).join("");
+		return {
+			status: event.status,
+			...(event.error ? { error: event.error } : {}),
+			output: withSteering(event.output, note),
+		};
+	});
+	amp.registerAgentMode({
+		key: ${JSON.stringify(AMP_PLUGIN_MODE_KEY)},
+		label: "Agent Swarm",
+		agent: amp.createAgent({
+			extends: CONFIG.baseMode,
+			...(CONFIG.instructions ? { instructions: CONFIG.instructions } : {}),
+			...(CONFIG.model ? { model: CONFIG.model } : {}),
+			...(CONFIG.reasoningEffort ? { reasoningEffort: CONFIG.reasoningEffort } : {}),
+			display: { label: "Agent Swarm" },
+		}).definition,
+	});
+}
+`;
+}
+function buildAmpSettings() {
+  return {
+    "amp.updates.mode": "disabled",
+    "amp.notifications.enabled": false,
+    "amp.notifications.system.enabled": false,
+    "amp.git.commit.coauthor.enabled": false,
+    "amp.git.commit.ampThread.enabled": false,
+    "amp.dangerouslyAllowAll": true
+  };
+}
+function swarmMcpConfig(config) {
+  const runtimeInstanceId = swarmRuntimeInstanceId();
+  return {
+    [AMP_MCP_SERVER_NAME]: {
+      url: `${config.apiUrl}/mcp`,
+      headers: {
+        Authorization: `Bearer ${config.apiKey}`,
+        "X-Agent-ID": config.agentId,
+        "X-Source-Task-Id": config.taskId,
+        ...config.contextKey ? { "X-Context-Key": config.contextKey } : {},
+        ...runtimeInstanceId ? { "X-Runtime-Instance-ID": runtimeInstanceId } : {}
+      }
+    }
+  };
+}
+async function liveTestAmpCredentials(env, timeoutMs = AMP_LIVE_TEST_TIMEOUT_MS) {
+  const binary = resolveAmpBinary(env);
+  if (!binary) {
+    return {
+      ok: false,
+      error: `amp CLI not found. Install ${AMP_PACKAGE} during image provisioning or set AMP_BINARY to a trusted executable.`
+    };
+  }
+  const apiKey = env.AMP_API_KEY?.trim();
+  if (apiKey)
+    registerVolatileSecret(apiKey, "AMP_API_KEY");
+  const configHome = await mkdtemp(join(tmpdir(), "swarm-amp-live-"));
+  try {
+    const proc = registerProcessGroup(Bun.spawn([binary, "usage"], {
+      env: {
+        ...env,
+        XDG_CONFIG_HOME: configHome,
+        AMP_SETTINGS_FILE: join(configHome, "amp", "settings.json")
+      },
+      stdin: "ignore",
+      stdout: "pipe",
+      stderr: "pipe",
+      detached: detachedProcessGroup
+    }));
+    let timedOut = false;
+    const timer = setTimeout(() => {
+      timedOut = true;
+      terminateProcessGroup(proc.pid);
+    }, timeoutMs);
+    try {
+      const [exitCode, stdout, stderr] = await Promise.all([
+        proc.exited,
+        new Response(proc.stdout).text(),
+        new Response(proc.stderr).text()
+      ]);
+      if (timedOut)
+        return { ok: false, error: `amp usage timed out after ${timeoutMs}ms` };
+      if (exitCode === 0)
+        return { ok: true };
+      const line = (stderr.trim() || stdout.trim()).split(`
+`)[0]?.replace(/^Error:\s*/, "") || `amp usage exited ${exitCode}`;
+      return { ok: false, error: scrubSecrets(line).slice(0, 300) };
+    } finally {
+      clearTimeout(timer);
+    }
+  } finally {
+    await rm(configHome, { recursive: true, force: true });
+  }
+}
+function parseAmpThreadCost(text) {
+  const cost = /^Cost: \$([\d,]+(?:\.\d+)?)\s*$/m.exec(text);
+  if (!cost?.[1])
+    return;
+  const routing = text.split(/^## Model Routing\s*$/m)[1];
+  if (routing === undefined)
+    return;
+  const rows = routing.split(/^## /m)[0]?.split(`
+`).map((line) => line.trim()).filter((line) => line.startsWith("|") && !/^\|\s*(Model ID|-)/.test(line));
+  for (const row of rows ?? []) {
+    if (row.split("|")[3]?.trim() !== "Via Amp")
+      return;
+  }
+  const usd = Number(cost[1].replaceAll(",", ""));
+  return Number.isFinite(usd) ? usd : undefined;
+}
+function count(value) {
+  return typeof value === "number" && Number.isFinite(value) && value > 0 ? value : 0;
+}
+function parseAmpThreadUsage(thread) {
+  const messages = thread?.messages;
+  if (!Array.isArray(messages))
+    return;
+  const byModel = new Map;
+  let last;
+  for (const message of messages) {
+    const usage = message?.usage;
+    if (message?.role !== "assistant" || !usage)
+      continue;
+    const model = typeof usage.model === "string" && usage.model ? usage.model : undefined;
+    if (!model)
+      continue;
+    const entry = byModel.get(model) ?? {
+      model,
+      inputTokens: 0,
+      outputTokens: 0,
+      cacheReadTokens: 0,
+      cacheWriteTokens: 0
+    };
+    const cacheCreation = count(usage.cacheCreationInputTokens);
+    entry.inputTokens += count(usage.inputTokens);
+    entry.outputTokens += count(usage.outputTokens);
+    entry.cacheReadTokens += count(usage.cacheReadInputTokens);
+    if (ampBillsCacheWrites(model))
+      entry.cacheWriteTokens += cacheCreation;
+    else
+      entry.inputTokens += cacheCreation;
+    byModel.set(model, entry);
+    last = usage;
+  }
+  if (byModel.size === 0)
+    return;
+  const models = [...byModel.values()];
+  const total = (m) => m.inputTokens + m.outputTokens + m.cacheReadTokens + m.cacheWriteTokens;
+  const primaryModel = [...models].sort((a, b) => total(b) - total(a))[0]?.model;
+  const window = count(last?.maxInputTokens);
+  return {
+    models,
+    primaryModel,
+    contextWindow: window || undefined,
+    contextUsedTokens: last ? count(last.totalInputTokens) + count(last.outputTokens) : undefined,
+    lastOutputTokens: last ? count(last.outputTokens) : undefined
+  };
+}
+function userMessage(text) {
+  return `${JSON.stringify({
+    type: "user",
+    message: { role: "user", content: [{ type: "text", text }] }
+  })}
+`;
+}
+
+class AmpSession {
+  proc;
+  directory;
+  run;
+  sessionId;
+  deliverSteering;
+  listeners = [];
+  pending = [];
+  output;
+  lastAssistantText = "";
+  failure;
+  stderr = "";
+  aborted = false;
+  completion;
+  startedAt = Date.now();
+  result;
+  toolNames = new Map;
+  tokens = { input: 0, output: 0, cacheRead: 0, cacheCreation: 0 };
+  unechoed = [];
+  inputClosed = false;
+  echoWatchdog;
+  exitWatchdog;
+  termination;
+  descendants = new Set;
+  captures = [];
+  steeringSeq = 0;
+  steers = new Map;
+  constructor(proc, directory, prompt, run) {
+    this.proc = proc;
+    this.directory = directory;
+    this.run = run;
+    this.emit({
+      type: "raw_log",
+      content: JSON.stringify({
+        type: "system",
+        subtype: "model.selected",
+        provider: "amp",
+        model: run.selection.model,
+        mode: run.selection.baseMode,
+        ...run.reasoningEffort ? { reasoningEffort: run.reasoningEffort } : {}
+      })
+    });
+    this.deliverSteering = ({ text }) => {
+      if (this.inputClosed || this.aborted) {
+        return Promise.resolve({
+          delivered: false,
+          reason: "Amp is no longer reading input (the turn has ended)"
+        });
+      }
+      try {
+        return this.queueSteering(text);
+      } catch (error) {
+        return Promise.resolve({
+          delivered: false,
+          reason: `Amp steering inbox write failed: ${String(error)}`
+        });
+      }
+    };
+    this.completion = this.runSession(prompt);
+  }
+  onEvent(listener) {
+    this.listeners.push(listener);
+    for (const event of this.pending.splice(0))
+      listener(event);
+  }
+  emit(event) {
+    if (this.listeners.length === 0)
+      this.pending.push(event);
+    else
+      for (const listener of this.listeners)
+        listener(event);
+  }
+  get stdin() {
+    return this.proc.stdin;
+  }
+  async writeInput(text) {
+    this.unechoed.push(text.trim());
+    await this.stdin.write(userMessage(text));
+    await this.stdin.flush?.();
+  }
+  queueSteering(text) {
+    const name = `${String(++this.steeringSeq).padStart(6, "0")}.json`;
+    const temp = join(this.run.steeringInbox, `.${name}.tmp`);
+    writeFileSync(temp, JSON.stringify(text), { mode: 384 });
+    renameSync(temp, join(this.run.steeringInbox, name));
+    return new Promise((resolve) => {
+      this.steers.set(name, { text, via: "inbox", resolve });
+    });
+  }
+  inboxPath(name, suffix = "") {
+    return join(this.run.steeringInbox, name + suffix);
+  }
+  settleSteer(name, result) {
+    const steer = this.steers.get(name);
+    if (!steer)
+      return;
+    this.steers.delete(name);
+    for (const suffix of ["", ".taken", ".read", ".stdin"]) {
+      rmSync(this.inboxPath(name, suffix), { force: true });
+    }
+    steer.resolve(result);
+  }
+  settleOpenSteers(reason) {
+    for (const name of [...this.steers.keys()]) {
+      this.settleSteer(name, { delivered: false, reason });
+    }
+  }
+  carrierOf(name) {
+    try {
+      const claim = JSON.parse(readFileSync(this.inboxPath(name, ".read"), "utf8"));
+      return typeof claim?.toolUseID === "string" ? claim.toolUseID : undefined;
+    } catch {
+      return;
+    }
+  }
+  markReceived(toolUseId, receiver) {
+    if (!toolUseId)
+      return;
+    for (const [name, steer] of this.steers) {
+      if (steer.via !== "inbox" || steer.receiver !== undefined)
+        continue;
+      if (this.carrierOf(name) === toolUseId)
+        steer.receiver = receiver;
+    }
+  }
+  acknowledgeHookSteering(answeredBy) {
+    for (const [name, steer] of [...this.steers]) {
+      if (steer.via !== "inbox")
+        continue;
+      if (existsSync(this.inboxPath(name, ".read"))) {
+        if (steer.receiver === answeredBy)
+          this.settleSteer(name, { delivered: true, mode: "queue" });
+      } else if (!existsSync(this.inboxPath(name)) && !existsSync(this.inboxPath(name, ".taken"))) {
+        this.settleSteer(name, {
+          delivered: false,
+          reason: "Amp could not read the queued steering message"
+        });
+      }
+    }
+  }
+  takeSteering() {
+    const taken = [];
+    for (const [name, steer] of [...this.steers].sort(([a], [b]) => a.localeCompare(b))) {
+      if (steer.via !== "inbox")
+        continue;
+      try {
+        renameSync(this.inboxPath(name), this.inboxPath(name, ".stdin"));
+      } catch {
+        continue;
+      }
+      steer.via = "stdin";
+      taken.push({ name, text: steer.text });
+    }
+    return taken;
+  }
+  endInput() {
+    if (this.inputClosed)
+      return;
+    this.inputClosed = true;
+    clearTimeout(this.echoWatchdog);
+    this.settleOpenSteers("Amp stopped reading input before the steering message reached the model");
+    this.captureDescendants().finally(() => {
+      try {
+        Promise.resolve(this.stdin.end()).catch(() => {});
+      } catch {}
+    });
+    this.exitWatchdog = setTimeout(() => {
+      if (!this.failure)
+        this.failure = "amp did not exit after its turn ended";
+      this.terminate();
+    }, this.run.exitAfterInputMs);
+  }
+  terminate() {
+    this.termination ??= terminateProcessTree(this.proc.pid);
+    return this.termination;
+  }
+  captureDescendants() {
+    const capture = listDescendantPids(this.proc.pid).then((pids) => {
+      for (const pid of pids)
+        this.descendants.add(pid);
+    }).catch(() => {});
+    this.captures.push(capture);
+    return capture;
+  }
+  onTurnEnd() {
+    if (this.inputClosed)
+      return;
+    for (const { name, text } of this.takeSteering()) {
+      this.writeInput(text).catch((error) => {
+        this.settleSteer(name, {
+          delivered: false,
+          reason: `Amp stdin write failed: ${scrubSecrets(String(error))}`
+        });
+        this.endInput();
+      });
+    }
+    if (this.unechoed.length === 0) {
+      this.endInput();
+      return;
+    }
+    clearTimeout(this.echoWatchdog);
+    this.echoWatchdog = setTimeout(() => this.endInput(), AMP_QUEUED_ECHO_MS);
+  }
+  consumeLine(line) {
+    if (!line.trim())
+      return;
+    const clean = scrubSecrets(line);
+    this.emit({ type: "raw_log", content: clean });
+    let event;
+    try {
+      event = JSON.parse(clean);
+    } catch {
+      return;
+    }
+    if (event.session_id && !this.sessionId) {
+      this.sessionId = event.session_id;
+      this.emit({ type: "session_init", sessionId: event.session_id, provider: "amp" });
+    }
+    switch (event.type) {
+      case "system":
+        if (event.subtype === "init")
+          this.checkMcp(event);
+        break;
+      case "assistant":
+        this.onAssistant(event);
+        break;
+      case "user":
+        this.onUser(event);
+        break;
+      case "result":
+        this.result = event;
+        this.captureDescendants();
+        if (typeof event.result === "string")
+          this.output = event.result;
+        this.endInput();
+        break;
+    }
+  }
+  checkMcp(event) {
+    const server = event.mcp_servers?.find((s) => s.name === AMP_MCP_SERVER_NAME);
+    const status = server?.status;
+    if (status === "connected" || status === "connecting" || status === "pending")
+      return;
+    this.failure = `amp could not connect to the swarm MCP server (${status ?? "not listed"})`;
+    this.terminate();
+  }
+  onAssistant(event) {
+    const message = event.message;
+    if (!message)
+      return;
+    this.acknowledgeHookSteering(event.parent_tool_use_id ?? null);
+    const blocks = Array.isArray(message.content) ? message.content : [];
+    const topLevel = !event.parent_tool_use_id;
+    const text = blocks.filter((b) => b.type === "text" && typeof b.text === "string").map((b) => b.text).join("");
+    if (text) {
+      if (topLevel)
+        this.lastAssistantText = text;
+      this.emit({ type: "message", role: "assistant", content: text });
+    }
+    let calledTool = false;
+    for (const block of blocks) {
+      if (block.type !== "tool_use" || !block.name)
+        continue;
+      calledTool = true;
+      const toolCallId = block.id ?? "";
+      this.toolNames.set(toolCallId, block.name);
+      this.emit({ type: "tool_start", toolCallId, toolName: block.name, args: block.input ?? {} });
+    }
+    const usage = message.usage;
+    if (usage) {
+      const input = count(usage.input_tokens);
+      const output = count(usage.output_tokens);
+      const cacheRead = count(usage.cache_read_input_tokens);
+      const cacheCreation = count(usage.cache_creation_input_tokens);
+      this.tokens.input += input;
+      this.tokens.output += output;
+      this.tokens.cacheRead += cacheRead;
+      this.tokens.cacheCreation += cacheCreation;
+      const used = computeContextUsedUnified({
+        inputTokens: input,
+        cacheReadTokens: cacheRead,
+        cacheCreateTokens: cacheCreation,
+        outputTokens: output
+      });
+      if (used > 0)
+        this.emitContext(used, output, null);
+    }
+    if (topLevel && !calledTool && message.stop_reason !== "tool_use")
+      this.onTurnEnd();
+  }
+  onUser(event) {
+    const blocks = Array.isArray(event.message?.content) ? event.message.content : [];
+    for (const block of blocks) {
+      if (block.type === "tool_result") {
+        const toolCallId = block.tool_use_id ?? "";
+        this.markReceived(toolCallId, event.parent_tool_use_id ?? null);
+        const toolName = this.toolNames.get(toolCallId) ?? "tool";
+        this.toolNames.delete(toolCallId);
+        this.emit({ type: "tool_end", toolCallId, toolName, result: block.content });
+      } else if (block.type === "text" && !event.parent_tool_use_id) {
+        const echoed = (block.text ?? "").trim();
+        const index = this.unechoed.indexOf(echoed);
+        if (index >= 0)
+          this.unechoed.splice(index, 1);
+        for (const [name, steer] of this.steers) {
+          if (steer.via === "stdin" && steer.text.trim() === echoed) {
+            this.settleSteer(name, { delivered: true, mode: "queue" });
+            break;
+          }
+        }
+        clearTimeout(this.echoWatchdog);
+      }
+    }
+  }
+  emitContext(used, output, window) {
+    this.emit({
+      type: "context_usage",
+      contextUsedTokens: used,
+      contextTotalTokens: window,
+      contextPercent: window ? clampContextPercent(used, window) ?? 0 : null,
+      outputTokens: output,
+      contextFormula: CONTEXT_FORMULA
+    });
+  }
+  async readStdout() {
+    const decoder = new TextDecoder;
+    let buffer = "";
+    for await (const chunk of this.proc.stdout) {
+      buffer += decoder.decode(chunk, { stream: true });
+      let newline = buffer.indexOf(`
+`);
+      while (newline >= 0) {
+        this.consumeLine(buffer.slice(0, newline));
+        buffer = buffer.slice(newline + 1);
+        newline = buffer.indexOf(`
+`);
+      }
+    }
+    this.consumeLine(buffer + decoder.decode());
+  }
+  async readStderr() {
+    const decoder = new TextDecoder;
+    let pending = "";
+    for await (const chunk of this.proc.stderr) {
+      pending += decoder.decode(chunk, { stream: true });
+      const end = Math.max(pending.lastIndexOf(`
+`), pending.lastIndexOf("\r"));
+      if (end >= 0) {
+        this.emitStderr(pending.slice(0, end + 1));
+        pending = pending.slice(end + 1);
+      }
+      if (pending.length > AMP_STDERR_RECORD_MAX) {
+        const cut = pending.lastIndexOf(" ") + 1 || pending.length;
+        this.emitStderr(pending.slice(0, cut));
+        pending = pending.slice(cut);
+      }
+    }
+    this.emitStderr(pending + decoder.decode());
+  }
+  emitStderr(text) {
+    if (!text)
+      return;
+    const content = scrubSecrets(text);
+    this.stderr = (this.stderr + content).slice(-8000);
+    this.emit({ type: "raw_stderr", content });
+  }
+  async exportUsage() {
+    let usage = await this.exportUsageOnce();
+    for (let retry = 0;!usage && !this.result && retry < AMP_EXPORT_RETRIES; retry++) {
+      await Bun.sleep(AMP_EXPORT_RETRY_MS);
+      usage = await this.exportUsageOnce();
+    }
+    return usage;
+  }
+  async exportUsageOnce() {
+    const text = await this.threadCommand(["export"]);
+    if (text === undefined)
+      return;
+    try {
+      return parseAmpThreadUsage(JSON.parse(text));
+    } catch {
+      return;
+    }
+  }
+  async threadCost() {
+    for (let attempt = 0;; attempt++) {
+      const text = await this.threadCommand(["usage", "--details"]);
+      if (text === undefined)
+        return;
+      const cost = parseAmpThreadCost(text);
+      if (cost !== undefined || attempt >= AMP_EXPORT_RETRIES)
+        return cost;
+      if (!/currently unavailable/i.test(text))
+        return;
+      await Bun.sleep(AMP_EXPORT_RETRY_MS);
+    }
+  }
+  async threadCommand(command) {
+    if (!this.sessionId)
+      return;
+    const [subcommand, ...flags] = command;
+    try {
+      const proc = registerProcessGroup(Bun.spawn([this.run.binary, "threads", subcommand ?? "", this.sessionId, ...flags], {
+        cwd: this.run.cwd,
+        env: this.run.env,
+        stdin: "ignore",
+        stdout: "pipe",
+        stderr: "ignore",
+        detached: detachedProcessGroup
+      }));
+      const timer = setTimeout(() => void terminateProcessGroup(proc.pid), AMP_EXPORT_TIMEOUT_MS);
+      try {
+        const [exitCode, text] = await Promise.all([proc.exited, new Response(proc.stdout).text()]);
+        return exitCode === 0 ? text : undefined;
+      } finally {
+        clearTimeout(timer);
+      }
+    } catch {
+      return;
+    }
+  }
+  buildCost(isError, thread, billedUsd) {
+    if (!this.sessionId)
+      return;
+    const t = this.tokens;
+    const models = thread?.models;
+    const sum = (pick) => (models ?? []).reduce((total, m) => total + pick(m), 0);
+    const hasStreamTokens = t.input + t.output + t.cacheRead + t.cacheCreation > 0;
+    if (!models && !hasStreamTokens && !billedUsd)
+      return;
+    return {
+      sessionId: this.sessionId,
+      taskId: this.run.taskId,
+      agentId: this.run.agentId,
+      totalCostUsd: billedUsd ?? 0,
+      inputTokens: models ? sum((m) => m.inputTokens) : t.input,
+      outputTokens: models ? sum((m) => m.outputTokens) : t.output,
+      cacheReadTokens: models ? sum((m) => m.cacheReadTokens) : t.cacheRead,
+      cacheWriteTokens: models ? sum((m) => m.cacheWriteTokens) : t.cacheCreation,
+      ...models ? { models } : {},
+      durationMs: this.result?.duration_ms ?? Date.now() - this.startedAt,
+      numTurns: this.result?.num_turns ?? null,
+      model: thread?.primaryModel ?? this.run.selection.model,
+      isError,
+      provider: "amp"
+    };
+  }
+  async runSession(prompt) {
+    try {
+      const [exitCode] = await Promise.all([
+        this.proc.exited,
+        this.readStdout(),
+        this.readStderr(),
+        this.writeInput(prompt).catch((error) => {
+          this.failure = `Amp stdin write failed: ${scrubSecrets(String(error))}`;
+          this.endInput();
+          this.terminate();
+        })
+      ]);
+      clearTimeout(this.exitWatchdog);
+      clearTimeout(this.echoWatchdog);
+      this.settleOpenSteers("Amp exited before the steering message reached the model");
+      await this.termination;
+      if (!this.termination) {
+        await Promise.all(this.captures);
+        await terminatePids(this.descendants);
+      }
+      const resultFailed = this.result !== undefined && (this.result.is_error || this.result.subtype !== "success");
+      const output = this.output ?? (this.lastAssistantText || undefined);
+      const isError = this.aborted || exitCode !== 0 || !!this.failure || !this.result || resultFailed;
+      const failureReason = isError ? this.aborted ? "amp session aborted" : this.failure || (resultFailed ? this.result?.error || this.result?.result : undefined) || this.stderr.trim().split(`
+`).slice(-3).join(`
+`) || `amp exited ${exitCode} without a result` : undefined;
+      if (failureReason)
+        this.emit({ type: "error", message: failureReason });
+      const [thread, billedUsd] = await Promise.all([this.exportUsage(), this.threadCost()]);
+      if (thread?.contextUsedTokens && thread.contextWindow) {
+        this.emitContext(thread.contextUsedTokens, thread.lastOutputTokens ?? 0, thread.contextWindow);
+      }
+      if (thread?.primaryModel) {
+        this.emit({
+          type: "raw_log",
+          content: JSON.stringify({
+            type: "system",
+            subtype: "model.resolved",
+            provider: "amp",
+            model: thread.primaryModel,
+            mode: this.run.selection.baseMode
+          })
+        });
+      }
+      const cost = this.buildCost(isError, thread, billedUsd);
+      if (cost)
+        this.emit({ type: "result", cost, output, isError });
+      return {
+        exitCode: isError ? exitCode || 1 : 0,
+        sessionId: this.sessionId,
+        cost,
+        output,
+        isError,
+        failureReason,
+        appliedReasoningEffort: this.run.reasoningEffort
+      };
+    } catch (error) {
+      await this.terminate();
+      const failureReason = scrubSecrets(String(error));
+      this.emit({ type: "error", message: failureReason });
+      return {
+        exitCode: 1,
+        sessionId: this.sessionId,
+        cost: this.buildCost(true, undefined),
+        isError: true,
+        failureReason
+      };
+    } finally {
+      this.settleOpenSteers("Amp exited before the steering message reached the model");
+      await rm(this.directory, { recursive: true, force: true });
+    }
+  }
+  waitForCompletion() {
+    return this.completion;
+  }
+  async abort() {
+    this.aborted = true;
+    this.endInput();
+    await this.terminate();
+  }
+}
+
+class AmpAdapter {
+  options;
+  name = "amp";
+  traits = {
+    hasMcp: true,
+    hasToolSearch: true,
+    nativeSkillDiscovery: true,
+    hasLocalEnvironment: true,
+    steerModes: ["queue"]
+  };
+  constructor(options = {}) {
+    this.options = options;
+  }
+  async createSession(config) {
+    const env = { ...process.env, ...config.env };
+    const apiKey = env.AMP_API_KEY?.trim();
+    if (!apiKey)
+      throw new Error("amp requires AMP_API_KEY");
+    const selection = resolveAmpModel(config.model);
+    const binary = resolveAmpBinary(env);
+    if (!binary) {
+      throw new Error(`amp CLI not found. Install ${AMP_PACKAGE} during image provisioning or set AMP_BINARY to a trusted executable.`);
+    }
+    registerVolatileSecret(apiKey, "AMP_API_KEY");
+    const prompt = await resolveSlashSkillPrompt(config.prompt, {
+      providerLabel: "amp",
+      skillsDir: join(env.HOME ?? "/home/worker", ".agents", "skills")
+    });
+    const effort = applyReasoningEffort("amp", selection.model, config.reasoningEffort);
+    const reasoningEffort = effort.kind === "amp-effort" ? effort.reasoningEffort : null;
+    const directory = await mkdtemp(join(tmpdir(), "swarm-amp-"));
+    try {
+      const configRoot = join(directory, "config");
+      const pluginDir = join(configRoot, "amp", "plugins");
+      await mkdir(pluginDir, { recursive: true });
+      const settingsPath = join(configRoot, "amp", "settings.json");
+      const mcpPath = join(directory, "mcp.json");
+      const steeringInbox = join(directory, "steering");
+      await mkdir(steeringInbox, { mode: 448 });
+      await writeFile(join(pluginDir, "agent-swarm.ts"), buildAmpPlugin({
+        baseMode: selection.baseMode,
+        instructions: config.systemPrompt,
+        pin: selection.pin,
+        reasoningEffort: reasoningEffort ? ampEffort(reasoningEffort) : null,
+        steeringInbox
+      }), { mode: 384 });
+      await writeFile(settingsPath, JSON.stringify(buildAmpSettings()), { mode: 384 });
+      await writeFile(mcpPath, JSON.stringify(swarmMcpConfig(config)), { mode: 384 });
+      const childEnv = {
+        ...env,
+        AMP_API_KEY: apiKey,
+        XDG_CONFIG_HOME: configRoot,
+        AMP_SETTINGS_FILE: settingsPath
+      };
+      const proc = registerProcessGroup(Bun.spawn([
+        binary,
+        "-x",
+        "--stream-json",
+        "--stream-json-input",
+        "-m",
+        AMP_PLUGIN_MODE_KEY,
+        "--title",
+        `swarm task ${config.taskId.slice(0, 8)}`,
+        "--settings-file",
+        settingsPath,
+        "--mcp-config",
+        mcpPath,
+        "--plugin-ready-timeout",
+        "30",
+        "--visibility",
+        "private",
+        "--no-notifications",
+        "--no-ide",
+        "--no-color"
+      ], {
+        cwd: config.cwd,
+        env: childEnv,
+        stdin: "pipe",
+        stdout: "pipe",
+        stderr: "pipe",
+        detached: detachedProcessGroup
+      }));
+      return new AmpSession(proc, directory, prompt, {
+        selection,
+        reasoningEffort,
+        taskId: config.taskId,
+        agentId: config.agentId,
+        binary,
+        cwd: config.cwd,
+        env: childEnv,
+        exitAfterInputMs: this.options.exitAfterInputMs ?? AMP_EXIT_AFTER_INPUT_MS,
+        steeringInbox
+      });
+    } catch (error) {
+      await rm(directory, { recursive: true, force: true });
+      throw error;
+    }
+  }
+  async canResume(_sessionId) {
+    return false;
+  }
+  formatCommand(commandName) {
+    return `/${commandName}`;
+  }
+}
+
+export { AMP_PACKAGE, checkAmpCredentials, resolveAmpBinary, buildAmpPlugin, liveTestAmpCredentials, parseAmpThreadCost, parseAmpThreadUsage, AmpAdapter };