@wrongstack/cli 1.1.4 → 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-wrongstack-bridge.d.ts

@@ -9,8 +9,16 @@ 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[]): string;
+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
@@ -18,13 +26,13 @@ export declare function bridgeTaskKickoff(servers: readonly BridgeServer[]): str
  * (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): string;
+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[]): string;
+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;
 /**

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

@@ -1,5 +1,6 @@
 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 {
     /**
@@ -23,6 +24,8 @@ export interface BuildAcpSubagentRunnerOptions {
      * 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