@wrongstack/cli 1.1.2 → 1.1.5

package/dist/execution-tui.d.ts

@@ -0,0 +1,30 @@
+import type { createToolVisionAdapters } from '@wrongstack/runtime/vision';
+import type { ExecuteDeps } from './execute-deps.js';
+import type { StandaloneAutoUpdate } from './standalone-auto-update.js';
+import type { UpdateInfo } from './update-check.js';
+/** Locals `execute` computes before branching, plus the coordinator-stop setter. */
+export interface ExecutionTuiLocals {
+    wpaths: ExecuteDeps['core']['wpaths'];
+    projectRoot: ExecuteDeps['core']['projectRoot'];
+    activeSessionStore: ExecuteDeps['session']['sessionStore'];
+    detachActiveTodosCheckpoint: (() => void | Promise<void>) | undefined;
+    profileName: string;
+    bootUpdateInfo: UpdateInfo | undefined;
+    supportsVision: () => Promise<boolean>;
+    visionAdapters: () => ReturnType<typeof createToolVisionAdapters>;
+    goalFlag: string | undefined;
+    askFlag: string | undefined;
+    autoUpdate: StandaloneAutoUpdate | undefined;
+    setCoordinatorStop: (fn: (() => void) | undefined) => void;
+}
+/**
+ * The interactive TUI branch of `execute`: wire the TUI runtime state,
+ * project-switch and coordinator plumbing, then run the TUI until it exits.
+ * `exitWith` carries a project-switch child's exit code when one replaced
+ * this session.
+ */
+export declare function runExecutionTui(deps: ExecuteDeps, local: ExecutionTuiLocals): Promise<{
+    code: number;
+    exitWith?: number;
+}>;
+//# sourceMappingURL=execution-tui.d.ts.map

package/dist/fleet/acp-live-steer.d.ts

@@ -0,0 +1,28 @@
+/**
+ * Live notes to a running external ACP worker.
+ *
+ * A WrongStack agent registers in the session note hub and folds notes in at
+ * its next iteration. An external agent (Claude Code over ACP) has no such
+ * loop, so while its turn runs this registers an inbox for it that injects
+ * each note into the turn through the agent's steering extension. The leader
+ * then reaches the worker with `session_note`, as it reaches its own workers.
+ */
+import type { AcpSteerOutcome } from '@wrongstack/acp';
+import { type SessionNoteHub } from '@wrongstack/core/coordination';
+import type { SubagentRunContext, TaskSpec } from '@wrongstack/core/types';
+interface Note {
+    from: string;
+    kind: string;
+    body: string;
+    subject?: string | undefined;
+}
+/** The note as the worker reads it: who sent it, as what, then the text. */
+export declare function steerMessage(note: Note): string;
+/**
+ * Register `ctx.subagentId` (and its display name) as a live agent of the
+ * delegating session for the length of the turn. Returns the unregister, or
+ * undefined when no WrongStack session delegated the task.
+ */
+export declare function registerAcpSteerInbox(ctx: SubagentRunContext, _task: TaskSpec, steer: (text: string) => Promise<AcpSteerOutcome>, hub?: Pick<SessionNoteHub, 'register'>, onUndelivered?: (outcome: string) => void): (() => void) | undefined;
+export {};
+//# sourceMappingURL=acp-live-steer.d.ts.map

package/dist/fleet/acp-permission-bridge.d.ts

@@ -0,0 +1,49 @@
+/**
+ * WrongStack's permission rules for an external ACP worker.
+ *
+ * A delegated agent must not be a one-hop bypass of the user's approval
+ * system. WrongStack's own subagents run every tool call through
+ * `AutoApprovePermissionPolicy`: the user's deny rules bind them, destructive
+ * commands and credential reads are refused (a worker cannot ask), and the
+ * user's YOLO+ lifts those refusals. An ACP worker gets the same treatment:
+ * the host starts it in a mode where it asks before edits, commands and
+ * fetches, and each `session/request_permission` is translated into the
+ * matching WrongStack tool call and decided by that policy. A request it
+ * cannot evaluate — an unknown kind, a call naming no target, a tool the run
+ * does not have — is refused, never waved through.
+ */
+import type { PermissionPolicy as AcpPermissionPolicy } from '@wrongstack/acp';
+import type { PermissionDecision, Tool } from '@wrongstack/core/types';
+/** The WrongStack tool call an ACP permission request stands for. */
+export interface WrongStackCall {
+    tool: string;
+    input: Record<string, unknown>;
+}
+export interface AcpPermissionBridgeOptions {
+    /** WrongStack's subagent policy (an `AutoApprovePermissionPolicy`). */
+    evaluate: (tool: Tool, input: unknown, ctx: {
+        projectRoot: string;
+        cwd: string;
+    }) => Promise<PermissionDecision>;
+    /** Resolve a WrongStack tool by name (the host's tool registry). */
+    getTool: (name: string) => Tool | undefined;
+    projectRoot: string;
+    /**
+     * Whether MCP tools may run at all. False under `--restricted`, which keeps
+     * MCP tools out of the registry and so out of a worker's reach too.
+     */
+    allowMcp?: boolean | undefined;
+    /**
+     * Ask the user when the policy wants a question (`confirm`). A worker has
+     * no one to ask, so without this a `confirm` is refused; a leader runs in
+     * front of the user and passes the session's own confirmation prompt.
+     */
+    confirm?: ((tool: Tool, call: WrongStackCall, request: {
+        toolCallId: string | undefined;
+        signal: AbortSignal;
+    }) => Promise<boolean>) | undefined;
+    /** Told about every refusal, for the host's log. */
+    onRefused?: ((call: WrongStackCall, reason: string) => void) | undefined;
+}
+export declare function wrongstackAcpPermissionPolicy(opts: AcpPermissionBridgeOptions): AcpPermissionPolicy;
+//# sourceMappingURL=acp-permission-bridge.d.ts.map

package/dist/fleet/acp-quota-hold.d.ts

@@ -0,0 +1,3 @@
+/** Run `start` unless `agentId` is held; record a hold when it fails on quota. */
+export declare function runWithQuotaHold<T>(agentId: string, start: () => Promise<T>, now?: () => number): Promise<T>;
+//# sourceMappingURL=acp-quota-hold.d.ts.map

package/dist/fleet/acp-quota-reading.d.ts

@@ -0,0 +1,3 @@
+/** Record one rate-limit reading from `agentId`; ignores readings it cannot read. */
+export declare function recordAcpRateLimit(agentId: string, info: Record<string, unknown>, now?: number): void;
+//# sourceMappingURL=acp-quota-reading.d.ts.map

package/dist/fleet/acp-turn-reminders.d.ts

@@ -0,0 +1,15 @@
+/** Remind an active ACP turn about local /btw notes and newly waiting mail. */
+import { type Context } from '@wrongstack/core/agent';
+type Steer = (text: string) => Promise<'injected' | 'promptRequired' | 'startedNewTurn' | 'unsupported'>;
+export interface AcpTurnRemindersOptions {
+    steer: Steer;
+    context?: Context | undefined;
+    unreadCount?: (() => Promise<number>) | undefined;
+    btwPollMs?: number | undefined;
+    mailPollMs?: number | undefined;
+}
+/** Mailbox awareness embeds message bodies; ask ACP to read inbox instead. */
+export declare function acpBtwBlock(notes: readonly string[]): string;
+export declare function startAcpTurnReminders(options: AcpTurnRemindersOptions): () => void;
+export {};
+//# sourceMappingURL=acp-turn-reminders.d.ts.map

package/dist/fleet/acp-wrongstack-bridge.d.ts

@@ -0,0 +1,50 @@
+import { type AcpSessionSetup } from '@wrongstack/acp';
+import type { Config, SubagentRunContext, TaskSpec } from '@wrongstack/core/types';
+export type BridgeServer = 'sage' | 'mailbox' | 'kanban' | 'codebase-index' | 'requirement-intake';
+export declare const DEFAULT_BRIDGE_AGENTS: readonly string[];
+export declare const DEFAULT_BRIDGE_SERVERS: readonly BridgeServer[];
+type BridgeConfig = NonNullable<NonNullable<Config['acp']>['bridge']>;
+/** How to start this same `wstack`: the binary itself, or node/bun + the CLI entry. */
+export declare function wstackLaunch(args: string[], entry?: string | undefined): {
+    command: string;
+    args: string[];
+};
+/**
+ * The worker's shell command for `wstack tools`, built from the same launcher
+ * as the MCP servers so it reaches this exact install. Stable for a given
+ * install, which keeps the system-prompt note cache-friendly across workers.
+ * Windows paths use forward slashes: the agent's shell is usually Git Bash,
+ * where an unquoted backslash is an escape.
+ */
+export declare function wstackToolsCommand(entry?: string | undefined, platform?: NodeJS.Platform): string;
+/** A short task-local cue: the Claude adapter gives user-turn text more immediate weight. */
+export declare function bridgeTaskKickoff(servers: readonly BridgeServer[], indexCli?: string): string;
+/**
+ * The note appended to the worker's system prompt. It must not vary per task
+ * or per worker: the system prompt is the head of the agent's prompt cache, so
+ * a task id or worker id in it made every worker rewrite ~25k cached tokens
+ * (measured: $0.21 per one-line task, against $0.008 with a stable prompt).
+ * Per-worker identity lives in the MCP servers' arguments instead.
+ */
+export declare function bridgeNote(servers: readonly BridgeServer[], delegated?: boolean, indexCli?: string): string;
+/**
+ * The note for an agent running as the session's LEADER: the user talks to it
+ * through WrongStack, so it answers them directly and ends a turn the way
+ * WrongStack's own leader does, with next steps the user can send back.
+ */
+export declare function leaderBridgeNote(servers: readonly BridgeServer[], indexCli?: string): string;
+/** True when `command` resolves to a file on PATH (PATHEXT-aware on Windows). */
+export declare function onPath(command: string, env?: NodeJS.ProcessEnv, platform?: NodeJS.Platform): boolean;
+/**
+ * Bridged agents the leader can hand a task to on this machine: listed in
+ * `acp.bridge.agents` (by catalog or registry id) and either configured by
+ * the user in `acp.agents` or with their CLI on PATH. Catalog ids, in order.
+ */
+export declare function installedBridgeAgents(acp: Config['acp'] | undefined, isOnPath?: (command: string) => boolean): string[];
+/**
+ * The per-session setup for `agentId`, or undefined when the bridge does not
+ * apply to it (not listed, turned off, or no servers).
+ */
+export declare function wrongstackBridgeSetup(agentId: string, projectRoot: string, config: BridgeConfig | undefined, role?: 'worker' | 'leader'): ((task: TaskSpec, ctx: SubagentRunContext) => AcpSessionSetup) | undefined;
+export {};
+//# sourceMappingURL=acp-wrongstack-bridge.d.ts.map

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

@@ -1,10 +1,31 @@
-import { type ACPProgressEvent, type AcpAgentCommandOverrides, type AcpLiveCatalog } from '@wrongstack/acp';
-import type { SubagentRunContext, SubagentRunner, TaskSpec } from '@wrongstack/core/types';
+import { type ACPProgressEvent, type AcpAgentCommandOverrides, type AcpLiveCatalog, type PermissionPolicy as AcpPermissionPolicy } from '@wrongstack/acp';
+import type { Config, SubagentRunContext, SubagentRunner, TaskSpec } from '@wrongstack/core/types';
+import { type WrongForgeGatewaySpec } from './wrongforge-runner.js';
 export type AcpLivePublisher = (ctx: SubagentRunContext, task: TaskSpec, event: ACPProgressEvent) => void;
 export interface BuildAcpSubagentRunnerOptions {
+    /**
+     * The project the worker works in: its cwd and file-access root. Without it
+     * the worker ran in the host process's cwd — a subdirectory, or another
+     * repository than the session's.
+     */
+    projectRoot?: string | undefined;
     overrides?: AcpAgentCommandOverrides | undefined;
     live?: AcpLiveCatalog | undefined;
     publishLive?: AcpLivePublisher | undefined;
+    /** Project the worker runs in, plus `acp.bridge` config: see acp-wrongstack-bridge.ts. */
+    bridge?: {
+        projectRoot: string;
+        config?: NonNullable<Config['acp']>['bridge'] | undefined;
+    } | undefined;
+    /**
+     * WrongStack's permission rules for the worker's session (see
+     * acp-permission-bridge.ts). When set, the worker is also started in its
+     * `default` mode so it asks before edits and commands, whatever mode the
+     * user runs the agent in on their own.
+     */
+    permissions?: ((ctx: SubagentRunContext) => AcpPermissionPolicy) | undefined;
+    /** WrongStack tools a WrongForge worker may call back (see wrongforge-gateway.ts). */
+    wrongforgeGateway?: (() => Promise<WrongForgeGatewaySpec | undefined>) | undefined;
 }
 /**
  * Same command resolution as `wstack acp spawn` / `/acp` — user override,

package/dist/fleet/wrongforge-client.d.ts

@@ -0,0 +1,116 @@
+import type { ACPProgressEvent } from '@wrongstack/acp';
+import type { WrongForgeInfo } from './wrongforge-info.js';
+export declare const WRONGFORGE_AGENT_ID = "wrongforge";
+/**
+ * WrongForge's own tools a task keeps when WrongStack's gateway carries the
+ * rest: reading, its todo list and progress reports. Writes and commands then
+ * go through `wstack_*`, i.e. through WrongStack's rules.
+ */
+export declare const WRONGFORGE_READ_SIDE_TOOLS: string[];
+export interface WrongForgeEndpoint {
+    url: string;
+    apiKey: string;
+}
+/** The `gateway` field of a WrongForge task: WrongStack tools it may call back. */
+export interface WrongForgeGatewaySpec {
+    url: string;
+    token: string;
+    list_path: string;
+    call_path: string;
+    name_prefix?: string | undefined;
+    deny?: string[] | undefined;
+    optional?: boolean | undefined;
+}
+export interface WfTaskRecord {
+    id: string;
+    status: 'queued' | 'running' | 'completed' | 'failed' | 'cancelled' | 'timed_out';
+    session_id?: string;
+    result?: {
+        text: string;
+        finish_reason?: string;
+        steps: number;
+        tool_calls: number;
+        usage?: {
+            input_tokens?: number;
+            output_tokens?: number;
+            cache_read_tokens?: number;
+            cache_write_tokens?: number;
+        };
+        context_tokens?: number;
+        context_window?: number;
+    };
+    error?: {
+        code: string;
+        message: string;
+    };
+    cancel_reason?: string;
+}
+export interface WfEvent {
+    seq: number;
+    type: string;
+    data: Record<string, unknown>;
+}
+export declare class WfHttpError extends Error {
+    readonly status: number;
+    readonly code: string;
+    constructor(status: number, code: string, message: string);
+}
+/** The delegating side gave up on the task (its signal fired). */
+export declare class WfAborted extends Error {
+    constructor();
+}
+/**
+ * Where a local WrongForge serves and the key it accepts: `WRONGFORGE_URL`
+ * (default 127.0.0.1:8787) and `WRONGFORGE_API_KEY`, else the key WrongForge
+ * saved on first start (`$WRONGFORGE_HOME|~/.wrongforge/api-key`).
+ */
+export declare function resolveWrongForgeEndpoint(env?: NodeJS.ProcessEnv): WrongForgeEndpoint | undefined;
+/** True when this machine has a WrongForge set up (a key to reach it with). */
+export declare function wrongForgeConfigured(env?: NodeJS.ProcessEnv): boolean;
+export declare const safeWfId: (s: string) => string;
+export type WfCall = <T>(method: 'GET' | 'POST', route: string, body?: unknown, signal?: AbortSignal) => Promise<T>;
+/** One JSON call to WrongForge; failures as WfHttpError (status 0 = unreachable). */
+export declare function wrongForgeCall(ep: WrongForgeEndpoint, doFetch?: typeof fetch): WfCall;
+/**
+ * A task's events in order, until it ends. Long-polls; a dropped connection or
+ * a WrongForge restart is retried (the task survives it). `onPoll` sees every
+ * answered poll's status: a task waiting in the shared queue emits nothing.
+ * Throws WfAborted when `signal` fires.
+ */
+export declare function followTask(call: WfCall, taskId: string, signal: AbortSignal, opts?: {
+    retryDelayMs?: number | undefined;
+    onPoll?: ((status: string) => void) | undefined;
+}): AsyncGenerator<WfEvent>;
+/**
+ * The terminal task record, with the same dropped-connection tolerance as
+ * `followTask`: the task is already finished, so one transient failure of
+ * this fetch must not turn completed work into a failed delegation (the
+ * caller would re-run it). Throws WfAborted when `signal` fires.
+ */
+export declare function terminalTaskRecord(call: WfCall, taskId: string, signal: AbortSignal, opts?: {
+    retryDelayMs?: number | undefined;
+}): Promise<WfTaskRecord>;
+/** Ask WrongForge to stop a task; best effort. */
+export declare function cancelTask(call: WfCall, taskId: string, reason: string): void;
+/**
+ * The model to ask WrongForge for. Its own `/v1/info` list is the authority:
+ * a model it does not serve fails fast, naming the ones it does, instead of
+ * failing inside WrongForge. Without the list (older server, info failed) only
+ * an id that looks like a Claude model is forwarded. An external-agent spawn
+ * may carry the agent's own name as its model; that is not a choice.
+ */
+export declare function chooseModel(requested: string | undefined, agentName: string | undefined, info: WrongForgeInfo | undefined): {
+    id?: string;
+    error?: string;
+};
+/** A WrongForge task event as the progress events the fleet and leader seams consume. */
+export declare function toProgress(ev: WfEvent): ACPProgressEvent[];
+/** WrongForge's token split: `input_tokens` is the uncached part (measured live). */
+export declare function wfTokens(usage: NonNullable<WfTaskRecord['result']>['usage']): {
+    input: number;
+    output: number;
+    cacheRead: number;
+    cacheWrite: number;
+};
+export declare function sleep(ms: number, signal: AbortSignal): Promise<void>;
+//# sourceMappingURL=wrongforge-client.d.ts.map

package/dist/fleet/wrongforge-gateway.d.ts

@@ -0,0 +1,20 @@
+import type { ToolRegistry } from '@wrongstack/core/registry';
+import type { Config } from '@wrongstack/core/types';
+import type { WrongForgeGatewaySpec } from './wrongforge-client.js';
+/**
+ * Never served to a worker: steering the fleet and the leader's session is the
+ * leader's job. A worker that could `delegate` would spawn workers of its own,
+ * filed under a session nobody is in (the gateway has no session). Memory,
+ * mailbox and the board stay: those are how a worker shares what it learns.
+ */
+export declare const WORKER_WITHHELD_TOOLS: ReadonlySet<string>;
+interface GatewayOptions {
+    projectRoot: string;
+    registry: ToolRegistry;
+    config: Config;
+    yoloPlus?: (() => boolean) | undefined;
+    log?: ((message: string) => void) | undefined;
+}
+export declare function sharedWrongForgeGateway(opts: GatewayOptions): Promise<WrongForgeGatewaySpec>;
+export {};
+//# sourceMappingURL=wrongforge-gateway.d.ts.map

package/dist/fleet/wrongforge-info.d.ts

@@ -0,0 +1,32 @@
+/**
+ * Where WrongForge answers. Structural, so this module stays a leaf:
+ * wrongforge-client.ts imports from here, never the other way round.
+ */
+interface WrongForgeEndpoint {
+    url: string;
+    apiKey: string;
+}
+export interface WrongForgeInfo {
+    models: string[];
+    defaultModel?: string | undefined;
+    features: string[];
+    effortLevels?: string[] | undefined;
+    modelDetails?: {
+        id: string;
+        description: string;
+        effortLevels: string[];
+    }[] | undefined;
+}
+export declare function wrongForgeInfoCacheFile(): string;
+/** Normalises a `/v1/info` body; anything malformed reads as "nothing known". */
+export declare function parseWrongForgeInfo(body: unknown): WrongForgeInfo;
+export declare function readCachedWrongForgeInfo(file?: string): WrongForgeInfo | undefined;
+export declare function writeWrongForgeInfoCache(info: WrongForgeInfo, file?: string): void;
+export declare function fetchWrongForgeInfo(ep: WrongForgeEndpoint, opts?: {
+    fetchImpl?: typeof fetch | undefined;
+    signal?: AbortSignal | undefined;
+}): Promise<WrongForgeInfo>;
+/** Boot-time, fire-and-forget: refresh the cache for the next description. */
+export declare function refreshWrongForgeInfoCache(ep: WrongForgeEndpoint | undefined): void;
+export {};
+//# sourceMappingURL=wrongforge-info.d.ts.map

package/dist/fleet/wrongforge-quota.d.ts

@@ -0,0 +1,10 @@
+import { type WrongForgeEndpoint } from './wrongforge-client.js';
+/** Read the signed-in WrongForge account into the shared quota plane; never a model call. */
+export declare function reportWrongForgeQuota(opts?: {
+    endpoint?: WrongForgeEndpoint | undefined;
+    providerId?: string | undefined;
+    fetchImpl?: typeof fetch | undefined;
+    force?: boolean | undefined;
+    timeoutMs?: number | undefined;
+}): Promise<boolean>;
+//# sourceMappingURL=wrongforge-quota.d.ts.map

package/dist/fleet/wrongforge-runner.d.ts

@@ -0,0 +1,37 @@
+import type { ACPProgressEvent } from '@wrongstack/acp';
+import type { SubagentRunContext, SubagentRunner, TaskSpec } from '@wrongstack/core/types';
+import { chooseModel, resolveWrongForgeEndpoint, WRONGFORGE_AGENT_ID, WRONGFORGE_READ_SIDE_TOOLS, type WrongForgeEndpoint, type WrongForgeGatewaySpec } from './wrongforge-client.js';
+export { wrongForgeConfigured } from './wrongforge-client.js';
+export { chooseModel, resolveWrongForgeEndpoint, WRONGFORGE_AGENT_ID, WRONGFORGE_READ_SIDE_TOOLS, type WrongForgeEndpoint, type WrongForgeGatewaySpec, };
+export interface WrongForgeRunnerOptions {
+    projectRoot: string;
+    endpoint?: (() => WrongForgeEndpoint | undefined) | undefined;
+    /** Started lazily on the first task; a failure runs the task without it. */
+    gateway?: (() => Promise<WrongForgeGatewaySpec | undefined>) | undefined;
+    publishLive?: ((ctx: SubagentRunContext, task: TaskSpec, event: ACPProgressEvent) => void) | undefined;
+    fetchImpl?: typeof fetch | undefined;
+    retryDelayMs?: number | undefined;
+}
+/**
+ * What the `delegate` description says about WrongForge at boot: whether it is
+ * set up, and the models it last reported (cached; refreshed in the background
+ * here and on every task, so the next boot names the current list).
+ */
+export declare function wrongForgeDelegateEntry(env?: NodeJS.ProcessEnv): {
+    agent: string;
+    models?: {
+        models: string[];
+        default?: string | undefined;
+    };
+} | undefined;
+/**
+ * The models the machine's WrongForge serves, for a model picker: asked live
+ * (short timeout, cache refreshed), else the last list it reported, else
+ * none (no WrongForge here, or it never answered).
+ */
+export declare function wrongForgeModels(env?: NodeJS.ProcessEnv): Promise<{
+    models: string[];
+    default?: string | undefined;
+} | undefined>;
+export declare function makeWrongForgeRunner(options: WrongForgeRunnerOptions): SubagentRunner;
+//# sourceMappingURL=wrongforge-runner.d.ts.map

package/dist/fleet/wrongforge-runtime.d.ts

@@ -0,0 +1,10 @@
+import type { ReasoningConfig, ReasoningRequest, RequestCacheControl } from '@wrongstack/core/types';
+import type { WrongForgeInfo } from './wrongforge-info.js';
+/** Task API accepts these controls and owns model-specific clamping/omission. */
+export declare const WRONGFORGE_REASONING: ReasoningConfig;
+/** WrongForge has a smaller effort vocabulary; model-specific clamping is server-owned. */
+export declare function wrongForgeRuntime(reasoning?: ReasoningRequest, cache?: RequestCacheControl, info?: WrongForgeInfo): {
+    effort?: 'off' | 'low' | 'medium' | 'high' | 'xhigh' | 'max';
+    cache?: '5m' | '1h';
+};
+//# sourceMappingURL=wrongforge-runtime.d.ts.map