@wrongstack/acp 1.0.3 → 1.0.5

package/dist/agent/index.d.ts

@@ -1,4 +1,4 @@
-export type { ClientCapabilities, RunTurn, RunTurnApi, RunTurnInput, RunTurnPermissionRequest, RunTurnResult, SessionPersistence, } from './protocol-handler.js';
+export type { ClientCapabilities, McpServer, RunTurn, RunTurnApi, RunTurnInput, RunTurnPermissionRequest, RunTurnResult, SessionPersistence, } from './protocol-handler.js';
 export { ACPProtocolHandler } from './protocol-handler.js';
 export type { ACPServerAgentTurnOptions } from './server-agent-turn.js';
 export { makeACPServerAgentTurn } from './server-agent-turn.js';

package/dist/agent/protocol-contract.d.ts

@@ -3,9 +3,9 @@
  * Keeping these declarations separate leaves the handler focused on request dispatch.
  */
 import type { ACPMessage } from '../types/acp-messages.js';
-import { ACP_PROTOCOL_VERSION, type ContentBlock, type PermissionOption, type PlanEntry, type RequestPermissionOutcome, type StopReason, type ToolKind, type UsageCost } from '../types/acp-v1.js';
+import { ACP_PROTOCOL_VERSION, type ContentBlock, type McpServer, type PermissionOption, type PlanEntry, type RequestPermissionOutcome, type StopReason, type ToolKind, type UsageCost } from '../types/acp-v1.js';
 import type { AgentServerTransport } from './stdio-transport.js';
-export type { ACPMessage, ContentBlock, RequestPermissionOutcome };
+export type { ACPMessage, ContentBlock, McpServer, RequestPermissionOutcome };
 export { ACP_PROTOCOL_VERSION };
 type WireMessage = {
     jsonrpc?: '2.0';
@@ -33,6 +33,19 @@ export interface RunTurnInput {
     prompt: readonly ContentBlock[];
     /** Cancelled when the client sends `session/cancel` for this session. */
     signal: AbortSignal;
+    /** Session working directory from `session/new` (absolute). */
+    cwd?: string | undefined;
+    /**
+     * MCP servers the CLIENT asked this session to connect to, as supplied in
+     * `session/new` / `session/load` / `session/fork`. Validated at the wire
+     * boundary (see `parseMcpServers`), so entries here are well-formed.
+     *
+     * The runTurn implementation owns the connection: it is what holds the tool
+     * registry these servers' tools must land in. Nothing here is optional
+     * decoration — an editor that passes a server and gets no tools has been
+     * told a successful `session/new` about work that never happened.
+     */
+    mcpServers?: readonly McpServer[] | undefined;
 }
 export interface RunTurnResult {
     stopReason: StopReason;
@@ -127,6 +140,13 @@ export interface SessionState {
     updatedAt: string;
     /** Optional human title. */
     title?: string;
+    /**
+     * The client's MCP servers for this session, captured at `session/new`
+     * (or `load`/`fork`) and replayed into every turn. Held on the session
+     * because the connection is session-scoped: two ACP sessions may ask for
+     * different servers, and closing one must not tear down the other's.
+     */
+    mcpServers?: readonly McpServer[] | undefined;
 }
 /** MCP-style session mode advertised in current_mode_update. */
 export interface SessionMode {

package/dist/agent/protocol-handler.d.ts

@@ -1,6 +1,6 @@
 import { type ProtocolHandlerOptions, WRONGSTACK_VERSION } from './protocol-contract.js';
 import { errorToJsonRpc } from './protocol-session-ops.js';
-export type { AgentCapabilities, ClientCapabilities, PromptCapabilities, ProtocolHandlerOptions, RunTurn, RunTurnApi, RunTurnInput, RunTurnPermissionRequest, RunTurnResult, SessionConfigOption, SessionMode, SessionPersistence, SessionState, } from './protocol-contract.js';
+export type { AgentCapabilities, ClientCapabilities, McpServer, PromptCapabilities, ProtocolHandlerOptions, RunTurn, RunTurnApi, RunTurnInput, RunTurnPermissionRequest, RunTurnResult, SessionConfigOption, SessionMode, SessionPersistence, SessionState, } from './protocol-contract.js';
 export { WRONGSTACK_VERSION };
 export declare class ACPProtocolHandler {
     private readonly transport;

package/dist/agent/protocol-session-ops.d.ts

@@ -1,8 +1,19 @@
-import { type ClientCapabilities, type RunTurnApi, type SessionConfigOption, type SessionMode } from './protocol-contract.js';
+import { type ClientCapabilities, type McpServer, type RunTurnApi, type SessionConfigOption, type SessionMode } from './protocol-contract.js';
 /** Single global mode id, sufficient for v1. */
 export declare const DEFAULT_MODE_ID = "code";
 export declare const DEFAULT_MAX_SESSIONS = 64;
 export declare const DEFAULT_MODES: readonly SessionMode[];
+/**
+ * Validate the `mcpServers` array a client sends with `session/new`,
+ * `session/load` or `session/fork`.
+ *
+ * Malformed entries are dropped rather than rejecting the whole request: an
+ * editor that ships one bad server config should still get a working session.
+ * A dropped entry is reported through `onSkipped` so the caller can tell the
+ * client instead of silently discarding what it asked for — silent discard is
+ * exactly how this array came to be ignored in the first place.
+ */
+export declare function parseMcpServers(raw: unknown, onSkipped?: (reason: string) => void): McpServer[];
 export declare function resolveSessionCwd(requested: string): Promise<string | null>;
 export declare function errorToJsonRpc(err: unknown): {
     code: number;

package/dist/agent/server-agent-turn.d.ts

@@ -39,7 +39,7 @@
  * `{stopReason: 'cancelled'}`.
  */
 import type { Agent, AgentInput } from '@wrongstack/core/agent';
-import type { ContentBlock, PlanEntry, StopReason, ToolKind, UsageCost } from '../types/acp-v1.js';
+import type { ContentBlock, McpServer, PlanEntry, StopReason, ToolKind, UsageCost } from '../types/acp-v1.js';
 import type { RunTurn, RunTurnApi, RunTurnResult } from './protocol-handler.js';
 export interface ACPServerAgentTurnOptions {
     /**
@@ -53,8 +53,12 @@ export interface ACPServerAgentTurnOptions {
      * advertises those capabilities. A factory that wires it builds a
      * client-backed permission policy and ACP-backed fs/terminal tools
      * instead of silently auto-approving against the local disk.
+     *
+     * `mcpServers` is the client's per-session MCP server list from
+     * `session/new`. The factory owns the session's tool registry, so it is the
+     * only place those servers can be connected and their tools registered.
      */
-    agentFor: (sessionId: string, cwd: string, api?: RunTurnApi) => Promise<Agent> | Agent;
+    agentFor: (sessionId: string, cwd: string, api?: RunTurnApi, mcpServers?: readonly McpServer[]) => Promise<Agent> | Agent;
     /**
      * Hard wall-clock cap for one turn. The agent's own provider
      * timeout is layered under this; this cap is a safety belt.

package/dist/agent.js

@@ -46,6 +46,64 @@ var DEFAULT_MODES = [
     description: "Default agent mode for code-generation tasks."
   }
 ];
+function parseMcpServers(raw, onSkipped) {
+  if (!Array.isArray(raw)) return [];
+  const out = [];
+  for (const entry of raw) {
+    if (typeof entry !== "object" || entry === null) {
+      onSkipped?.("entry is not an object");
+      continue;
+    }
+    const e = entry;
+    const name = typeof e.name === "string" ? e.name.trim() : "";
+    if (name === "") {
+      onSkipped?.("entry has no name");
+      continue;
+    }
+    const type = typeof e.type === "string" ? e.type : "stdio";
+    if (type === "http" || type === "sse") {
+      if (typeof e.url !== "string" || e.url === "") {
+        onSkipped?.(`"${name}": ${type} server has no url`);
+        continue;
+      }
+      const headers = parseNameValuePairs(e.headers);
+      const url = e.url;
+      out.push(
+        type === "http" ? { type: "http", name, url, ...headers ? { headers } : {} } : { type: "sse", name, url, ...headers ? { headers } : {} }
+      );
+      continue;
+    }
+    if (type !== "stdio") {
+      onSkipped?.(`"${name}": unknown transport "${type}"`);
+      continue;
+    }
+    if (typeof e.command !== "string" || e.command === "") {
+      onSkipped?.(`"${name}": stdio server has no command`);
+      continue;
+    }
+    const args = Array.isArray(e.args) ? e.args.filter((a) => typeof a === "string") : void 0;
+    const env = parseNameValuePairs(e.env);
+    out.push({
+      name,
+      command: e.command,
+      ...args && args.length > 0 ? { args } : {},
+      ...env ? { env } : {}
+    });
+  }
+  return out;
+}
+function parseNameValuePairs(raw) {
+  if (!Array.isArray(raw)) return void 0;
+  const out = [];
+  for (const pair of raw) {
+    if (typeof pair !== "object" || pair === null) continue;
+    const p = pair;
+    if (typeof p.name === "string" && p.name !== "" && typeof p.value === "string") {
+      out.push({ name: p.name, value: p.value });
+    }
+  }
+  return out.length > 0 ? out : void 0;
+}
 async function resolveSessionCwd(requested) {
   if (!path.isAbsolute(requested)) return null;
   const resolved = path.resolve(requested);
@@ -128,9 +186,16 @@ function buildInitializeResult(agentName, modes, configOptions) {
         audio: false,
         embeddedContext: true
       },
+      // All three ACP transports are supported. stdio is mandatory per spec
+      // and cannot be declined; http and sse are declared here because the
+      // agent now actually connects them (see `parseMcpServers` above and the
+      // per-session MCP registry in `buildAcpServerAgentFactory`). Before that
+      // wiring existed the array was destructured and thrown away at every
+      // entry point, so a client got a successful `session/new` and no tools —
+      // flip these back to false if that connection path is ever removed.
       mcpCapabilities: {
-        http: false,
-        sse: false
+        http: true,
+        sse: true
       },
       sessionCapabilities: {
         close: {},
@@ -170,6 +235,8 @@ async function handleSessionNewOp(ctx, id, params) {
     }
     cwd = resolved;
   }
+  const skipped = [];
+  const mcpServers = parseMcpServers(p.mcpServers, (reason) => skipped.push(reason));
   const sessionId = `sess_${ctx.allocId()}`;
   const now = (/* @__PURE__ */ new Date()).toISOString();
   const state = {
@@ -178,7 +245,8 @@ async function handleSessionNewOp(ctx, id, params) {
     abort: new AbortController(),
     modeId: DEFAULT_MODE_ID,
     createdAt: now,
-    updatedAt: now
+    updatedAt: now,
+    ...mcpServers.length > 0 ? { mcpServers } : {}
   };
   ctx.sessions.set(sessionId, state);
   ctx.onSessionNew(state);
@@ -199,6 +267,7 @@ async function handleSessionNewOp(ctx, id, params) {
       }
     });
   }
+  await reportSkippedMcpServers(ctx, sessionId, skipped);
   await ctx.sendResult(id, {
     sessionId,
     modes: ctx.modes,
@@ -210,6 +279,8 @@ async function handleSessionLoadOp(ctx, id, params) {
   const p = params ?? {};
   const sessionId = typeof p.sessionId === "string" ? p.sessionId : null;
   const loadCwd = typeof p.cwd === "string" ? p.cwd : void 0;
+  const loadSkipped = [];
+  const loadMcpServers = parseMcpServers(p.mcpServers, (reason) => loadSkipped.push(reason));
   const existing = sessionId ? ctx.sessions.get(sessionId) : void 0;
   if (!existing && sessionId && ctx.store) {
     const persisted = await ctx.store.load(sessionId);
@@ -231,7 +302,8 @@ async function handleSessionLoadOp(ctx, id, params) {
         modeId: persisted.modeId ?? DEFAULT_MODE_ID,
         createdAt: persisted.createdAt ?? (/* @__PURE__ */ new Date()).toISOString(),
         updatedAt: (/* @__PURE__ */ new Date()).toISOString(),
-        ...persisted.title !== void 0 ? { title: persisted.title } : {}
+        ...persisted.title !== void 0 ? { title: persisted.title } : {},
+        ...loadMcpServers.length > 0 ? { mcpServers: loadMcpServers } : {}
       };
       ctx.sessions.set(sessionId, restored);
       ctx.seedFor?.(sessionId, persisted.history ?? []);
@@ -242,6 +314,7 @@ async function handleSessionLoadOp(ctx, id, params) {
         sessionId,
         update: { sessionUpdate: "current_mode_update", modeId: restored.modeId }
       });
+      await reportSkippedMcpServers(ctx, sessionId, loadSkipped);
       await ctx.sendResult(id, {
         initialMode: { currentModeId: restored.modeId, availableModes: ctx.modes }
       });
@@ -250,6 +323,9 @@ async function handleSessionLoadOp(ctx, id, params) {
   }
   if (existing) {
     existing.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
+    if (loadMcpServers.length > 0) {
+      existing.mcpServers = loadMcpServers;
+    }
     const replay = ctx.replayFor?.(sessionId);
     if (replay) {
       for (const update of replay) {
@@ -270,6 +346,7 @@ async function handleSessionLoadOp(ctx, id, params) {
         modeId: existing.modeId
       }
     });
+    await reportSkippedMcpServers(ctx, sessionId, loadSkipped);
     await ctx.sendResult(id, {
       initialMode: {
         currentModeId: existing.modeId,
@@ -302,6 +379,9 @@ async function handleSessionForkOp(ctx, id, params) {
     }
     forkCwd = resolved;
   }
+  const forkSkipped = [];
+  const forkRequested = parseMcpServers(p.mcpServers, (reason) => forkSkipped.push(reason));
+  const forkMcpServers = forkRequested.length > 0 ? forkRequested : source.mcpServers;
   const now = (/* @__PURE__ */ new Date()).toISOString();
   const sessionId = `sess_${ctx.allocId()}`;
   const forked = {
@@ -311,7 +391,8 @@ async function handleSessionForkOp(ctx, id, params) {
     modeId: source.modeId,
     createdAt: now,
     updatedAt: now,
-    ...source.title !== void 0 ? { title: source.title } : {}
+    ...source.title !== void 0 ? { title: source.title } : {},
+    ...forkMcpServers && forkMcpServers.length > 0 ? { mcpServers: forkMcpServers } : {}
   };
   const history = (ctx.replayFor?.(sourceId) ?? []).map((update) => ({
     sessionUpdate: update.sessionUpdate,
@@ -325,6 +406,7 @@ async function handleSessionForkOp(ctx, id, params) {
     sessionId,
     update: { sessionUpdate: "current_mode_update", modeId: forked.modeId }
   });
+  await reportSkippedMcpServers(ctx, sessionId, forkSkipped);
   await ctx.sendResult(id, {
     sessionId,
     modes: ctx.modes,
@@ -364,7 +446,13 @@ async function handleSessionPromptOp(ctx, id, params) {
   };
   try {
     result = await ctx.runTurn(
-      { sessionId, prompt: p.prompt, signal: turnSignal.signal },
+      {
+        sessionId,
+        prompt: p.prompt,
+        signal: turnSignal.signal,
+        cwd: session.cwd,
+        ...session.mcpServers ? { mcpServers: session.mcpServers } : {}
+      },
       emit,
       api
     );
@@ -422,6 +510,22 @@ async function handleSetConfigOptionOp(ctx, id, params) {
   await ctx.sendResult(id, { configOptions: [...ctx.configOptions] });
   return false;
 }
+async function reportSkippedMcpServers(ctx, sessionId, skipped) {
+  if (skipped.length === 0) return;
+  try {
+    await ctx.sendNotification({
+      sessionId,
+      update: {
+        sessionUpdate: "agent_message_chunk",
+        content: {
+          type: "text",
+          text: `Ignored ${skipped.length} malformed mcpServers entr${skipped.length === 1 ? "y" : "ies"}: ${skipped.join("; ")}`
+        }
+      }
+    });
+  } catch {
+  }
+}
 
 // src/agent/protocol-handler.ts
 var ACPProtocolHandler = class {
@@ -620,7 +724,7 @@ var ACPProtocolHandler = class {
     return false;
   }
   async handleAuthenticate(id, _params) {
-    await this.sendResult(id, { outcome: "unauthenticated" });
+    await this.sendResult(id, {});
     return false;
   }
   async handleLogout(id, _params) {
@@ -633,6 +737,10 @@ var ACPProtocolHandler = class {
     const existing = sessionId ? this.sessions.get(sessionId) : void 0;
     if (existing) {
       existing.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
+      const resumeServers = parseMcpServers(p.mcpServers);
+      if (resumeServers.length > 0) {
+        existing.mcpServers = resumeServers;
+      }
       await this.sendResult(id, {
         initialMode: {
           currentModeId: existing.modeId,
@@ -775,7 +883,12 @@ function makeACPServerAgentTurn(opts) {
   const turn = async (input, emit, api) => {
     let agent = agents.get(input.sessionId);
     if (!agent) {
-      agent = await opts.agentFor(input.sessionId, process.cwd(), api);
+      agent = await opts.agentFor(
+        input.sessionId,
+        input.cwd ?? process.cwd(),
+        api,
+        input.mcpServers
+      );
       agents.set(input.sessionId, agent);
       if (pendingSeed.has(input.sessionId)) {
         pendingSeed.delete(input.sessionId);
@@ -1618,11 +1731,11 @@ function toolToPriority(tool) {
 }
 
 // src/agent/wrongstack-acp-agent.ts
-import { timingSafeEqual } from "node:crypto";
 import { createServer } from "node:http";
 import { isIP } from "node:net";
 import { fileURLToPath } from "node:url";
 import { expandIPv6, writeErr as writeErr2 } from "@wrongstack/core/utils";
+import { timingSafeTokenEqual } from "@wrongstack/primitives";
 var LISTEN_RETRY_LIMIT = 5;
 var LISTEN_RETRY_BASE_MS = 25;
 var WrongStackACPServer = class {
@@ -1856,13 +1969,6 @@ var WrongStackACPServer = class {
 var defaultEchoRunTurn = async (_input, _emit) => {
   return { stopReason: "end_turn" };
 };
-function timingSafeTokenEqual(supplied, expected) {
-  if (!supplied || !expected) return false;
-  const a = Buffer.from(supplied);
-  const b = Buffer.from(expected);
-  if (a.length !== b.length) return false;
-  return timingSafeEqual(a, b);
-}
 function isLoopbackPeer(req) {
   const address = req.socket.remoteAddress?.replace(/^::ffff:/i, "");
   return address !== void 0 && isLoopbackHost(address);

package/dist/client/acp-session-errors.d.ts

@@ -10,5 +10,11 @@ interface JsonRpcError {
     data?: unknown;
 }
 export declare function isJsonRpcError(v: unknown): v is JsonRpcError;
+/**
+ * True when an agent refused `session/new` (or similar) because the user
+ * must authenticate first. Official registry agents often return this
+ * (~19/31 in the 2026-09 protocol matrix) instead of creating a session.
+ */
+export declare function isAuthRequiredError(err: unknown): boolean;
 export {};
 //# sourceMappingURL=acp-session-errors.d.ts.map

package/dist/client/acp-session.d.ts

@@ -107,6 +107,18 @@ export declare class ACPSession {
     close(): Promise<void>;
     private allocId;
     private sendRequest;
+    /**
+     * `session/new`, then one authenticate+retry if the agent demands login.
+     * Logged-in CLIs succeed on the first call even when they advertise
+     * `authMethods`; we do not pop OAuth on every spawn.
+     */
+    private createSessionWithAuth;
+    /**
+     * Pick a non-terminal auth method and run `authenticate`. Terminal-only
+     * agents need an out-of-band login CLI (registry AUTHENTICATION.md) —
+     * we refuse rather than hang a TUI inside the JSON-RPC child.
+     */
+    private ensureAuthenticated;
     private sendResult;
     private sendErrorResponse;
     private responseSender;

package/dist/client.js

@@ -254,6 +254,21 @@ function verbatimOptions(invocation) {
 // src/types/acp-v1.ts
 var ACP_PROTOCOL_VERSION = 1;
 
+// src/version.ts
+import { createRequire } from "node:module";
+var require2 = createRequire(import.meta.url);
+function readPackageVersion(load = () => require2("../package.json")) {
+  try {
+    const packageJson = load();
+    if (typeof packageJson.version === "string" && packageJson.version.length > 0) {
+      return packageJson.version;
+    }
+  } catch {
+  }
+  return "dev";
+}
+var ACP_PACKAGE_VERSION = readPackageVersion();
+
 // src/client/acp-message-routing.ts
 function isBestEffortAckMethod(method) {
   return method === "mcp/connect" || method === "mcp/message" || method === "mcp/disconnect" || method === "elicitation/create" || method === "elicitation/complete";
@@ -728,6 +743,20 @@ var ACPSessionError = class extends Error {
 function isJsonRpcError(v) {
   return typeof v === "object" && v !== null && typeof v.code === "number" && typeof v.message === "string";
 }
+function isAuthRequiredError(err) {
+  const message = err instanceof Error ? err.message : String(err);
+  if (/auth(_|-)?required|authentication required/i.test(message)) return true;
+  const cause = err instanceof ACPSessionError ? err.cause : err && typeof err === "object" && "cause" in err ? err.cause : err;
+  if (!cause || typeof cause !== "object") return false;
+  const data = cause.data;
+  if (data === "auth_required" || data === "AUTH_REQUIRED") return true;
+  if (data && typeof data === "object") {
+    const d = data;
+    if (d.authRequired === true) return true;
+    if (d.code === "auth_required" || d.code === "AUTH_REQUIRED") return true;
+  }
+  return false;
+}
 
 // src/client/acp-session-ops.ts
 function filterMcpServers(agentCapabilities, servers) {
@@ -1772,7 +1801,7 @@ var ACPSession = class _ACPSession {
         fs: { readTextFile: true, writeTextFile: true },
         terminal: true
       },
-      clientInfo: { name: "wrongstack", title: "WrongStack", version: "0.287.0" }
+      clientInfo: { name: "wrongstack", title: "WrongStack", version: ACP_PACKAGE_VERSION }
     });
     if (isJsonRpcError(result)) {
       throw new ACPSessionError("init_failed", `initialize failed: ${result.message}`, result);
@@ -1804,12 +1833,13 @@ var ACPSession = class _ACPSession {
     if (this.state === "closed") {
       throw new ACPSessionError("closed", "session is closed");
     }
-    if (this.state !== "ready") {
+    if (this.state !== "ready" && this.state !== "authenticated") {
       throw new ACPSessionError(
         "protocol_error",
         `authenticate called in state=${this.state} (expected 'ready')`
       );
     }
+    if (this.state === "authenticated") return;
     if (!this.authMethods.some((m) => m.id === methodId)) {
       throw new ACPSessionError(
         "auth_failed",
@@ -1912,7 +1942,7 @@ var ACPSession = class _ACPSession {
       return emptyRunResult("cancelled");
     }
     if (!this.sessionId) {
-      this.sessionId = await executeCreateSession(this.opContext());
+      this.sessionId = await this.createSessionWithAuth();
     }
     if (signal.aborted) {
       return emptyRunResult("cancelled");
@@ -2048,6 +2078,54 @@ var ACPSession = class _ACPSession {
       });
     });
   }
+  /**
+   * `session/new`, then one authenticate+retry if the agent demands login.
+   * Logged-in CLIs succeed on the first call even when they advertise
+   * `authMethods`; we do not pop OAuth on every spawn.
+   */
+  async createSessionWithAuth() {
+    try {
+      return await executeCreateSession(this.opContext());
+    } catch (err) {
+      if (this.state === "authenticated" || !isAuthRequiredError(err)) {
+        throw err instanceof ACPSessionError ? err : new ACPSessionError(
+          "session_create_failed",
+          err instanceof Error ? err.message : String(err),
+          err
+        );
+      }
+      await this.ensureAuthenticated();
+      return executeCreateSession(this.opContext());
+    }
+  }
+  /**
+   * Pick a non-terminal auth method and run `authenticate`. Terminal-only
+   * agents need an out-of-band login CLI (registry AUTHENTICATION.md) —
+   * we refuse rather than hang a TUI inside the JSON-RPC child.
+   */
+  async ensureAuthenticated() {
+    if (this.state === "authenticated") return;
+    if (this.authMethods.length === 0) {
+      throw new ACPSessionError(
+        "auth_failed",
+        "This agent requires authentication before a session can start, but advertised no authMethods. Log into the CLI, then retry."
+      );
+    }
+    const inProcess = this.authMethods.find(
+      (m) => m.type === void 0 || m.type === "agent" || m.type === "oauth" || m.type === "http"
+    );
+    if (inProcess) {
+      await this.authenticate(inProcess.id);
+      return;
+    }
+    const terminal = this.authMethods.find((m) => m.type === "terminal");
+    const setupArgs = terminal?.args?.length ? terminal.args.join(" ") : void 0;
+    const setup = setupArgs !== void 0 ? `${this.opts.command} ${setupArgs}` : `${this.opts.command}${this.opts.args?.length ? ` ${this.opts.args.join(" ")}` : ""}`;
+    throw new ACPSessionError(
+      "auth_failed",
+      `This agent requires a terminal login before ACP can start. Run \`${setup}\` (or the CLI's /login), then retry.`
+    );
+  }
   sendResult(id, result) {
     return this.transport.send({ jsonrpc: "2.0", id, result });
   }
@@ -2076,7 +2154,11 @@ var ACPSession = class _ACPSession {
       clearTimeout(pending.timeoutHandle);
       this.pending.delete(msg.id);
       if (msg.error !== void 0) {
-        pending.reject(new Error(msg.error.message ?? "unknown JSON-RPC error"));
+        const method = pending.method;
+        const kind = method === "session/new" ? "session_create_failed" : method === "authenticate" ? "auth_failed" : "protocol_error";
+        pending.reject(
+          new ACPSessionError(kind, msg.error.message ?? "unknown JSON-RPC error", msg.error)
+        );
       } else {
         pending.resolve(msg.result);
       }
@@ -2198,6 +2280,10 @@ async function makeACPSubagentRunnerWithStop(options) {
       } catch {
       }
       options.onProgress?.(event);
+      try {
+        options.publishLive?.(ctx, task, event);
+      } catch {
+      }
     };
     try {
       const result = await session.prompt([textContent(task.description)], ctx.signal, onProgress);