@wrongstack/cli 1.1.2 → 1.1.5

package/dist/{acp-HCGUTFNE.js → acp-NKUEYJDZ.js}

@@ -4,10 +4,13 @@ import {
   loadCachedAcpRegistry,
   refreshAcpRegistry,
   setupProvider
-} from "./chunk-ZNNFEKDZ.js";
+} from "./chunk-M7FNHCE3.js";
 import {
-  createHqCommandDispatcher
-} from "./chunk-XT3NAHRX.js";
+  createHqCommandDispatcher,
+  wrongstackBridgeSetup
+} from "./chunk-5SGMUDP5.js";
+import "./chunk-3LEIFO5D.js";
+import "./chunk-VEESMPTX.js";
 import {
   startCliHqConnection
 } from "./chunk-76JE54WD.js";
@@ -15,6 +18,7 @@ import {
   WebSocketServer
 } from "./chunk-OZCYZYN2.js";
 import "./chunk-UFRVTBV6.js";
+import "./chunk-LUEO5HLZ.js";
 import "./chunk-HKMOIIPQ.js";
 import "./chunk-W23PY4IJ.js";
 
@@ -99,8 +103,13 @@ async function spawnACPAgent(args, deps) {
       ...cmd.env !== void 0 ? { env: cmd.env } : {},
       role: subagentId,
       task,
+      // The project, not wherever `wstack` was launched from: the bridge's
+      // servers are bound to it, and the agent must edit the same tree.
+      cwd: deps.projectRoot,
+      projectRoot: deps.projectRoot,
       signal: ac.signal,
       permissionPolicy: defaultPermissionPolicy,
+      sessionSetup: wrongstackBridgeSetup(subagentId, deps.projectRoot, deps.config.acp?.bridge),
       onProgress: (event) => {
         const line = formatProgress(event);
         if (line) deps.renderer.writeInfo(`  ${line}
@@ -1115,7 +1124,7 @@ var acpCmd = async (args, deps) => {
   const sub = args[0];
   const loginIndex = sub === "auth" ? 0 : (sub === "server" || sub === "serve") && args[1] === "auth" ? 1 : -1;
   if (loginIndex >= 0) {
-    const { authCmd } = await import("./auth-ANOVZVHE.js");
+    const { authCmd } = await import("./auth-2ZG5DBHS.js");
     return authCmd(args.slice(loginIndex + 1), deps);
   }
   if (!sub || sub === "server" || sub === "serve") {
@@ -1196,4 +1205,4 @@ parallel:
 export {
   acpCmd
 };
-//# sourceMappingURL=acp-HCGUTFNE.js.map
+//# sourceMappingURL=acp-NKUEYJDZ.js.map

package/dist/acp-leader/acp-leader-confirm.d.ts

@@ -0,0 +1,20 @@
+import type { EventBus } from '@wrongstack/core/kernel';
+import type { PermissionPolicy, Tool } from '@wrongstack/core/types';
+export declare const ACP_CONFIRM_TIMEOUT_MS = 120000;
+export interface EventConfirmRequest {
+    events: EventBus;
+    sessionId: string | undefined;
+    tool: Tool;
+    input: unknown;
+    toolUseId: string;
+    suggestedPattern: string;
+    signal: AbortSignal;
+    /** Where an "always" or "deny" answer is remembered, as for the leader's own tools. */
+    permission?: Pick<PermissionPolicy, 'trust' | 'deny'> | undefined;
+    /** The context the policy evaluates the agent's calls in: an exact-input answer is keyed to it. */
+    context: Parameters<PermissionPolicy['evaluate']>[2];
+    timeoutMs?: number | undefined;
+}
+/** Resolves true when the user approved the call. */
+export declare function confirmThroughEvents(req: EventConfirmRequest): Promise<boolean>;
+//# sourceMappingURL=acp-leader-confirm.d.ts.map

package/dist/acp-leader/acp-leader-context.d.ts

@@ -0,0 +1,29 @@
+/**
+ * The leading agent's context, as the agent reports it. WrongStack's
+ * transcript is not what the agent holds, and a turn's usage is the sum of
+ * every model call in it, so neither measures the agent's window. Its own
+ * reports do: `usage_update` (`used` / `size`, after each model call) and the
+ * result of a compaction, manual or automatic (`preTokens` / `postTokens` on
+ * Claude's "Compact conversation" call).
+ */
+import type { ACPCapturedToolCall } from '@wrongstack/acp';
+import type { EventBus } from '@wrongstack/core/kernel';
+import type { AgentContextUsage } from '@wrongstack/core/types';
+export declare class LeaderContext {
+    private reading;
+    /** The agent's last reading. */
+    get current(): AgentContextUsage | undefined;
+    /** A `usage_update`: the context after the agent's latest model call. */
+    usage(update: {
+        used: number;
+        size: number;
+    }): AgentContextUsage;
+    /** A settled tool call; a compaction resets the context to what it kept. */
+    toolCall(call: ACPCapturedToolCall): AgentContextUsage | undefined;
+}
+/**
+ * Show a reading mid-turn: the agent's context grows with every tool call of
+ * a long turn, and the loop reports the fill only once the turn ends.
+ */
+export declare function publishLeaderContext(events: EventBus | undefined, sessionId: string | undefined, reading: AgentContextUsage, fallbackMaxContext: number): void;
+//# sourceMappingURL=acp-leader-context.d.ts.map

package/dist/acp-leader/acp-leader-fleet.d.ts

@@ -0,0 +1,26 @@
+import type { AcpLeaderHost } from './acp-leader-host.js';
+/** The MCP server name the agent sees (`mcp__wrongstack-fleet__<tool>`). */
+export declare const FLEET_SERVER_NAME = "wrongstack-fleet";
+/**
+ * The coordination tools offered, when the leader has them (a profile can
+ * disable `delegate`; then the spawn/assign/await path is what remains).
+ */
+export declare const FLEET_TOOLS: readonly string[];
+/** The leader tool behind a fleet MCP tool name, if it is one. */
+export declare function fleetToolName(mcpName: string): string | undefined;
+export interface FleetEndpoint {
+    url: string;
+    token: string;
+    /** The tools actually offered (those the leader has). */
+    tools: string[];
+    close(): Promise<void>;
+}
+/**
+ * Serve the leader's fleet tools to one agent session; undefined when the
+ * leader has none of them. Its calls run on the agent of `run.sessionId` (a
+ * WebUI tab's own), and one the policy wants confirmed runs on `run.approve`.
+ */
+export declare function startFleetEndpoint(host: AcpLeaderHost, run?: Parameters<AcpLeaderHost['runTool']>[2]): Promise<FleetEndpoint | undefined>;
+/** What the leader note says about the fleet tools it was given. */
+export declare function fleetNote(tools: readonly string[]): string;
+//# sourceMappingURL=acp-leader-fleet.d.ts.map

package/dist/acp-leader/acp-leader-host-binding.d.ts

@@ -0,0 +1,17 @@
+import type { Agent } from '@wrongstack/core/agent';
+import type { EventBus } from '@wrongstack/core/kernel';
+import type { Config, ConfirmAwaiter, Tool } from '@wrongstack/core/types';
+import { type AcpLeaderHost } from './acp-leader-host.js';
+export interface AcpLeaderHostOptions {
+    /** The leader: the agent of any session the host does not run itself. */
+    agent: Agent;
+    events: EventBus;
+    projectRoot: string;
+    stateDir?: string | undefined;
+    getConfig(): Config;
+    getTool(name: string): Tool | undefined;
+    listTools?(): Tool[];
+    confirmAwaiter?: ConfirmAwaiter | undefined;
+}
+export declare function createAcpLeaderHost(opts: AcpLeaderHostOptions): AcpLeaderHost;
+//# sourceMappingURL=acp-leader-host-binding.d.ts.map

package/dist/acp-leader/acp-leader-host.d.ts

@@ -0,0 +1,82 @@
+/**
+ * Host services the ACP leader provider needs but cannot get when it is built.
+ *
+ * Providers are created with the provider registry, before the agent exists;
+ * the leader provider still has to put the agent's tool calls on the agent's
+ * event bus, decide its permission requests with the leader's policy and ask
+ * through the leader's confirmation prompt. The CLI binds these once the
+ * agent is created (`bindAcpLeaderHost`); until then — or on a surface that
+ * never binds them — the provider runs the agent with the read-only default
+ * permission policy and shows no tool cards.
+ */
+import type { Agent } from '@wrongstack/core/agent';
+import type { EventBus } from '@wrongstack/core/kernel';
+import type { Config, ConfirmAwaiter, PermissionPolicy, Tool } from '@wrongstack/core/types';
+/** The provider id an ACP agent leads under (`--provider acp --model claude-code`). */
+export declare const ACP_LEADER_PROVIDER_ID = "acp";
+export interface AcpLeaderHost {
+    events: EventBus;
+    projectRoot: string;
+    /** The project's state directory, where a session's agent session is remembered for resume. */
+    stateDir?: string | undefined;
+    getConfig(): Config;
+    /**
+     * The live permission policy (it can change with YOLO and trust rules) of
+     * the agent running `sessionId` — a WebUI tab's own; the leader's without one.
+     */
+    permission(sessionId?: string): PermissionPolicy;
+    /** That agent's context, which the policy reads (files already read, the session). */
+    context(sessionId?: string): Parameters<PermissionPolicy['evaluate']>[2];
+    getTool(name: string): Tool | undefined;
+    /** Every tool the leader has (the WrongForge leader offers them over its gateway). */
+    listTools?(): Tool[];
+    /**
+     * Run one of the leader's tools as the leader would — the executor and
+     * context of the agent running `sessionId`, so permissions, hooks, events
+     * and the session all apply. Used by the fleet tools the agent reaches over
+     * MCP (`delegate` and kin). A call the policy wants confirmed runs only when
+     * `approve` says yes.
+     */
+    runTool(name: string, input: Record<string, unknown>, run?: {
+        sessionId?: string | undefined;
+        approve?: ((tool: Tool, input: Record<string, unknown>) => Promise<boolean>) | undefined;
+    }): Promise<{
+        content: string;
+        isError: boolean;
+    }>;
+    /** The leader's confirmation prompt, when the surface has one. */
+    confirmAwaiter?: ConfirmAwaiter | undefined;
+    /**
+     * The surface answers confirmations itself (TUI, WebUI): a question goes
+     * out as a `tool.confirm_needed` event, the leader tools' own prompt.
+     */
+    confirmThroughEvents?: boolean | undefined;
+}
+/** The agent of a session, on a host that runs one agent per session (the WebUI's tabs). */
+export type AcpLeaderSessionAgent = Pick<Agent, 'ctx' | 'permission' | 'toolExecutor' | 'perIterationOutputCapBytes'>;
+/** Set by a host with an agent per session; without it every session uses the leader. */
+export declare function setAcpLeaderSessionAgents(resolve: ((sessionId: string) => AcpLeaderSessionAgent | undefined) | undefined): void;
+export declare function acpLeaderSessionAgent(sessionId: string): AcpLeaderSessionAgent | undefined;
+export declare function bindAcpLeaderHost(host: AcpLeaderHost | undefined): void;
+export declare function acpLeaderHost(): AcpLeaderHost | undefined;
+/**
+ * The surface took the prompt away (`agent.disableInteractiveConfirmation()`:
+ * the TUI and WebUI answer confirmations themselves). The stdin prompt must
+ * not be used under them: it would read the terminal Ink or the browser owns.
+ * The agent's questions are asked the way the leader's own tools ask there.
+ */
+export declare function confirmAcpLeaderThroughEvents(): void;
+/** Something holding live agent sessions: an ACP leader provider. */
+interface LeaderSessions {
+    closeAll(): Promise<void>;
+}
+export declare function trackAcpLeader(leader: LeaderSessions): void;
+/**
+ * Close every ACP leader's agent sessions, bounded by `timeoutMs`. Called on
+ * the way out: an open agent (and the MCP servers it started) otherwise holds
+ * the process until the forced exit. Imports nothing heavy — it runs on every
+ * CLI exit.
+ */
+export declare function closeAcpLeaderSessions(timeoutMs?: number): Promise<void>;
+export {};
+//# sourceMappingURL=acp-leader-host.d.ts.map

package/dist/acp-leader/acp-leader-picker.d.ts

@@ -0,0 +1,24 @@
+import type { ProviderRegistry } from '@wrongstack/core/registry';
+import type { Config, Provider, ProviderConfig } from '@wrongstack/core/types';
+export interface PickableHostProvider {
+    id: string;
+    type: string;
+    refreshQuota?: () => Promise<boolean>;
+    models: Array<{
+        id: string;
+        name: string;
+        description: string;
+        contextWindow?: number;
+        reasoningEffortLevels?: string[];
+        effortSupported?: boolean;
+    }>;
+}
+/** The `acp` entry, or none when no ACP agent is installed. */
+export declare function acpLeaderPickable(config: Config | undefined): PickableHostProvider[];
+/**
+ * Build a host-registered leader (the ACP leader, WrongForge) from the host's
+ * provider registry, where its factory is registered; undefined for every
+ * other provider, which the WebUI builds as before.
+ */
+export declare function buildAcpLeaderProvider(registry: Pick<ProviderRegistry, 'has' | 'create'> | undefined, providerId: string, config: ProviderConfig): Provider | undefined;
+//# sourceMappingURL=acp-leader-picker.d.ts.map

package/dist/acp-leader/acp-leader-provider.d.ts

@@ -0,0 +1,85 @@
+import type { AgentContextUsage, Capabilities, Config, Provider, ProviderFactory, Request, Response, StreamEvent } from '@wrongstack/core/types';
+import { ACP_LEADER_PROVIDER_ID } from './acp-leader-host.js';
+export { ACP_LEADER_PROVIDER_ID };
+export declare function leaderSideModel(config: Config): {
+    provider: string;
+    model: string;
+} | undefined;
+/** A leader turn: the request's thread is its own conversation (a subagent's is not). */
+export declare function isLeaderTurn(req: Request): boolean;
+export interface AcpLeaderProviderOptions {
+    id?: string | undefined;
+    /** The config at boot; the bound host's live config wins once available. */
+    bootConfig: Config;
+    /** Build a WrongStack provider by id, for side requests. */
+    buildProvider(providerId: string, config: Config): Provider | undefined;
+}
+export declare class AcpLeaderProvider implements Provider {
+    private readonly opts;
+    readonly id: string;
+    private caps;
+    private acp;
+    private readonly sessions;
+    private readonly sideProviders;
+    /**
+     * Fleet calls the user already approved through the agent's permission
+     * request, by session, tool and input: the call that follows runs on that
+     * approval instead of asking again.
+     */
+    private readonly fleetGrants;
+    constructor(opts: AcpLeaderProviderOptions);
+    private config;
+    /**
+     * The leading agent's capabilities. One object per agent, so a host that
+     * refines a field in place keeps it until the user picks another agent.
+     */
+    get capabilities(): Capabilities;
+    /** The WrongStack provider and request for anything that is not a leader turn. */
+    private side;
+    complete(req: Request, opts: {
+        signal: AbortSignal;
+    }): Promise<Response>;
+    stream(req: Request, opts: {
+        signal: AbortSignal;
+    }): AsyncIterable<StreamEvent>;
+    /** The turn's prompt; an agent joining a conversation under way gets the turns before it. */
+    private promptText;
+    /**
+     * `/compact` on this route: the agent compacts its own conversation. No
+     * agent started yet means there is nothing in its context to compact.
+     */
+    compactOwnContext(opts: {
+        sessionId: string;
+        signal: AbortSignal;
+    }): Promise<AgentContextUsage | undefined>;
+    /** The progress handler of one agent turn: text, tool cards, rate limits and context. */
+    private progress;
+    /** A context reading from the agent: its window is the route's, and the fill shows at once. */
+    private observeContext;
+    private publishContext;
+    private loadAcp;
+    private drop;
+    /** The persistent agent session for this conversation, started on first use. */
+    private sessionFor;
+    /**
+     * Ask the user about one of the agent's calls on the prompt the surface
+     * has: the REPL's own, or the TUI/WebUI approval prompt in the session's tab.
+     */
+    private confirm;
+    /**
+     * A fleet call the policy wants confirmed: the approval the user gave the
+     * agent's permission request for it, once, or a question now (an agent
+     * whose own settings let it call the tool without asking).
+     */
+    private approveFleetCall;
+    private ask;
+    private startSession;
+    /** Close every agent session (process shutdown). */
+    closeAll(): Promise<void>;
+}
+/**
+ * Registered with the provider registry at boot. Inert unless the leader
+ * names it (`--provider acp`, `/model acp/claude-code`).
+ */
+export declare function createAcpLeaderProviderFactory(opts: Omit<AcpLeaderProviderOptions, 'id'>): ProviderFactory;
+//# sourceMappingURL=acp-leader-provider.d.ts.map

package/dist/acp-leader/acp-leader-resume.d.ts

@@ -0,0 +1,10 @@
+export interface LeaderSessionRecord {
+    agentId: string;
+    agentSessionId: string;
+    updatedAt: string;
+}
+/** The agent session that led `sessionId` with `agentId`, if one is on record. */
+export declare function readLeaderSession(stateDir: string, sessionId: string, agentId: string): Promise<string | undefined>;
+/** Remember that `agentSessionId` leads `sessionId`. Writes are serialized and atomic. */
+export declare function writeLeaderSession(stateDir: string, sessionId: string, record: Omit<LeaderSessionRecord, 'updatedAt'>): Promise<void>;
+//# sourceMappingURL=acp-leader-resume.d.ts.map

package/dist/acp-leader/acp-leader-stream.d.ts

@@ -0,0 +1,83 @@
+/**
+ * Turning an ACP agent's turn into a provider stream (see
+ * acp-leader-provider.ts): a push queue the progress callback feeds and the
+ * stream drains, the text block bookkeeping, the tool calls the agent runs
+ * itself relayed to the host as tool cards, and its failures as typed
+ * ProviderErrors.
+ */
+import type { ACPCapturedToolCall, ACPSessionRunResult } from '@wrongstack/acp';
+import type { EventBus } from '@wrongstack/core/kernel';
+import type { Message, StopReason, StreamEvent, SubagentError, Usage } from '@wrongstack/core/types';
+import { ProviderError } from '@wrongstack/core/types';
+/** A push-to-pull bridge: the agent's progress callback pushes, the stream iterates. */
+export declare class StreamQueue {
+    private readonly items;
+    private wake;
+    private done;
+    private failure;
+    push(event: StreamEvent): void;
+    end(): void;
+    fail(err: unknown): void;
+    drain(): AsyncGenerator<StreamEvent>;
+}
+/**
+ * Text arrives in chunks across one or more agent messages; each run of text
+ * is one content block. Thoughts are not forwarded into the response: an
+ * unsigned thinking block in history is rejected by Anthropic's wire if the
+ * user later switches the session to a real model.
+ */
+export declare class TextBlocks {
+    private readonly queue;
+    private open;
+    private index;
+    constructor(queue: StreamQueue);
+    text(chunk: string): void;
+    close(): void;
+}
+/**
+ * The agent's own tool calls as the host's tool cards: `tool.started` once a
+ * call is announced, `tool.executed` once it settles. Named by the agent's
+ * title ("Read src/a.ts", "git status"), which is what the user needs to see.
+ */
+export declare class ToolCardRelay {
+    private readonly events;
+    private readonly meta;
+    private readonly started;
+    private readonly settled;
+    constructor(events: EventBus | undefined, meta: {
+        sessionId?: string | undefined;
+        model: string;
+        provider?: string | undefined;
+    });
+    update(call: ACPCapturedToolCall): void;
+}
+/**
+ * What the agent has not seen yet: the text of every user message since its
+ * last reply (the user's prompt plus anything WrongStack folded in after it —
+ * a [DELEGATION RESULT], a session note). The agent keeps its own history.
+ */
+export declare function latestUserText(messages: readonly Message[]): string;
+/**
+ * The conversation before the agent's first turn, for an agent that joins one
+ * already under way: a `/model` switch to it, or a resumed session (a fresh
+ * agent remembers nothing). Text only, newest kept when it is long; the
+ * messages `latestUserText` sends are not repeated.
+ */
+export declare function earlierConversation(messages: readonly Message[], maxChars?: number): string | undefined;
+export declare function turnUsage(result: ACPSessionRunResult): Usage;
+export declare function turnStopReason(result: ACPSessionRunResult): StopReason;
+/**
+ * A failed agent turn as a ProviderError the leader's loop already handles:
+ * a spent subscription quota is `quota_exhausted` (the fallback chain moves
+ * the session to a WrongStack model), a stall is a timeout, a dead agent a
+ * server error. `dead` tells the caller to start a fresh agent next turn.
+ */
+export declare function agentTurnError(err: unknown, agentId: string, classify: (rpc: {
+    code?: number;
+    message: string;
+    data?: unknown;
+}, agent: string) => SubagentError | undefined): {
+    error: ProviderError;
+    dead: boolean;
+};
+//# sourceMappingURL=acp-leader-stream.d.ts.map