@wrongstack/cli 1.0.3 → 1.0.4

package/dist/{acp-JK4ZQO3R.js → acp-AB54FWM2.js}

@@ -1,9 +1,10 @@
 import {
   createGracefulShutdown,
+  formatAcpAgentList,
   loadCachedAcpRegistry,
   refreshAcpRegistry,
   setupProvider
-} from "./chunk-GMY45LO6.js";
+} from "./chunk-KEPABQYT.js";
 import {
   startCliHqConnection
 } from "./chunk-TE3Q32JP.js";
@@ -89,14 +90,15 @@ function startAcpHqTelemetry(options) {
   };
   return {
     wrapAgentFactory(agentFor) {
-      const wrapped = async (sessionId, cwd, api) => {
-        const agent = await agentFor(sessionId, cwd, api);
+      const wrapped = async (sessionId, cwd, ...rest) => {
+        const agent = await agentFor(sessionId, cwd, ...rest);
         try {
           attach(sessionId, agent, cwd);
         } catch {
         }
         return agent;
       };
+      Object.assign(wrapped, agentFor);
       return wrapped;
     },
     wrapDispose(dispose) {
@@ -120,7 +122,6 @@ function startAcpHqTelemetry(options) {
 // src/acp-server-agent.ts
 import { Agent, Context, createDefaultPipelines } from "@wrongstack/core/agent";
 import { ToolExecutor } from "@wrongstack/core/execution";
-import { wireKanbanPorts } from "@wrongstack/runtime";
 import { DefaultLogger, DefaultTokenCounter } from "@wrongstack/core/infrastructure";
 import { EventBus, TOKENS } from "@wrongstack/core/kernel";
 import { ToolRegistry } from "@wrongstack/core/registry";
@@ -128,7 +129,65 @@ import { AutoApprovePermissionPolicy, ToolCapabilities } from "@wrongstack/core/
 import {
   ToolValidationError
 } from "@wrongstack/core/types";
-import { createDefaultContainer } from "@wrongstack/runtime";
+import { createDefaultContainer, wireKanbanPorts } from "@wrongstack/runtime";
+
+// src/acp-mcp-servers.ts
+import { MCPRegistry } from "@wrongstack/mcp";
+function pairsToRecord(pairs) {
+  if (!pairs || pairs.length === 0) return void 0;
+  const out = {};
+  for (const { name, value } of pairs) out[name] = value;
+  return out;
+}
+function acpMcpServerToConfig(server) {
+  const type = "type" in server ? server.type : "stdio";
+  if (type === "http" || type === "sse") {
+    const headers = pairsToRecord(
+      server.headers
+    );
+    return {
+      name: server.name,
+      transport: type === "http" ? "streamable-http" : "sse",
+      url: server.url,
+      ...headers ? { headers } : {},
+      description: "Supplied by the ACP client for this session."
+    };
+  }
+  const stdio = server;
+  const env = pairsToRecord(server.env);
+  return {
+    name: server.name,
+    transport: "stdio",
+    command: stdio.command,
+    ...stdio.args && stdio.args.length > 0 ? { args: [...stdio.args] } : {},
+    ...env ? { env } : {},
+    description: "Supplied by the ACP client for this session."
+  };
+}
+async function connectAcpSessionMcpServers(opts) {
+  if (opts.servers.length === 0) return void 0;
+  const registry = new MCPRegistry({
+    toolRegistry: opts.toolRegistry,
+    events: opts.events,
+    log: opts.logger,
+    // Eager, not lazy: the tool list has to be complete before the session's
+    // Context snapshots `listForProvider()`, which happens immediately below
+    // this call. A lazily registered tool would exist in the registry but be
+    // absent from the very first turn's provider payload.
+    lazyMode: false,
+    ...opts.cacheDir ? { cacheDir: opts.cacheDir } : {}
+  });
+  for (const server of opts.servers) {
+    try {
+      await registry.start(acpMcpServerToConfig(server));
+    } catch (err) {
+      opts.logger.warn(`ACP client MCP server "${server.name}" failed to start`, err);
+    }
+  }
+  return registry;
+}
+
+// src/acp-server-agent.ts
 var AcpServerConfigError = class extends Error {
   constructor(message) {
     super(message);
@@ -311,7 +370,8 @@ function buildAcpServerAgentFactory(deps, options = {}) {
     logger,
     modelsRegistry: deps.modelsRegistry
   });
-  return async function agentFor(_sessionId, cwd, api) {
+  const sessionMcp = /* @__PURE__ */ new Map();
+  const agentFor = async function agentFor2(sessionId, cwd, api, mcpServers) {
     await container.resolve(TOKENS.MemoryStore).initialize();
     const { provider, providerRegistry } = await bootProvider();
     const events = new EventBus();
@@ -321,6 +381,19 @@ function buildAcpServerAgentFactory(deps, options = {}) {
     if (api) {
       wireClientBackedTools(tools, api);
     }
+    if (mcpServers && mcpServers.length > 0) {
+      const previous = sessionMcp.get(sessionId);
+      if (previous) void previous.stopAll().catch(() => {
+      });
+      const mcp = await connectAcpSessionMcpServers({
+        servers: mcpServers,
+        toolRegistry: tools,
+        events,
+        logger,
+        ...wpaths.cacheDir ? { cacheDir: wpaths.cacheDir } : {}
+      });
+      if (mcp) sessionMcp.set(sessionId, mcp);
+    }
     const permissionPolicy = api?.requestPermission ? new ACPClientPermissionPolicy(api.requestPermission) : new AutoApprovePermissionPolicy();
     const tokenCounter = new DefaultTokenCounter({
       registry: deps.modelsRegistry,
@@ -366,9 +439,25 @@ function buildAcpServerAgentFactory(deps, options = {}) {
       context,
       permissionPolicy,
       toolExecutor,
-      loopDetection: config.tools?.loopDetection
+      loopDetection: config.tools?.loopDetection,
+      // `tools.maxIterations` was never read on this host, so an operator who
+      // set a turn budget got it honoured on the CLI and WebUI hosts and
+      // silently ignored here. Only a POSITIVE value is forwarded: the shipped
+      // default is `0` ("no hard limit"), and handing that to the agent loop
+      // would trade a missing setting for a missing safety net. Absent an
+      // explicit budget the Agent keeps its own DEFAULT_MAX_ITERATIONS.
+      ...typeof config.tools?.maxIterations === "number" && Number.isFinite(config.tools.maxIterations) && config.tools.maxIterations > 0 ? { maxIterations: config.tools.maxIterations } : {}
     });
   };
+  agentFor.disposeSession = (sessionId) => {
+    const mcp = sessionMcp.get(sessionId);
+    if (!mcp) return;
+    sessionMcp.delete(sessionId);
+    void mcp.stopAll().catch((err) => {
+      logger.warn(`ACP session ${sessionId}: MCP teardown failed`, err);
+    });
+  };
+  return agentFor;
 }
 
 // src/subcommands/handlers/acp-connection-gate.ts
@@ -516,10 +605,20 @@ function parseWsPort(flag) {
   const n = Number(flag);
   return Number.isInteger(n) && n > 0 && n < 65536 ? n : 8889;
 }
+function composeDispose(disposeTurn, factory) {
+  return (sessionId) => {
+    try {
+      disposeTurn(sessionId);
+    } finally {
+      factory?.disposeSession(sessionId);
+    }
+  };
+}
 async function runACPWebSocketServer(deps, port) {
   const host = "127.0.0.1";
   const echo = deps.flags?.echo === true || deps.flags?.echo === "true";
   let turnFactory;
+  let wsAgentFactory;
   let echoTurn;
   let store;
   let hqTelemetry;
@@ -543,6 +642,7 @@ async function runACPWebSocketServer(deps, port) {
       appConfig: deps.config
     });
     const tracked = hqTelemetry.wrapAgentFactory(agentFor);
+    wsAgentFactory = agentFor;
     turnFactory = () => makeACPServerAgentTurn({ agentFor: tracked });
     store = deps.paths?.projectDir ? new ACPSessionStore({ dir: path.join(deps.paths.projectDir, "acp-sessions") }) : void 0;
   }
@@ -576,7 +676,10 @@ async function runACPWebSocketServer(deps, port) {
       ...connectionTurn ? {
         replayFor: connectionTurn.replay,
         seedFor: connectionTurn.seed,
-        disposeFor: hqTelemetry?.wrapDispose(connectionTurn.dispose) ?? connectionTurn.dispose
+        disposeFor: composeDispose(
+          hqTelemetry?.wrapDispose(connectionTurn.dispose) ?? connectionTurn.dispose,
+          wsAgentFactory
+        )
       } : {},
       ...store ? { store } : {}
     });
@@ -651,6 +754,7 @@ async function runACPServer(deps) {
         projectName: path.basename(deps.cwd ?? process.cwd()),
         appConfig: deps.config
       });
+      const stdioAgentFactory = agentFor;
       const turn = makeACPServerAgentTurn({
         agentFor: stdioHqTelemetry.wrapAgentFactory(agentFor)
       });
@@ -659,7 +763,10 @@ async function runACPServer(deps) {
         runTurn: turn,
         replayFor: turn.replay,
         seedFor: turn.seed,
-        disposeFor: stdioHqTelemetry.wrapDispose(turn.dispose),
+        disposeFor: composeDispose(
+          stdioHqTelemetry.wrapDispose(turn.dispose),
+          stdioAgentFactory
+        ),
         ...store ? { store } : {}
       };
     })()
@@ -702,35 +809,10 @@ async function runACPServer(deps) {
   return 0;
 }
 async function listACPAgents(deps) {
-  const registry = new EnsembleRegistry();
-  const detected = await registry.list();
-  deps.renderer.write("Detected ACP agents:\n\n");
-  const installed = detected.filter((a) => a.installed);
-  const missing = detected.filter((a) => !a.installed);
-  for (const a of installed) {
-    const ver = a.version ? `  (${a.version.split("\n")[0]})` : "";
-    deps.renderer.write(`  \u2713 ${a.id.padEnd(16)} ${a.displayName}${ver}
-`);
-  }
-  for (const a of missing) {
-    deps.renderer.write(
-      `  \u2717 ${a.id.padEnd(16)} ${a.displayName}  (${a.reason ?? "not installed"})
-`
-    );
-  }
-  deps.renderer.write(`
-${installed.length} of ${detected.length} agents available.
-`);
+  const detected = await new EnsembleRegistry().list();
   const live = await loadLive(deps);
-  if (live && live.agents.length > 0) {
-    deps.renderer.write(
-      `Synced registry: ${live.agents.length} agents available (run \`wstack acp spawn <id> <task>\`).
-`
-    );
-  } else {
-    deps.renderer.write("Run `wstack acp sync` to pull the full official registry (37+ agents).\n");
-  }
-  deps.renderer.write("Use `wstack acp spawn <agent-id> <task>` to delegate a task.\n");
+  deps.renderer.write(`${formatAcpAgentList({ live, detected })}
+`);
   return 0;
 }
 async function syncACPRegistry(deps) {
@@ -1017,4 +1099,4 @@ ${renderAcpBenchText(result)}
 export {
   acpCmd
 };
-//# sourceMappingURL=acp-JK4ZQO3R.js.map
+//# sourceMappingURL=acp-AB54FWM2.js.map

package/dist/acp-agent-list.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Shared `/acp` + `wstack acp list` renderer.
+ *
+ * After `sync`, the official registry is the list the user sees — not the
+ * 13-entry bundled offline catalog (which still includes experimental ids
+ * that are not in https://github.com/agentclientprotocol/registry).
+ */
+import { type DetectedAgent } from '@wrongstack/acp';
+import type { LoadedAcpRegistry } from './acp-registry-cache.js';
+export declare function formatAcpAgentList(opts: {
+    live: LoadedAcpRegistry | null;
+    detected: readonly DetectedAgent[];
+}): string;
+//# sourceMappingURL=acp-agent-list.d.ts.map

package/dist/acp-hq-telemetry.d.ts

@@ -23,8 +23,15 @@
  */
 import type { Agent } from '@wrongstack/core/agent';
 import type { Config } from '@wrongstack/core/types';
-/** The per-session Agent factory shape `makeACPServerAgentTurn` consumes. */
-type AcpAgentFactory = (sessionId: string, cwd: string, api?: never) => Promise<Agent>;
+/**
+ * The per-session Agent factory shape `makeACPServerAgentTurn` consumes.
+ *
+ * Typed on `...args` rather than a fixed parameter list on purpose: the
+ * wrapper below must forward every argument the adapter passes, and the list
+ * has grown (it now carries the client's `mcpServers`). A wrapper that names
+ * its parameters silently drops the ones added after it was written.
+ */
+type AcpAgentFactory = (sessionId: string, cwd: string, ...rest: never[]) => Promise<Agent>;
 export interface AcpHqTelemetryOptions {
     projectRoot: string;
     projectName?: string | undefined;

package/dist/acp-mcp-servers.d.ts

@@ -0,0 +1,49 @@
+/**
+ * Client-supplied MCP servers for ACP sessions.
+ *
+ * The ACP spec lets a client hand the agent a list of MCP servers with
+ * `session/new` (and `session/load` / `session/fork`): the editor owns the
+ * user's MCP configuration, and the agent is expected to connect to those
+ * servers and expose their tools for the session's lifetime.
+ *
+ * WrongStack advertised `mcpCapabilities: {http: false, sse: false}` and then
+ * destructured `mcpServers` at every entry point without ever reading it — so
+ * even the mandatory stdio transport was silently dropped. A client got a
+ * successful `session/new` and no tools, with nothing anywhere saying why.
+ * This module is the missing half: it maps the ACP wire shape onto
+ * `MCPServerConfig` and drives a per-session `MCPRegistry` whose tools land in
+ * that session's own `ToolRegistry` clone.
+ *
+ * Per-session, not per-process, deliberately: two ACP sessions may ask for
+ * different servers, and closing one must not tear down the other's.
+ */
+import type { McpServer } from '@wrongstack/acp/agent';
+import type { EventBus } from '@wrongstack/core/kernel';
+import type { ToolRegistry } from '@wrongstack/core/registry';
+import type { Logger, MCPServerConfig } from '@wrongstack/core/types';
+import { MCPRegistry } from '@wrongstack/mcp';
+/**
+ * Translate one ACP server entry into the config shape `MCPRegistry` consumes.
+ *
+ * Transport names differ between the two specs: ACP's `http` is MCP's
+ * `streamable-http`, and an entry with no `type` is stdio (the spec's default,
+ * and the only transport a client may assume).
+ */
+export declare function acpMcpServerToConfig(server: McpServer): MCPServerConfig;
+export interface AcpSessionMcpOptions {
+    servers: readonly McpServer[];
+    toolRegistry: ToolRegistry;
+    events: EventBus;
+    logger: Logger;
+    cacheDir?: string | undefined;
+}
+/**
+ * Connect the session's MCP servers and register their tools.
+ *
+ * Returns the registry so the caller can stop it when the session ends, or
+ * `undefined` when the client asked for nothing. A server that fails to start
+ * is logged and skipped — one unreachable server must not cost the client its
+ * whole session, and the failure is visible in `wstack mcp` health output.
+ */
+export declare function connectAcpSessionMcpServers(opts: AcpSessionMcpOptions): Promise<MCPRegistry | undefined>;
+//# sourceMappingURL=acp-mcp-servers.d.ts.map

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

@@ -8,12 +8,14 @@
  * module is that factory, reusing the same boot pieces the interactive CLI
  * uses (`setupProvider`, `createDefaultContainer`, builtin tools).
  *
- * Scope: a minimal but real agent. It deliberately does NOT wire MCP servers,
- * compaction middleware, model-runtime overlays, or lifecycle hooks — those
- * belong in the interactive host. The ACP server is a headless single-turn
- * surface; a future PR can layer richer session behaviour if needed.
+ * Scope: a minimal but real agent. It deliberately does NOT wire compaction
+ * middleware, model-runtime overlays, or lifecycle hooks — those belong in the
+ * interactive host. It DOES wire the MCP servers the ACP client supplies with
+ * `session/new`, because the spec makes those part of the session contract:
+ * the client hands over its MCP configuration and expects the tools to be
+ * there (see `acp-mcp-servers.ts`).
  */
-import type { RunTurnApi } from '@wrongstack/acp/agent';
+import type { McpServer, RunTurnApi } from '@wrongstack/acp/agent';
 import { Agent } from '@wrongstack/core/agent';
 import { type Logger, type PermissionDecision, type PermissionPolicy, type Tool } from '@wrongstack/core/types';
 import type { SubcommandDeps } from './subcommands/contracts.js';
@@ -25,6 +27,16 @@ import type { SubcommandDeps } from './subcommands/contracts.js';
 export declare class AcpServerConfigError extends Error {
     constructor(message: string);
 }
+/**
+ * The per-session Agent factory, plus the teardown hook for anything the
+ * session owns outside the Agent itself (currently the client's MCP servers).
+ * `dispose` on the turn adapter drops the Agent; this drops the connections.
+ */
+export interface AcpServerAgentFactory {
+    (sessionId: string, cwd: string, api?: RunTurnApi, mcpServers?: readonly McpServer[]): Promise<Agent>;
+    /** Stop and forget the MCP servers connected for this ACP session. */
+    disposeSession(sessionId: string): void;
+}
 interface AcpAgentFactoryOptions {
     /** Caller-supplied logger; a minimal stderr logger is created when omitted. */
     logger?: Logger | undefined;
@@ -63,6 +75,6 @@ export declare class ACPClientPermissionPolicy implements PermissionPolicy {
  *
  * Throws `AcpServerConfigError` up front if no provider is configured.
  */
-export declare function buildAcpServerAgentFactory(deps: SubcommandDeps, options?: AcpAgentFactoryOptions): (sessionId: string, cwd: string, api?: RunTurnApi) => Promise<Agent>;
+export declare function buildAcpServerAgentFactory(deps: SubcommandDeps, options?: AcpAgentFactoryOptions): AcpServerAgentFactory;
 export {};
 //# sourceMappingURL=acp-server-agent.d.ts.map

package/dist/{auth-XD3GN5RJ.js → auth-WDMSNZ3S.js}

@@ -29,7 +29,7 @@ import {
 } from "./chunk-YMXXOOFN.js";
 import {
   parseAuthFlags
-} from "./chunk-E6RFXHWD.js";
+} from "./chunk-EK2P53GL.js";
 import "./chunk-SIGUWXAA.js";
 import "./chunk-DAKVBMD4.js";
 import {
@@ -619,4 +619,4 @@ async function runAuthRemove(deps, providerId) {
 export {
   authCmd
 };
-//# sourceMappingURL=auth-XD3GN5RJ.js.map
+//# sourceMappingURL=auth-WDMSNZ3S.js.map

package/dist/boot/short-circuit-hq.d.ts

@@ -7,6 +7,8 @@
  * Returns 0 when the HQ flag was present and the server ran, or null
  * when the flag was absent (caller should proceed to boot()).
  */
+/** Detect a PID-namespace collision with a marker left by a prior container. */
+export declare function isReusedContainerPid(markerPid: number | undefined, containerMode: string | undefined, currentPid?: number): boolean;
 /**
  * Check for --hq flag and start the HQ server if present.
  *

package/dist/boot/tool-registry.d.ts

@@ -1,7 +1,7 @@
 /** CLI boot adapter for canonical runtime tool registration and host policies. */
 import type { EventBus } from '@wrongstack/core/kernel';
 import type { ToolRegistry } from '@wrongstack/core/registry';
-import type { AutoThinConfig, DisabledToolMeta, MemoryPort, TokenSavingTier, ToolDescriptionModeConfig, ToolResultRenderModeConfig } from '@wrongstack/core/types';
+import type { AutoThinConfig, ConcreteTokenSavingTier, DisabledToolMeta, MemoryPort, TokenSavingTier, ToolDescriptionModeConfig, ToolResultRenderModeConfig } from '@wrongstack/core/types';
 import type { WstackPaths } from '@wrongstack/core/utils';
 import type { VectorMemoryStore } from '@wrongstack/vector-memory';
 interface RegisterBuiltinToolsDeps {
@@ -36,6 +36,23 @@ interface RegisterBuiltinToolsDeps {
             } | undefined;
         } | undefined;
     };
+    /**
+     * The concrete tier this session runs at, resolved ONCE by the caller.
+     *
+     * `features.tokenSavingMode` defaults to `'auto'`, and `'auto'` has two
+     * different expansions: `normalizeTokenSavingTier` (window-blind, always
+     * `'medium'`) and `resolveTokenSavingTier` (window-aware — `'minimal'` on a
+     * modern window). The prompt builder uses the second. Letting this function
+     * fall back to the first meant every default session shipped a `'minimal'`
+     * shaped prompt over a `'medium'` tool surface: the two halves of one tier
+     * disagreed on which tools exist.
+     *
+     * Hosts therefore resolve the tier once, from the model window they already
+     * know at boot, and hand the same concrete value to the registry AND to the
+     * prompt builder. The `normalizeTokenSavingTier` fallback below stays for
+     * embedders that have no window to resolve against.
+     */
+    tier?: ConcreteTokenSavingTier | undefined;
     memoryStore: MemoryPort | null | undefined;
     /**
      * Optional vector memory store. When provided, the four