@wrongstack/acp 0.274.0 → 0.275.0

package/dist/index-DEEYyEpu.d.ts

@@ -0,0 +1,54 @@
+import { b as ACPMessage, H as ACPToolCallResponse } from './acp-v1-BxskPsdo.js';
+import './acp-subagent-runner-BAlo23L-.js';
+
+/**
+ * ToolTranslator — bidirectional translation between WrongStack tools and
+ * ACP tool representations.
+ *
+ * Used by DIR-1 (WrongStack as ACP client) to:
+ *   - Map WrongStack TaskSpec → ACP task payload
+ *   - Map ACP tool responses → TaskResult
+ *
+ * Used by DIR-2 (WrongStack as ACP server) to:
+ *   - Convert the WrongStack Tool.inputSchema → ACPToolDefinition.inputSchema
+ *   - (handled by tools-registry.ts — same logic lives there)
+ *
+ * For DIR-1 async tool calls: ACP agents send progress notifications while
+ * a tool is running, then send a final result. The translator handles this
+ * by polling for the final [result] notification on the transport.
+ */
+
+interface ToolTranslatorOptions {
+    /**
+     * If true (default), wrap tool calls in an async poll loop that waits
+     * for progress notifications until a final result arrives.
+     */
+    asyncTools?: boolean | undefined;
+    pollIntervalMs?: number | undefined;
+    totalTimeoutMs?: number | undefined;
+}
+/** ToolTranslator for DIR-1 — wraps ACP client transport, adds task semantics */
+declare class ToolTranslator {
+    private readonly opts;
+    private readonly pending;
+    constructor(opts?: ToolTranslatorOptions);
+    /**
+     * Start listening to a transport for tool responses and cancellations.
+     * Call this once after constructing the translator and before sending tasks.
+     */
+    attachToTransport(transport: {
+        onMessage: (h: (msg: ACPMessage) => void) => () => void;
+        send: (msg: ACPMessage) => Promise<void>;
+    }): void;
+    /**
+     * Send a tool call over the transport and wait for a response.
+     * If asyncTools is true, polls for progress and resolves when the final
+     * response arrives.
+     */
+    callTool(transport: {
+        send: (msg: ACPMessage) => Promise<void>;
+    }, name: string, args: Record<string, unknown>, callId?: string | number): Promise<ACPToolCallResponse>;
+    cancelAll(): void;
+}
+
+export { ToolTranslator as T, type ToolTranslatorOptions as a };

package/dist/index.d.ts

@@ -1,130 +1,13 @@
-export { c as ACPCancelParams, d as ACPCapabilities, e as ACPChildProcess, f as ACPError, g as ACPImageContent, h as ACPInitializeParams, i as ACPInputSchema, j as ACPMessage, k as ACPNotification, l as ACPPlanContent, m as ACPPlanStep, n as ACPProgressContent, o as ACPRequest, p as ACPResourceContent, q as ACPResponse, r as ACPSessionInfo, s as ACPSessionMode, t as ACPTextContent, u as ACPToolCallRequest, v as ACPToolCallResponse, w as ACPToolDefinition, a as ACPToolList, b as ACPToolResult, A as AgentServerTransport, C as ClientTransport, x as ClientTransportOptions, y as ContentBlock, S as StdioTransport } from './stdio-transport-CsFr8JzC.js';
-export { A as ACPToolsRegistry } from './tools-registry-BCf8evEG.js';
-import { T as ToolCallUpdateNotification, P as PermissionOption, b as RequestPermissionOutcome, S as StopReason, U as UsageCost, c as PlanEntry } from './wrongstack-acp-agent-Dv-A0bEm.js';
-export { A as ACPProtocolHandler, W as WrongStackACPServer, a as WrongStackACPServerOptions } from './wrongstack-acp-agent-Dv-A0bEm.js';
-import { A as ACPSubagentRunnerOptions } from './index-BvPqJHhm.js';
-export { a as ACP_AGENT_COMMANDS, T as ToolTranslator, b as ToolTranslatorOptions, m as makeACPSubagentRunner, c as makeACPSubagentRunnerWithStop } from './index-BvPqJHhm.js';
+export { n as ACPCancelParams, o as ACPCapabilities, p as ACPChildProcess, A as ACPClientTransport, q as ACPError, r as ACPImageContent, s as ACPInitializeParams, t as ACPInputSchema, b as ACPMessage, u as ACPNotification, v as ACPPlanContent, w as ACPPlanStep, x as ACPProgressContent, y as ACPRequest, z as ACPResourceContent, B as ACPResponse, D as ACPSessionInfo, E as ACPSessionMode, F as ACPTextContent, G as ACPToolCallRequest, H as ACPToolCallResponse, I as ACPToolDefinition, c as ACPToolList, d as ACPToolResult, a as AgentServerTransport, J as ClientTransport, K as ClientTransportOptions, L as ContentBlock, S as StdioTransport } from './acp-v1-BxskPsdo.js';
+export { A as ACPToolsRegistry } from './tools-registry-D2xdbzN7.js';
+export { A as ACPProtocolHandler, e as WrongStackACPServer, f as WrongStackACPServerOptions } from './wrongstack-acp-agent-nzrqmJnc.js';
+import { i as ACPSubagentRunnerOptions, b as ACPProgressEvent } from './acp-subagent-runner-BAlo23L-.js';
+export { A as ACPCapturedDiff, a as ACPCapturedToolCall, c as ACPProgressHandler, d as ACPSession, e as ACPSessionError, f as ACPSessionErrorKind, g as ACPSessionOptions, h as ACPSessionRunResult, j as ACP_AGENT_COMMANDS, k as AcpAgentCommandOverrides, B as AcpLiveCatalog, l as AcpProbeResult, P as PermissionPolicy, m as PermissionRequest, C as ProbeAcpAgentsOptions, D as REGISTRY_ID_ALIASES, R as RunOneAcpTaskOptions, n as RunOneAcpTaskResult, W as WebSocketClientTransport, o as WebSocketClientTransportOptions, p as audioContent, q as defaultPermissionPolicy, r as imageContent, s as makeACPSubagentRunner, t as makeACPSubagentRunnerWithStop, u as makePermissionPolicy, v as probeAcpAgent, E as probeAcpAgents, w as readOnlyPermissionPolicy, x as resolveAcpAgentCommand, y as runOneAcpTask, z as textContent } from './acp-subagent-runner-BAlo23L-.js';
+export { T as ToolTranslator, a as ToolTranslatorOptions } from './index-DEEYyEpu.js';
+export { F as FileServer, a as FileServerOptions, b as FsError, c as FsErrorCode, R as ReadFileParams, T as TerminalServer, d as TerminalServerOptions, W as WriteFileParams } from './terminal-server-P9KpMZTT.js';
 import 'node:events';
 import '@wrongstack/core';
 
-/**
- * Permission policy for ACP v1 client sessions.
- *
- * ACP agents can call `session/request_permission` to ask the user
- * before executing a tool call. The client is expected to surface
- * the question, get a decision, and respond. This module is the seam
- * where WrongStack-specific permission UI can plug in; for v1 we ship
- * a minimal default that auto-approves the first `allow_once` option
- * (or `allow_always` if present) and rejects on abort.
- */
-
-/** A single permission decision request. */
-interface PermissionRequest {
-    toolCall: ToolCallUpdateNotification;
-    options: readonly PermissionOption[];
-    signal: AbortSignal;
-}
-/** A permission policy decides how to respond to a request. */
-type PermissionPolicy = (req: PermissionRequest) => Promise<RequestPermissionOutcome>;
-/**
- * Default policy: pick the safest-looking allow option if the signal
- * is not aborted, otherwise report cancelled. Order of preference:
- *
- *   1. `allow_always`
- *   2. `allow_once`
- *   3. anything else with `optionId` (last resort)
- *
- * Real WrongStack permission UIs replace this; the contract is the
- * `PermissionPolicy` function type, not the implementation.
- */
-declare const defaultPermissionPolicy: PermissionPolicy;
-
-interface ACPSessionOptions {
-    command: string;
-    args?: readonly string[] | undefined;
-    env?: Record<string, string> | undefined;
-    cwd?: string | undefined;
-    role?: string | undefined;
-    /** Sandbox root for fs/* and terminal/* methods. */
-    projectRoot: string;
-    /** Hard timeout for one prompt turn. Default 5 minutes. */
-    timeoutMs?: number | undefined;
-    /** Override the permission policy. */
-    permissionPolicy?: PermissionPolicy | undefined;
-    /** Per-fs-call timeout, default 30s. */
-    fsTimeoutMs?: number | undefined;
-    /** Per-terminal command timeout, default 5 minutes. */
-    terminalTimeoutMs?: number | undefined;
-    /** Per-terminal output byte cap, default 1 MiB. */
-    terminalOutputByteLimit?: number | undefined;
-}
-interface ACPSessionRunResult {
-    text: string;
-    stopReason: StopReason;
-    hasText: boolean;
-    usage?: {
-        used: number;
-        size: number;
-        cost?: UsageCost | undefined;
-    } | undefined;
-    plan?: PlanEntry[] | undefined;
-}
-type ACPSessionErrorKind = 'spawn_failed' | 'init_failed' | 'protocol_error' | 'session_create_failed' | 'prompt_failed' | 'aborted' | 'closed' | 'agent_died' | 'unsupported_capability';
-declare class ACPSessionError extends Error {
-    readonly kind: ACPSessionErrorKind;
-    readonly cause: unknown;
-    constructor(kind: ACPSessionErrorKind, message: string, cause?: unknown);
-}
-declare class ACPSession {
-    private readonly transport;
-    private readonly fileServer;
-    private readonly terminalServer;
-    private readonly permissionPolicy;
-    private readonly timeoutMs;
-    private readonly opts;
-    private state;
-    private sessionId;
-    /** Pending outbound requests (initialize, session/new, session/prompt, etc). */
-    private readonly pending;
-    private nextId;
-    /** True after close() has been called. */
-    private closed;
-    private constructor();
-    /**
-     * Spawn the child, run the initialize handshake, install the
-     * message dispatch, and return a ready session.
-     */
-    static start(opts: ACPSessionOptions): Promise<ACPSession>;
-    private initialize;
-    /**
-     * Run one prompt turn. Creates a session if needed, sends the
-     * prompt, streams session/update notifications, and resolves with
-     * the agent's response.
-     *
-     * Cancellation: if `signal` aborts mid-prompt, we send
-     * `session/cancel` (a notification per spec) and keep accepting
-     * updates until the agent returns with `stopReason: 'cancelled'`.
-     * The result is the same shape as a normal turn, with
-     * `stopReason === 'cancelled'`.
-     */
-    prompt(text: string, signal: AbortSignal): Promise<ACPSessionRunResult>;
-    private createSession;
-    /** Tear down the session and kill the child process. */
-    close(): Promise<void>;
-    private allocId;
-    private sendRequest;
-    private handleMessage;
-    private handleUpdate;
-    private scratch;
-    private accumulatedText;
-    private accumulatedPlan;
-    private accumulatedUsage;
-    private resetScratch;
-    private handlePermissionRequest;
-    private handleFsRequest;
-    private handleTerminalRequest;
-}
-
 /** Vendor classification — used to filter the catalog by family. */
 type ACPAgentVendor = 'anthropic' | 'google' | 'openai' | 'github' | 'community';
 /** How the agent is integrated into ACP. */
@@ -212,6 +95,12 @@ declare class EnsembleRegistry {
     /**
      * Probe every catalog entry in parallel and return the detection
      * results. Results are cached for `PROBE_CACHE_MS`.
+     *
+     * Probes are dispatched with bounded concurrency (`MAX_PARALLEL_PROBES`)
+     * so cold-start lists do not spawn `catalog.length` subprocesses at
+     * once — which is especially wasteful on Windows shells and on hosts
+     * with large agent catalogs. The output order still matches
+     * `this.catalog` so callers can index by position.
      */
     list(): Promise<readonly DetectedAgent[]>;
     /** Probe a single descriptor. Always returns a `DetectedAgent`. */
@@ -233,14 +122,13 @@ declare class EnsembleRegistry {
  *
  * Maintenance
  * ───────────
- * This is a static catalog by design. ACP v1 is a moving target: agents
- * ship ACP support, deprecate it, change invocation flags. Auto-fetching
- * a live registry sounds appealing but adds a runtime dependency on
- * network + on whatever schema the ACP team decides on for the Registry
- * RFD. A typed static file the maintainer refreshes on a known schedule
- * is more reliable, easier to diff in PRs, and keeps probe failures
- * attributable to the local machine rather than to a transient registry
- * outage.
+ * This is the OFFLINE FALLBACK catalog. The official, hourly-updated registry
+ * now lives at https://github.com/agentclientprotocol/registry (CDN snapshot
+ * in `acp-registry-fetch.ts`). `wstack acp sync` / `/acp sync` fetch it into a
+ * local cache that supersedes this file at resolution time — so this catalog
+ * only needs to carry the most-used agents with invocations that work without
+ * a network round-trip. Entries here are kept aligned to the registry's
+ * authoritative ACP-entry commands; run `/acp probe` to confirm on a host.
  *
  * Each entry tags its `integration` mechanism:
  *   - `native`       — the agent ships with a documented ACP entry flag.
@@ -269,103 +157,91 @@ declare const AGENTS_CATALOG: readonly ACPAgentDescriptor[];
 /** O(1) lookup by id. Returns `undefined` for unknown ids. */
 declare function findAgentDescriptor(id: string): ACPAgentDescriptor | undefined;
 
-interface FileServerOptions {
-    /** Absolute path; only files under this root are accessible. */
-    projectRoot: string;
-    /** Per-call timeout, default 30s. */
-    timeoutMs?: number;
-}
-interface ReadFileParams {
-    sessionId: string;
-    path: string;
-}
-interface WriteFileParams {
-    sessionId: string;
-    path: string;
-    content: string;
-}
-type FsErrorCode = 'ENOENT' | 'EACCES' | 'OUTSIDE_ROOT' | 'TIMEOUT' | 'INVALID_PATH';
 /**
- * Thrown for protocol-level rejections (path outside root, etc.).
- * The session converts these into JSON-RPC error responses.
+ * Official ACP registry fetcher.
+ *
+ * The Agent Client Protocol maintains a canonical, hourly-updated registry of
+ * ACP-supporting agents at https://github.com/agentclientprotocol/registry,
+ * published as a single JSON document on a CDN. This module fetches that
+ * document and maps each entry to our `ACPAgentDescriptor` shape so the live
+ * list can supersede the bundled static `AGENTS_CATALOG` (which remains the
+ * offline fallback).
+ *
+ * Distribution → spawn-command mapping (per the registry FORMAT.md):
+ *   - npx:    { package, args }      → `npx -y <package> <args>`
+ *   - uvx:    { package, args }      → `uvx <package> <args>`
+ *   - binary: { "<os>-<arch>": { cmd, args, env } }
+ *                                    → `<basename(cmd)> <args>` for THIS host
+ *
+ * Binary entries reference a downloadable archive we do NOT fetch; we map the
+ * platform `cmd` to its basename so an already-installed on-PATH binary (the
+ * common case for goose/opencode/cursor) still launches. Agents distributed
+ * ONLY as a binary with no current-platform target are dropped (not runnable).
+ *
+ * Network is never required at runtime: this is invoked by an explicit
+ * `wstack acp sync` / `/acp sync`, the result is cached, and resolution falls
+ * back to the static catalog when no cache exists.
  */
-declare class FsError extends Error {
-    readonly code: FsErrorCode;
-    readonly path: string;
-    constructor(code: FsErrorCode, path: string, message: string);
-}
-declare class FileServer {
-    private readonly root;
-    private readonly timeoutMs;
-    constructor(opts: FileServerOptions);
-    /** Read a text file. Returns the content as a string. */
-    readTextFile(params: ReadFileParams): Promise<{
-        content: string;
-    }>;
-    /** Write a text file. Atomic via write-then-rename. */
-    writeTextFile(params: WriteFileParams): Promise<void>;
-    /**
-     * Resolve a path; throw `FsError('OUTSIDE_ROOT')` if the result is
-     * not under the project root. Symlinks are not followed here — we
-     * operate on the textual path. A future hardening pass can
-     * `fs.realpath` each access to catch symlink escapes.
-     */
-    private resolveInside;
-}
 
-interface TerminalServerOptions {
-    projectRoot: string;
-    /** Hard cap on per-command wall-clock. Default 5 minutes. */
-    commandTimeoutMs?: number;
-    /** Bytes of output to retain per terminal. Default 1 MiB. */
-    outputByteLimit?: number;
-    /** Optional abort signal that kills ALL active terminals. */
-    signal?: AbortSignal;
-}
-declare class TerminalServer {
-    private readonly terminals;
-    private readonly projectRoot;
-    private readonly commandTimeoutMs;
-    private readonly outputByteLimit;
-    private nextId;
-    constructor(opts: TerminalServerOptions);
-    /** Spawn a new terminal. Returns the agent-facing id. */
-    create(params: {
-        sessionId: string;
-        command: string;
-        args?: string[];
-        env?: {
-            name: string;
-            value: string;
-        }[];
-        cwd?: string;
-        outputByteLimit?: number;
-    }): {
-        terminalId: string;
-    };
-    /** Return captured output and (if available) the exit status. */
-    output(terminalId: string): {
-        output: string;
-        truncated: boolean;
-        exitStatus?: {
-            exitCode: number | null;
-            signal: string | null;
+/** Canonical CDN endpoint for the latest registry snapshot. */
+declare const ACP_REGISTRY_URL = "https://cdn.agentclientprotocol.com/registry/v1/latest/registry.json";
+/** One raw entry from the registry JSON (only the fields we consume). */
+interface RegistryAgentEntry {
+    id: string;
+    name?: string;
+    version?: string;
+    description?: string;
+    repository?: string;
+    website?: string;
+    authors?: string[];
+    distribution?: {
+        npx?: {
+            package: string;
+            args?: string[];
+        };
+        uvx?: {
+            package: string;
+            args?: string[];
         };
+        binary?: Record<string, {
+            archive?: string;
+            cmd: string;
+            args?: string[];
+            env?: Record<string, string>;
+        }>;
     };
-    /** Block until the process exits. Resolves with the exit status. */
-    waitForExit(terminalId: string): Promise<{
-        exitCode: number | null;
-        signal: string | null;
-    }>;
-    /** Kill the process but keep the terminal record (agent can still read output). */
-    kill(terminalId: string): void;
-    /** Kill the process if alive and remove the record. */
-    release(terminalId: string): void;
-    /** Kill all active terminals. Used on session close. */
-    releaseAll(): void;
-    private resolveCwd;
-    private buildEnv;
 }
+interface FetchAcpRegistryResult {
+    /** ISO timestamp the snapshot was fetched. */
+    fetchedAt: string;
+    /** Mapped, runnable descriptors (entries we could not map are dropped). */
+    agents: ACPAgentDescriptor[];
+}
+interface FetchAcpRegistryOptions {
+    /** Override the endpoint (tests / mirrors). */
+    url?: string | undefined;
+    /** Abort the fetch from the caller. */
+    signal?: AbortSignal | undefined;
+    /** Hard timeout in ms (default 15s). Layered under any caller signal. */
+    timeoutMs?: number | undefined;
+    /** ISO timestamp to stamp the result with (tests pass a fixed value). */
+    now?: string | undefined;
+    /** Platform key for binary selection (tests). Defaults to this host. */
+    platformKey?: string | undefined;
+}
+/** Map Node's platform/arch to the registry's `<os>-<arch>` key form. */
+declare function currentPlatformKey(): string;
+/**
+ * Map one registry entry to an `ACPAgentDescriptor`, or `null` if it carries
+ * no distribution runnable on this host. Pure — no I/O.
+ */
+declare function mapRegistryEntry(entry: RegistryAgentEntry, platformKey?: string): ACPAgentDescriptor | null;
+/**
+ * Fetch the live registry and return mapped descriptors. Throws on network /
+ * parse failure so the caller (`wstack acp sync`) can surface it; callers that
+ * want graceful degradation use the cached/static fallback instead.
+ */
+declare function fetchAcpRegistry(opts?: FetchAcpRegistryOptions): Promise<FetchAcpRegistryResult>;
 
 /**
  * Ensemble runner — fan a single task out to multiple ACP agents in parallel.
@@ -395,6 +271,8 @@ declare class TerminalServer {
  *    `finally`, so a throw in the body still tears the child down.
  */
 
+/** Live per-agent progress callback for an ensemble run. */
+type EnsembleProgressHandler = (agentId: string, event: ACPProgressEvent) => void;
 /**
  * Per-agent outcome from an ensemble run.
  * `status === 'skipped'` carries a `reason`; the other statuses carry
@@ -469,11 +347,25 @@ interface EnsembleRunnerOptions {
      * `SubagentRunContext.signal` they receive.
      */
     signal?: AbortSignal | undefined;
+    /**
+     * Live progress callback. Invoked for every streamed update from every
+     * agent, tagged with the agent id so the caller can render interleaved
+     * progress (e.g. `[gemini-cli] edit foo.ts`).
+     */
+    onProgress?: EnsembleProgressHandler | undefined;
+    /**
+     * Maximum number of agents to launch concurrently. Defaults to
+     * `DEFAULT_MAX_CONCURRENCY` (4). Set to 1 for serial execution;
+     * values larger than the runnable count are clamped down. Bounded
+     * fan-out keeps simultaneous ACP subprocess / WebSocket counts
+     * manageable when an ensemble has many members.
+     */
+    maxConcurrency?: number | undefined;
 }
 /**
- * Default command resolver. Checks the legacy `ACP_AGENT_COMMANDS` map
- * first, then falls back to the 12-entry catalog. Returns `null` for
- * ids that aren't in either source.
+ * Default command resolver — delegates to `resolveAcpAgentCommand`, so the
+ * catalog's corrected invocations win over the stale legacy map (the legacy
+ * map is now only a last-resort fallback). Returns `null` for unknown ids.
  */
 declare const defaultEnsembleCmdResolver: EnsembleCmdResolver;
 /**
@@ -496,4 +388,71 @@ declare function runEnsemble(opts: EnsembleRunnerOptions): Promise<EnsembleResul
  */
 declare function renderEnsembleText(result: EnsembleResult): string;
 
-export { type ACPAgentDescriptor, type ACPAgentVendor, type ACPIntegration, ACPSession, ACPSessionError, type ACPSessionErrorKind, type ACPSessionOptions, type ACPSessionRunResult, ACPSubagentRunnerOptions, AGENTS_CATALOG, type DetectedAgent, type EnsembleAgentResult, type EnsembleCmdResolver, EnsembleRegistry, type EnsembleRegistryOptions, type EnsembleResult, type EnsembleRunnerOptions, FileServer, type FileServerOptions, FsError, type FsErrorCode, type PermissionPolicy, type PermissionRequest, type ReadFileParams, TerminalServer, type TerminalServerOptions, type WriteFileParams, defaultEnsembleCmdResolver, defaultPermissionPolicy, findAgentDescriptor, renderEnsembleText, runEnsemble };
+type AcpBenchStatus = 'pass' | 'partial' | 'fail' | 'skipped';
+interface AcpBenchCheck {
+    name: 'handshake' | 'prompt' | 'marker' | 'fs';
+    ok: boolean;
+    detail?: string | undefined;
+}
+interface AcpBenchAgentResult {
+    agentId: string;
+    status: AcpBenchStatus;
+    checks: AcpBenchCheck[];
+    /** Agent metadata from the initialize handshake. */
+    agentInfo?: {
+        name: string;
+        title?: string | undefined;
+        version: string;
+    } | undefined;
+    handshakeMs?: number | undefined;
+    promptMs?: number | undefined;
+    /** First line of the agent's reply (trimmed), for the report. */
+    sample?: string | undefined;
+    /** Why the agent failed / was skipped. */
+    reason?: string | undefined;
+    durationMs: number;
+}
+interface AcpBenchResult {
+    results: AcpBenchAgentResult[];
+    summary: {
+        pass: number;
+        partial: number;
+        fail: number;
+        skipped: number;
+    };
+    totalDurationMs: number;
+}
+/** Resolve an agent id to its spawn command (null = unknown). */
+type AcpBenchCmdResolver = (id: string) => ACPSubagentRunnerOptions | null;
+interface AcpBenchOptions {
+    /** Agent ids to bench. */
+    agentIds: string[];
+    /** Resolve each id → spawn command (wire overrides + synced registry here). */
+    resolveCmd: AcpBenchCmdResolver;
+    /** FS sandbox + cwd for each agent. Defaults to `process.cwd()`. */
+    projectRoot?: string | undefined;
+    /** Per-agent hard timeout (handshake + each prompt). Default 60s. */
+    timeoutMs?: number | undefined;
+    /** Also verify the `fs/read_text_file` callback channel. Default false. */
+    checkFs?: boolean | undefined;
+    /** Max agents benched concurrently. Default 2 (each runs a real LLM turn). */
+    concurrency?: number | undefined;
+    /** Cancellation. Aborts the in-flight agent and skips the rest. */
+    signal?: AbortSignal | undefined;
+    /** Live per-agent status callback for the UI. */
+    onProgress?: ((agentId: string, phase: 'start' | 'done', result?: AcpBenchAgentResult) => void) | undefined;
+    /** Marker token override (tests). Default is a random per-run token. */
+    marker?: string | undefined;
+    /** Clock injection (tests). Defaults to `Date.now`. */
+    now?: (() => number) | undefined;
+}
+/**
+ * Bench a set of ACP agents end-to-end and return a graded report. Unknown
+ * ids are reported `skipped`. Bounded concurrency keeps the number of live
+ * ACP subprocesses (each running a real model turn) manageable.
+ */
+declare function runAcpBench(opts: AcpBenchOptions): Promise<AcpBenchResult>;
+/** Render an `AcpBenchResult` as a plain-text report. */
+declare function renderAcpBenchText(result: AcpBenchResult): string;
+
+export { type ACPAgentDescriptor, type ACPAgentVendor, type ACPIntegration, ACPProgressEvent, ACPSubagentRunnerOptions, ACP_REGISTRY_URL, AGENTS_CATALOG, type AcpBenchAgentResult, type AcpBenchCheck, type AcpBenchCmdResolver, type AcpBenchOptions, type AcpBenchResult, type AcpBenchStatus, type DetectedAgent, type EnsembleAgentResult, type EnsembleCmdResolver, type EnsembleProgressHandler, EnsembleRegistry, type EnsembleRegistryOptions, type EnsembleResult, type EnsembleRunnerOptions, type FetchAcpRegistryOptions, type FetchAcpRegistryResult, type RegistryAgentEntry, currentPlatformKey, defaultEnsembleCmdResolver, fetchAcpRegistry, findAgentDescriptor, mapRegistryEntry, renderAcpBenchText, renderEnsembleText, runAcpBench, runEnsemble };