@desplega.ai/agent-swarm 1.164.1 → 1.166.0

package/dist/{cli-etbrt8x1.js → cli-0nhdwxd5.js}

@@ -1,14 +1,14 @@
 import {
   seedPricingFromModelsDev
-} from "./cli-wg8yjqtw.js";
+} from "./cli-ysnyhws9.js";
 import {
   ensureRbacSeedsSynced,
   init_rbac_roles
-} from "./cli-xb7kyanp.js";
+} from "./cli-8kgvmkak.js";
 import {
   getDb,
-  init_db
-} from "./cli-0wn3ypqv.js";
+  init_db1 as init_db
+} from "./cli-yshaazs1.js";
 
 // src/be/boot-seeds.ts
 init_db();

package/dist/{cli-jeefgppq.js → cli-0qjcsxgz.js}

@@ -1,6 +1,6 @@
 import {
   runStopHookSessionSummarySubprocess
-} from "./cli-3ajw5v5v.js";
+} from "./cli-rsy933yz.js";
 import {
   buildOtelTraceparentEnv,
   isHarnessOtelEnabled
@@ -16,7 +16,7 @@ import {
   clampContextPercent,
   computeContextUsedUnified,
   getContextWindowSize
-} from "./cli-6behs2bt.js";
+} from "./cli-32bca7nr.js";
 import {
   fetchInstalledMcpServers
 } from "./cli-tng3131n.js";
@@ -32,7 +32,7 @@ import {
 } from "./cli-2pdaysab.js";
 import {
   applyReasoningEffort
-} from "./cli-cn53e7vc.js";
+} from "./cli-ttbsse3f.js";
 import {
   swarmRuntimeInstanceId
 } from "./cli-re8z5p8p.js";
@@ -44,12 +44,12 @@ import {
 import {
   init_file_lock,
   withFileLock
-} from "./cli-agjzafns.js";
+} from "./cli-jhm6hzjn.js";
 import {
   CLAUDE_CREDENTIALS_HINT,
   init_credentials,
   validateClaudeCredentials
-} from "./cli-yj790e19.js";
+} from "./cli-tadfgd0t.js";
 import {
   deriveDefaultRoute,
   init_src,
@@ -63,7 +63,7 @@ import {
 import {
   init_secret_scrubber,
   scrubSecrets
-} from "./cli-qt5wzq6v.js";
+} from "./cli-wt7ccy4r.js";
 import {
   require_src
 } from "./cli-knd276ed.js";
@@ -1026,7 +1026,7 @@ class ClaudeAdapter {
     if (transport === "sdk" && isClaudeBridgeEffective(sourceEnv)) {
       throw new Error("CLAUDE_TRANSPORT=sdk cannot run with an effective Claude Bridge configuration. Select CLI transport or disable the bridge.");
     }
-    const claudeSdk = transport === "sdk" ? await import("./claude-sdk-session-6nb9raem.js") : undefined;
+    const claudeSdk = transport === "sdk" ? await import("./claude-sdk-session-kkbxtw5q.js") : undefined;
     claudeSdk?.validateClaudeSdkAdditionalArgs([
       ...claudeBinaryArgv.slice(1),
       ...config.additionalArgs ?? []

package/dist/{cli-6behs2bt.js → cli-32bca7nr.js}

@@ -4,7 +4,7 @@ import {
   init_src,
   runtimeCatalogModel,
   runtimeCatalogSection
-} from "./cli-g3qgrzck.js";
+} from "./cli-zsh093hk.js";
 
 // src/utils/context-window.ts
 init_src();

package/dist/{cli-gt8v96qx.js → cli-3ddybbbx.js}

@@ -11,7 +11,7 @@ import {
   CONTEXT_FORMULA,
   clampContextPercent,
   getContextWindowSize
-} from "./cli-6behs2bt.js";
+} from "./cli-32bca7nr.js";
 import {
   fetchInstalledMcpServers
 } from "./cli-tng3131n.js";
@@ -20,7 +20,7 @@ import {
 } from "./cli-5bfdm1ah.js";
 import {
   applyReasoningEffort
-} from "./cli-cn53e7vc.js";
+} from "./cli-ttbsse3f.js";
 import {
   swarmRuntimeInstanceId
 } from "./cli-re8z5p8p.js";
@@ -31,11 +31,11 @@ import {
 import {
   init_credentials,
   validateOpencodeCredentials
-} from "./cli-yj790e19.js";
+} from "./cli-tadfgd0t.js";
 import {
   init_secret_scrubber,
   scrubSecrets
-} from "./cli-qt5wzq6v.js";
+} from "./cli-wt7ccy4r.js";
 import {
   __toESM
 } from "./cli-bc05qbss.js";

package/dist/{acp-adapter-rxvek4ym.js → cli-3qn4r334.js}

@@ -1,16 +1,27 @@
+import {
+  clampContextPercent,
+  getContextWindowSize
+} from "./cli-32bca7nr.js";
 import {
   fetchInstalledMcpServers
 } from "./cli-tng3131n.js";
 import {
+  ACP_TARGET_IDS,
   getAcpTargetCatalogEntry,
   isAcpTarget
-} from "./cli-dgnj0zcc.js";
-import"./cli-dpvkp2et.js";
+} from "./cli-zp67qg5x.js";
+import {
+  applyReasoningEffort
+} from "./cli-ttbsse3f.js";
 import {
   detachedProcessGroup,
   registerProcessGroup,
   terminateProcessGroup
 } from "./cli-zt3w1cn1.js";
+import {
+  init_src,
+  normalizeGrokModel
+} from "./cli-zsh093hk.js";
 import {
   array,
   boolean,
@@ -30,12 +41,11 @@ import {
 import {
   init_package,
   package_default
-} from "./cli-1d3w4xm3.js";
+} from "./cli-4r1sjfc4.js";
 import {
   init_secret_scrubber,
   scrubSecrets
-} from "./cli-qt5wzq6v.js";
-import"./cli-bc05qbss.js";
+} from "./cli-wt7ccy4r.js";
 
 // node_modules/@agentclientprotocol/sdk/dist/schema/index.js
 var AGENT_METHODS = {
@@ -4718,6 +4728,9 @@ function translateAcpSessionNotification(notification) {
 }
 
 // src/providers/acp-targets.ts
+init_src();
+import { mkdir, mkdtemp, rm } from "node:fs/promises";
+import { tmpdir } from "node:os";
 import { join } from "node:path";
 class AcpTargetResolutionError extends Error {
   constructor(message) {
@@ -4863,14 +4876,247 @@ var opencodeTargetProfile = {
   configuredOptions,
   async writeSystemPromptArtifact() {}
 };
+var geminiSystemPromptPaths = new WeakMap;
+var geminiTargetProfile = {
+  target: "gemini",
+  command() {
+    const entry = getAcpTargetCatalogEntry("gemini");
+    return [entry.command, ...entry.args ?? []];
+  },
+  env(config) {
+    const env = baseTargetEnv(config);
+    const entry = getAcpTargetCatalogEntry("gemini");
+    copyEnvKeys(config, env, entry.envKeys);
+    env.GEMINI_CLI_TRUST_WORKSPACE = "true";
+    if (config.model.trim())
+      env.GEMINI_MODEL = config.model.trim();
+    const systemPromptPath = geminiSystemPromptPaths.get(config);
+    if (systemPromptPath)
+      env.GEMINI_SYSTEM_MD = systemPromptPath;
+    return env;
+  },
+  configuredOptions,
+  async writeSystemPromptArtifact(config) {
+    if (!config.systemPrompt?.trim())
+      return;
+    const directory = await mkdtemp(join(tmpdir(), "swarm-acp-gemini-"));
+    const path = join(directory, "system.md");
+    await Bun.write(path, config.systemPrompt);
+    geminiSystemPromptPaths.set(config, path);
+  }
+};
+function copilotInstructionsDir(config) {
+  const key = new Bun.CryptoHasher("sha256").update(`${config.agentId}:${config.taskId}:${config.cwd}`).digest("hex").slice(0, 16);
+  return join(tmpdir(), "agent-swarm-copilot-instructions", key);
+}
+var COPILOT_INSTRUCTIONS_FILE = join(".github", "instructions", "agent-swarm.instructions.md");
+var copilotTargetProfile = {
+  target: "copilot",
+  command() {
+    const entry = getAcpTargetCatalogEntry("copilot");
+    return [entry.command, ...entry.args ?? []];
+  },
+  env(config) {
+    const env = baseTargetEnv(config);
+    const entry = getAcpTargetCatalogEntry("copilot");
+    copyEnvKeys(config, env, entry.envKeys);
+    if (config.model.trim())
+      env.COPILOT_MODEL = config.model.trim();
+    env.COPILOT_AUTO_UPDATE = "false";
+    const operatorDirs = readEnv(config, "COPILOT_CUSTOM_INSTRUCTIONS_DIRS")?.trim();
+    env.COPILOT_CUSTOM_INSTRUCTIONS_DIRS = [copilotInstructionsDir(config), operatorDirs].filter(Boolean).join(",");
+    return env;
+  },
+  configuredOptions,
+  async writeSystemPromptArtifact(config) {
+    const dir = copilotInstructionsDir(config);
+    await rm(dir, { recursive: true, force: true });
+    if (!config.systemPrompt)
+      return;
+    await mkdir(join(dir, ".github", "instructions"), { recursive: true });
+    await Bun.write(join(dir, COPILOT_INSTRUCTIONS_FILE), `---
+applyTo: "**"
+---
+
+${config.systemPrompt}
+`);
+  },
+  async cleanupSystemPromptArtifact(config) {
+    await rm(copilotInstructionsDir(config), { recursive: true, force: true });
+  }
+};
+var GROK_ISOLATION_ENV = {
+  GROK_DISABLE_AUTOUPDATER: "1",
+  GROK_TELEMETRY_ENABLED: "0",
+  GROK_CLAUDE_HOOKS_ENABLED: "false",
+  GROK_CLAUDE_MCPS_ENABLED: "false",
+  GROK_CLAUDE_AGENTS_ENABLED: "false",
+  GROK_CLAUDE_RULES_ENABLED: "false",
+  GROK_CURSOR_HOOKS_ENABLED: "false",
+  GROK_CURSOR_MCPS_ENABLED: "false",
+  GROK_CURSOR_AGENTS_ENABLED: "false",
+  GROK_CURSOR_RULES_ENABLED: "false",
+  GROK_CURSOR_SKILLS_ENABLED: "false"
+};
+var GROK_XAI_ENDPOINT_KEYS = [
+  "GROK_MODELS_BASE_URL",
+  "GROK_MODELS_LIST_URL",
+  "GROK_XAI_API_BASE_URL"
+];
+function isGrokOpenRouterModel(model) {
+  return model.trim().startsWith("openrouter/");
+}
+function unwrapGrokToolProxy(event) {
+  if (event.type === "tool_start" && event.toolName === "use_tool") {
+    const args = event.args;
+    if (typeof args?.tool_name !== "string" || !args.tool_name)
+      return event;
+    return { ...event, toolName: `mcp__${args.tool_name}`, args: args.tool_input ?? {} };
+  }
+  if (event.type !== "custom" || event.name !== "acp_tool_call_update")
+    return event;
+  const data = event.data;
+  const raw = data?.rawInput;
+  if (!raw || typeof raw !== "object" || typeof raw.variant !== "string")
+    return event;
+  const { variant, ...rest } = raw;
+  const rawInput = variant === "UseTool" ? rest.tool_input ?? {} : rest;
+  return { ...event, data: { ...data, rawInput } };
+}
+function finiteCount(value) {
+  return typeof value === "number" && Number.isFinite(value) && value >= 0 ? value : undefined;
+}
+var XAI_USD_TICKS = 10000000000;
+function grokReportedModel(reported, sessionModel) {
+  const id = normalizeGrokModel(reported);
+  if (!isGrokOpenRouterModel(sessionModel) || isGrokOpenRouterModel(id))
+    return id;
+  return `openrouter/${id}`;
+}
+function grokFinalModel(meta, model) {
+  const reported = typeof meta?.modelId === "string" ? meta.modelId.trim() : "";
+  return reported ? grokReportedModel(reported, model) : normalizeGrokModel(model);
+}
+function grokUsageCounts(usage) {
+  const input = finiteCount(usage.inputTokens) ?? 0;
+  const cacheRead = finiteCount(usage.cachedReadTokens) ?? 0;
+  const reasoning = finiteCount(usage.reasoningTokens) ?? 0;
+  const ticks = finiteCount(usage.costUsdTicks);
+  return {
+    inputTokens: Math.max(0, input - cacheRead),
+    cacheReadTokens: cacheRead,
+    cacheWriteTokens: finiteCount(usage.cacheCreationTokens) ?? 0,
+    outputTokens: (finiteCount(usage.outputTokens) ?? 0) + reasoning,
+    reasoningOutputTokens: reasoning,
+    costUsd: ticks ? ticks / XAI_USD_TICKS : undefined
+  };
+}
+function grokModelUsage(usage, model) {
+  const byModel = usage.modelUsage;
+  if (!byModel || typeof byModel !== "object" || Array.isArray(byModel))
+    return [];
+  const rows = [];
+  for (const [reported, entry] of Object.entries(byModel)) {
+    if (!reported.trim() || !entry || typeof entry !== "object")
+      continue;
+    const {
+      costUsd,
+      reasoningOutputTokens: _,
+      ...counts
+    } = grokUsageCounts(entry);
+    rows.push({
+      model: grokReportedModel(reported, model),
+      ...counts,
+      ...costUsd !== undefined ? { harnessCostUsd: costUsd } : {}
+    });
+  }
+  return rows;
+}
+function grokPromptCost(meta, model) {
+  const usage = meta?.usage;
+  if (!usage || typeof usage !== "object")
+    return;
+  const { costUsd, ...counts } = grokUsageCounts(usage);
+  const turns = finiteCount(usage.numTurns) ?? finiteCount(usage.modelCalls);
+  const models = grokModelUsage(usage, model);
+  return {
+    model: grokFinalModel(meta, model),
+    ...counts,
+    ...models.length ? { models } : {},
+    ...costUsd !== undefined ? { totalCostUsd: costUsd } : {},
+    ...turns ? { numTurns: turns } : {}
+  };
+}
+function grokPromptContext(meta, model) {
+  const used = finiteCount(meta?.totalTokens);
+  if (!used)
+    return;
+  const id = grokFinalModel(meta, model);
+  const total = getContextWindowSize(isGrokOpenRouterModel(id) ? id : `xai/${id}`);
+  return {
+    type: "context_usage",
+    contextUsedTokens: used,
+    contextTotalTokens: total,
+    contextPercent: clampContextPercent(used, total),
+    outputTokens: finiteCount(meta?.outputTokens) ?? null,
+    contextFormula: "harness-reported"
+  };
+}
+var GROK_AUTH_ERROR_RE = /authentication required|not signed in/i;
+var grokTargetProfile = {
+  target: "grok",
+  command(config) {
+    const binary = readEnv(config, "GROK_BINARY")?.trim() || "grok";
+    const args = [binary, "agent", "--no-leader", "--always-approve"];
+    if (config.model.trim())
+      args.push("--model", config.model.trim());
+    const effort = config.reasoningEffort ? applyReasoningEffort("grok", config.model.trim(), config.reasoningEffort) : null;
+    if (effort?.kind === "grok-effort")
+      args.push("--reasoning-effort", effort.reasoningEffort);
+    args.push("stdio");
+    return args;
+  },
+  env(config) {
+    const env = baseTargetEnv(config);
+    if (isGrokOpenRouterModel(config.model)) {
+      copyEnvKeys(config, env, ["OPENROUTER_API_KEY", "GROK_HOME"]);
+    } else {
+      copyEnvKeys(config, env, ["XAI_API_KEY", "GROK_HOME", ...GROK_XAI_ENDPOINT_KEYS]);
+    }
+    Object.assign(env, GROK_ISOLATION_ENV);
+    return env;
+  },
+  configuredOptions() {
+    return {};
+  },
+  async writeSystemPromptArtifact() {},
+  sessionMeta(config) {
+    return {
+      ...config.systemPrompt?.trim() ? { rules: config.systemPrompt } : {},
+      yoloMode: true
+    };
+  },
+  rewriteEvent: unwrapGrokToolProxy,
+  promptCost: grokPromptCost,
+  promptContext: grokPromptContext,
+  describeError(message) {
+    if (!GROK_AUTH_ERROR_RE.test(message))
+      return;
+    return `Grok rejected the credentials (XAI_API_KEY or OPENROUTER_API_KEY invalid or missing): ${message}`;
+  }
+};
 function resolveAcpTarget(config) {
   const target = readEnv(config, "ACP_TARGET") ?? "custom";
   if (!isAcpTarget(target)) {
-    throw new AcpTargetResolutionError(`Unsupported ACP target "${target}". Supported targets: opencode, custom.`);
+    throw new AcpTargetResolutionError(`Unsupported ACP target "${target}". Supported targets: ${ACP_TARGET_IDS.join(", ")}.`);
   }
   switch (target) {
     case "opencode":
       return opencodeTargetProfile;
+    case "gemini":
+      return geminiTargetProfile;
+    case "copilot":
+      return copilotTargetProfile;
     case "custom":
       return customTargetProfile;
   }
@@ -4878,6 +5124,7 @@ function resolveAcpTarget(config) {
 
 // src/providers/acp-adapter.ts
 var ACP_LOG_MAX_CHARS = 30000;
+var ACP_CANCEL_SETTLE_MS = 3000;
 var ACP_LOG_FIELD_MAX_CHARS = 12000;
 var ACP_LOG_PREVIEW_MAX_CHARS = 1e4;
 var CREDENTIAL_HEADER_NAMES = new Set([
@@ -4974,9 +5221,11 @@ function boundedAcpLogScalar(value) {
 
 class SwarmAcpClient {
   emit;
+  target;
   reportedCostUsd = null;
-  constructor(emit) {
+  constructor(emit, target) {
     this.emit = emit;
+    this.target = target;
   }
   async requestPermission(params) {
     const selected = params.options.find((option) => option.kind === "allow_always") ?? params.options.find((option) => option.kind === "allow_once") ?? params.options[0];
@@ -4990,7 +5239,7 @@ class SwarmAcpClient {
     if (costUsd !== null)
       this.reportedCostUsd = costUsd;
     for (const event of translateAcpSessionNotification(params)) {
-      this.emit(event);
+      this.emit(this.target?.rewriteEvent?.(event) ?? event);
     }
   }
 }
@@ -5000,6 +5249,8 @@ class ACPSession {
   client;
   process;
   config;
+  providerName;
+  target;
   sessionId;
   listeners = new Set;
   pendingEvents = [];
@@ -5010,18 +5261,20 @@ class ACPSession {
   completionPromise;
   completionResolve;
   ephemeralTokenId = null;
-  constructor(connection, client2, process2, config, sessionId, providerMeta, ephemeralTokenId) {
+  constructor(connection, client2, process2, config, sessionId, providerName, target, providerMeta, ephemeralTokenId) {
     this.connection = connection;
     this.client = client2;
     this.process = process2;
     this.config = config;
+    this.providerName = providerName;
+    this.target = target;
     this.sessionId = sessionId;
     this.ephemeralTokenId = ephemeralTokenId ?? null;
     this.completionPromise = new Promise((resolve) => {
       this.completionResolve = resolve;
     });
     this.consumeStderr();
-    this.emit({ type: "session_init", sessionId, provider: "acp", providerMeta });
+    this.emit({ type: "session_init", sessionId, provider: providerName, providerMeta });
     this.runPrompt();
   }
   onEvent(listener) {
@@ -5039,6 +5292,7 @@ class ACPSession {
     this.aborted = true;
     try {
       await this.connection.cancel({ sessionId: this.sessionId });
+      await Promise.race([this.completionPromise, Bun.sleep(ACP_CANCEL_SETTLE_MS)]);
     } catch (err) {
       this.emit({
         type: "error",
@@ -5098,8 +5352,11 @@ class ACPSession {
           }
         })
       });
+      const context = this.target.promptContext?.(response._meta, this.config.model);
+      if (context)
+        this.emit(context);
       const isError = response.stopReason === "refusal" || response.stopReason === "cancelled";
-      const cost = this.buildCostData(isError, response.usage);
+      const cost = this.buildCostData(isError, response.usage, response._meta);
       result = {
         exitCode: isError ? 1 : 0,
         sessionId: this.sessionId,
@@ -5110,7 +5367,7 @@ class ACPSession {
       };
       this.emit({ type: "result", cost, output: this.output, isError });
     } catch (err) {
-      const message = scrubSecrets(formatError(err));
+      const message = describeTargetError(this.target, scrubSecrets(formatError(err)));
       this.emit({ type: "error", message, category: "protocol" });
       result = {
         exitCode: 1,
@@ -5135,12 +5392,16 @@ class ACPSession {
         if (done)
           break;
         if (value.length > 0) {
-          this.emit({ type: "raw_stderr", content: scrubSecrets(decoder.decode(value)) });
+          this.emit({
+            type: "raw_stderr",
+            content: scrubSecrets(Bun.stripANSI(decoder.decode(value)))
+          });
         }
       }
     } catch {}
   }
-  buildCostData(isError, usage) {
+  buildCostData(isError, usage, responseMeta) {
+    const targetCost = this.target.promptCost?.(responseMeta, this.config.model);
     return {
       sessionId: this.sessionId,
       taskId: this.config.taskId,
@@ -5154,7 +5415,8 @@ class ACPSession {
       numTurns: 1,
       model: this.config.model,
       isError,
-      provider: "acp"
+      provider: this.providerName,
+      ...targetCost
     };
   }
   finish(result) {
@@ -5169,24 +5431,41 @@ class ACPSession {
 }
 
 class ACPAdapter {
-  name = "acp";
+  options;
+  name;
   traits = {
     hasMcp: true,
     hasToolSearch: false,
     hasLocalEnvironment: true
   };
+  constructor(options = {}) {
+    this.options = options;
+    this.name = options.providerName ?? "acp";
+  }
   async createSession(config) {
-    const target = resolveAcpTarget(config);
+    const target = this.options.target ?? resolveAcpTarget(config);
     await target.writeSystemPromptArtifact(config);
-    const command = target.command(config);
-    const proc = registerProcessGroup(Bun.spawn(command, {
-      cwd: config.cwd,
-      detached: detachedProcessGroup,
-      env: target.env(config),
-      stdin: "pipe",
-      stdout: "pipe",
-      stderr: "pipe"
-    }));
+    const cleanupArtifact = async () => {
+      try {
+        await target.cleanupSystemPromptArtifact?.(config);
+      } catch (err) {
+        console.warn(`\x1B[33m[acp]\x1B[0m System prompt cleanup failed: ${formatError(err)}`);
+      }
+    };
+    let proc;
+    try {
+      proc = registerProcessGroup(Bun.spawn(target.command(config), {
+        cwd: config.cwd,
+        detached: detachedProcessGroup,
+        env: target.env(config),
+        stdin: "pipe",
+        stdout: "pipe",
+        stderr: "pipe"
+      }));
+    } catch (err) {
+      await cleanupArtifact();
+      throw err;
+    }
     let session = null;
     const preSessionEvents = [];
     const client2 = new SwarmAcpClient((event) => {
@@ -5194,7 +5473,7 @@ class ACPAdapter {
         session.emitFromAcp(event);
       else
         preSessionEvents.push(event);
-    });
+    }, target);
     const stream = ndJsonStream2(fileSinkWritableStream(proc.stdin), proc.stdout);
     const connection = new ClientSideConnection(() => client2, stream);
     let ephemeralToken = null;
@@ -5206,7 +5485,9 @@ class ACPAdapter {
       });
       ephemeralToken = await mintAcpSessionToken(config.apiUrl, config.apiKey, config.agentId, config.taskId);
       const installedServers = await fetchInstalledMcpServers(config.apiUrl, config.apiKey, config.agentId, "claude");
+      const sessionMeta = target.sessionMeta?.(config);
       const newSession = await connection.newSession({
+        ...sessionMeta ? { _meta: sessionMeta } : {},
         cwd: config.cwd,
         mcpServers: [
           {
@@ -5223,19 +5504,21 @@ class ACPAdapter {
         ]
       });
       const configOptions = await applyConfiguredOptions(connection, newSession.sessionId, newSession.configOptions ?? [], target.configuredOptions(config));
-      session = new ACPSession(connection, client2, proc, config, newSession.sessionId, {
+      session = new ACPSession(connection, client2, proc, config, newSession.sessionId, this.name, target, {
         target: target.target,
         configOptions: sanitizeAcpConfigOptions(configOptions)
       }, ephemeralToken.tokenId);
       for (const event of preSessionEvents)
         session.emitFromAcp(event);
+      session.waitForCompletion().finally(cleanupArtifact);
       return session;
     } catch (err) {
       if (ephemeralToken && !session) {
         revokeAcpSessionToken(config.apiUrl, config.apiKey, ephemeralToken.tokenId);
       }
       await terminateProcessGroup(proc.pid);
-      throw new Error(`ACP target failed during startup: ${scrubSecrets(formatError(err))}`);
+      await cleanupArtifact();
+      throw new Error(`ACP target failed during startup: ${describeTargetError(target, scrubSecrets(formatError(err)))}`);
     }
   }
   async canResume(_sessionId) {
@@ -5335,6 +5618,9 @@ function toAcpMcpServers(installed) {
   }
   return servers;
 }
+function describeTargetError(target, message) {
+  return target.describeError?.(message) ?? message;
+}
 function formatError(err) {
   return err instanceof Error ? err.message : String(err);
 }
@@ -5352,9 +5638,5 @@ function fileSinkWritableStream(sink) {
     }
   });
 }
-export {
-  ACPAdapter,
-  applyConfiguredOptions,
-  sanitizeAcpConfigOptions,
-  toAcpMcpServers
-};
+
+export { isGrokOpenRouterModel, grokTargetProfile, ACPAdapter, applyConfiguredOptions, sanitizeAcpConfigOptions, toAcpMcpServers };