@wrongstack/cli 1.1.4 → 1.1.5

package/dist/slash-commands/command-context-fleet.d.ts

@@ -0,0 +1,187 @@
+/** Fleet and subagent hooks: spawn, monitor, budget, kill, retry and logs. */
+export interface SlashFleetCommandContext {
+    /** Agent Monitor Service — tracks subagent conversations and streams to HQ. */
+    agentMonitor?: import('@wrongstack/core/coordination').AgentMonitorService | undefined;
+    /**
+     * Generate a commit message by calling the LLM with the git diff.
+     * Receives the raw diff, returns a commit message string.
+     * When omitted /commit falls back to heuristics-only messages.
+     */
+    generateCommitMessage?: ((diff: string) => Promise<string>) | undefined;
+    /** Fire-and-forget spawn — returns immediately with spawn metadata. Used by /spawn. */
+    onSpawn?: (description: string, opts?: {
+        provider?: string | undefined;
+        model?: string | undefined;
+        fallbackModels?: string[] | undefined;
+        tools?: string[] | undefined;
+        name?: string | undefined;
+        /** Explicit capability allowlist for the subagent's auto-approve policy.
+         *  When omitted the host applies the WIDE working default (read/write/
+         *  net/shell/install) — or, for a scoped tools slice, that plus the
+         *  tools' own capabilities. Pass this to narrow (e.g. read-only) or to
+         *  grant an escape-hatch cap (fs.write.outside-project, config.mutate). */
+        allowedCapabilities?: readonly string[] | undefined;
+        /** Legacy Shadow Agent interval in ms. Only used when name === 'shadow'. */
+        shadowIntervalMs?: number | undefined;
+        /**
+         * Free-form task context propagated into the spawned `TaskSpec.context`.
+         * Used by `/kanban task dispatch` to carry `{ kanban: { boardId, taskId } }`
+         * so the tool-runtime boundary gate (`evaluateToolKanbanBoundary`) can
+         * resolve the live policy instead of failing open.
+         */
+        context?: {
+            kanban?: {
+                boardId?: string;
+                taskId?: string;
+                projectRoot?: string;
+            };
+        } | undefined;
+    }) => Promise<string>;
+    /**
+     * Blocking spawn — waits for the subagent to complete and returns the full
+     * result. Used by /techstack and any other command that needs the subagent's
+     * actual output inline.
+     */
+    onSpawnAndWait?: (description: string, opts?: {
+        provider?: string | undefined;
+        model?: string | undefined;
+        fallbackModels?: string[] | undefined;
+        tools?: string[] | undefined;
+        name?: string | undefined;
+        /** Explicit capability allowlist for the subagent's auto-approve policy.
+         *  When omitted the host applies the WIDE working default (read/write/
+         *  net/shell/install) — or, for a scoped tools slice, that plus the
+         *  tools' own capabilities. Pass this to narrow (e.g. read-only) or to
+         *  grant an escape-hatch cap (fs.write.outside-project, config.mutate). */
+        allowedCapabilities?: readonly string[] | undefined;
+        /** Legacy Shadow Agent interval in ms. Only used when name === 'shadow'. */
+        shadowIntervalMs?: number | undefined;
+        /**
+         * Free-form task context propagated into the spawned `TaskSpec.context`.
+         * Used by `/kanban task dispatch` to carry `{ kanban: { boardId, taskId } }`
+         * so the tool-runtime boundary gate (`evaluateToolKanbanBoundary`) can
+         * resolve the live policy instead of failing open.
+         */
+        context?: {
+            kanban?: {
+                boardId?: string;
+                taskId?: string;
+                projectRoot?: string;
+            };
+        } | undefined;
+    }) => Promise<string>;
+    onAgents?: ((subagentId?: string) => string) | undefined;
+    onFleet?: (action: 'status' | 'usage' | 'kill' | 'manifest' | 'concurrency' | 'retry' | 'log', target?: string | undefined) => Promise<string>;
+    /**
+     * Get live coordinator status for /fleet. Returns null when no fleet is active.
+     */
+    onFleetStatus?: (() => import('@wrongstack/core/types').CoordinatorStatus | null) | undefined;
+    /**
+     * Read-only concurrency + lifetime spawn budget for `/fleet status`.
+     * Returns null when no fleet host is available.
+     */
+    onFleetBudget?: (() => {
+        maxConcurrent: number;
+        activeAgents: number;
+        maxSpawns: number;
+        usedSpawns: number;
+        remainingSpawns: number;
+        maxTokens?: number | undefined;
+        usedTokens?: number | undefined;
+        remainingTokens?: number | undefined;
+        maxCostUsd?: number | undefined;
+        usedCostUsd?: number | undefined;
+        remainingCostUsd?: number | undefined;
+        checkpointMaxSpawns?: number | undefined;
+        ceilingMismatch?: boolean | undefined;
+    } | null) | undefined;
+    /**
+     * Get fleet usage summary for /fleet usage.
+     */
+    onFleetUsage?: (() => import('@wrongstack/core/coordination').FleetUsage | null) | undefined;
+    /**
+     * Kill all running subagents. Returns count of killed subagents.
+     */
+    onFleetKill?: (() => number | Promise<number>) | undefined;
+    /**
+     * Abort the in-flight leader run. Installed by the surface (REPL/TUI) on
+     * startup so `/interrupt` can stop the current iteration — slash commands
+     * don't get the RunController directly. The default no-op returns false;
+     * a real handler returns true when it actually aborted a run.
+     */
+    interruptController?: {
+        abortLeader: () => boolean;
+        /**
+         * Report whether an operation (leader run, autonomy loop, or SDD run)
+         * is currently in flight. Used by `/clear` to confirm before wiping a
+         * session that still has active work. Absent → treated as idle.
+         */
+        isRunning?: (() => boolean) | undefined;
+        /**
+         * Ask the owning interactive surface to confirm a destructive clear.
+         * The TUI installs a panel-backed implementation; plain terminals
+         * fall back to the generic `confirm` callback below.
+         */
+        confirmClear?: ((info: {
+            leaderActive: boolean;
+            subagentCount: number;
+        }) => Promise<boolean>) | undefined;
+        /** Render a generic slash-command confirmation in the owning surface. */
+        confirmSlash?: ((question: string, defaultYes: boolean) => Promise<boolean | null>) | undefined;
+        /** Drop buffered output that belongs to the session being cleared. */
+        resetSession?: (() => void) | undefined;
+        /** Wait until the aborted leader turn can no longer mutate context. */
+        waitForIdle?: (() => Promise<void>) | undefined;
+    } | undefined;
+    /**
+     * Terminate a specific subagent by id. Returns true if terminated.
+     */
+    onFleetTerminate?: ((subagentId: string) => boolean | Promise<boolean>) | undefined;
+    /**
+     * Spawn a subagent of a given role. Returns the new subagent id.
+     */
+    onFleetSpawn?: ((role: string) => Promise<string>) | undefined;
+    /**
+     * Optional LLM classifier for `/fleet dispatch`. When wired, the smart
+     * dispatcher uses it to resolve ambiguous routing decisions; without it the
+     * dispatcher is heuristic-only. Built from the session provider in the host.
+     */
+    onDispatchClassify?: import('@wrongstack/core/coordination').DispatchClassifier | undefined;
+    /**
+     * Toggle subagent activity streaming into the leader's history. The
+     * TUI installs the actual setter on mount via a shared controller;
+     * before that, calls are buffered into the initial-value field so
+     * `/fleet stream off` issued before mount still takes effect.
+     */
+    fleetStreamController?: {
+        /** Fleet-chat verbosity (off | compact | full). */
+        mode: import('@wrongstack/core/types').FleetChatVerbosity;
+        /** Replaced by the TUI on mount with a dispatch-backed setter. */
+        setMode: (mode: import('@wrongstack/core/types').FleetChatVerbosity) => void;
+    } | undefined;
+    /**
+     * Toggle prompt refinement ("did you mean this?"). The TUI installs the
+     * actual dispatch-backed setter on mount via this shared controller; before
+     * that, `enabled` just mirrors the requested value so a pre-mount toggle
+     * still takes effect. Backed by `config.autonomy.enhance`.
+     */
+    enhanceController?: {
+        enabled: boolean;
+        setEnabled: (enabled: boolean) => void;
+    };
+    /**
+     * Re-run interrupted tasks from a prior director-state.json. Pass `undefined`
+     * to list them, a specific task id to retry one, or 'all' to retry every
+     * interrupted task. Returns a human-readable summary. Only wired when
+     * director mode is enabled.
+     */
+    onFleetRetry?: ((taskId?: string) => Promise<string>) | undefined;
+    /**
+     * Inspect per-subagent JSONL transcripts under `<fleetRoot>/subagents/`.
+     * Pass `undefined` to list available transcripts, a subagent id to show
+     * a compact event summary, or a subagent id with `mode='raw'` to dump
+     * the full JSONL. Only wired when a fleet root exists for this session.
+     */
+    onFleetLog?: (subagentId: string | undefined, mode: 'summary' | 'raw') => Promise<string>;
+}
+//# sourceMappingURL=command-context-fleet.d.ts.map

package/dist/slash-commands/command-context-sdd-goal.d.ts

@@ -0,0 +1,102 @@
+/** SDD run and goal-runner hooks. */
+export interface SlashSddGoalCommandContext {
+    /**
+     * Start an SDD parallel fan-out run. Requires an active SDD session with
+     * an approved spec and generated task graph.
+     */
+    onSddParallelRun?: (opts?: {
+        parallelSlots?: number | undefined;
+    }) => Promise<string>;
+    /** Stop the currently running SDD parallel fan-out. */
+    onSddParallelStop?: (() => void) | undefined;
+    /** Requeue every failed task in the active SDD run to pending. Returns the count requeued. */
+    onSddRetryAllFailed?: (() => number) | undefined;
+    /**
+     * Split a task in the active SDD run into sub-tasks (refused while it runs).
+     * Returns the new leaf ids, or null when there is no active run / unknown task.
+     */
+    onSddSplitTask?: ((taskId: string, subtasks: Array<{
+        title: string;
+        description: string;
+    }>) => string[] | null) | undefined;
+    /**
+     * Remove the git worktrees + branches an SDD run created. Uses the live run
+     * when one is active (after a stop), else sweeps the project's leftovers from
+     * disk. Returns the number of worktrees removed.
+     */
+    onSddCleanWorktrees?: (() => Promise<number>) | undefined;
+    /**
+     * Roll back an SDD run's merged commits by reverting each on the base branch
+     * (history-preserving). Refuses while a run is still live. Returns the outcome.
+     */
+    onSddRollback?: (() => Promise<{
+        ok: boolean;
+        reverted: number;
+        reason?: string;
+    }>) | undefined;
+    /**
+     * Destroy the SDD project: stop any active run, clean worktrees, and delete the
+     * on-disk artifacts (specs, task-graphs, session, boards). Pass
+     * `{ revertMerged: true }` (`/sdd destroy --revert`) to also revert merged
+     * commits before wiping; otherwise they are left on the base branch.
+     */
+    onSddDestroy?: ((opts?: {
+        revertMerged?: boolean;
+    }) => Promise<{
+        worktreesRemoved: number;
+        deleted: string[];
+        reverted: number;
+        revertOk?: boolean | undefined;
+        revertReason?: string | undefined;
+    }>) | undefined;
+    /**
+     * Start a real, LLM-driven Goal run from a free-text goal. The host
+     * plans phases (each holding many todos), persists the phase-graph as
+     * per-project JSON, and drives the orchestrator — one subagent per task —
+     * in the background. Returns the built graph or an error.
+     */
+    onGoalStart?: (opts: {
+        goal: string;
+        projectContext?: string | undefined;
+    }) => Promise<{
+        ok: true;
+        graph: import('@wrongstack/core/goal').PhaseGraph;
+    } | {
+        ok: false;
+        error: string;
+    }>;
+    onGoalPause?: (() => void) | undefined;
+    onGoalResume?: (() => void) | undefined;
+    onGoalStop?: (() => void) | undefined;
+    /**
+     * Resume a persisted PhaseGraph. The host creates a new orchestrator for
+     * the loaded graph and starts executing pending tasks.
+     */
+    onGoalResumeFromGraph?: ((graph: import('@wrongstack/core/goal').PhaseGraph) => Promise<{
+        ok: true;
+        graph: import('@wrongstack/core/goal').PhaseGraph;
+    } | {
+        ok: false;
+        error: string;
+    }>) | undefined;
+    /** Live, read-only view of the running Goal (null when idle). */
+    getGoalRunner?: () => {
+        graph: import('@wrongstack/core/goal').PhaseGraph;
+        getProgress: () => import('@wrongstack/core/goal').PhaseProgress | null;
+        isRunning: () => boolean;
+    } | null;
+    /** Interactive board: move a task to another phase (returns false when idle/invalid). */
+    onGoalMoveTask?: ((taskId: string, toPhaseId: string) => boolean) | undefined;
+    /** Interactive board: (re)assign a task to an agent (clear with both omitted). */
+    onGoalAssignTask?: ((taskId: string, agentId?: string, agentName?: string) => boolean) | undefined;
+    /** Interactive board: add a new task to a phase, returning its id (or null when idle). */
+    onGoalAddTask?: ((phaseId: string, spec: {
+        title: string;
+        description?: string;
+        type?: import('@wrongstack/core/types').TaskNode['type'];
+        priority?: import('@wrongstack/core/types').TaskNode['priority'];
+    }) => string | null) | undefined;
+    /** Interactive board: requeue a task to pending so it (re)runs. */
+    onGoalRetryTask?: ((taskId: string) => boolean) | undefined;
+}
+//# sourceMappingURL=command-context-sdd-goal.d.ts.map

package/dist/slash-commands/command-context.d.ts

@@ -5,8 +5,10 @@ import type { CompactOptions, CompactReport, HealthRegistry, MemoryPort, Metrics
 import type { WstackPaths } from '@wrongstack/core/utils';
 import type { SummarizerPort } from '@wrongstack/tools';
 import type { VectorMemoryStore } from '@wrongstack/vector-memory';
+import type { SlashFleetCommandContext } from './command-context-fleet.js';
+import type { SlashSddGoalCommandContext } from './command-context-sdd-goal.js';
 /** Host capabilities supplied to command adapters. */
-export interface SlashCommandContext {
+export interface SlashCommandContext extends SlashFleetCommandContext, SlashSddGoalCommandContext {
     registry: SlashCommandRegistry;
     toolRegistry: ToolRegistry;
     /**
@@ -75,189 +77,6 @@ export interface SlashCommandContext {
     onNewSession?: (() => Promise<void>) | undefined;
     onDiag?: (() => string) | undefined;
     onStats?: (() => string | null) | undefined;
-    /** Agent Monitor Service — tracks subagent conversations and streams to HQ. */
-    agentMonitor?: import('@wrongstack/core/coordination').AgentMonitorService | undefined;
-    /**
-     * Generate a commit message by calling the LLM with the git diff.
-     * Receives the raw diff, returns a commit message string.
-     * When omitted /commit falls back to heuristics-only messages.
-     */
-    generateCommitMessage?: ((diff: string) => Promise<string>) | undefined;
-    /** Fire-and-forget spawn — returns immediately with spawn metadata. Used by /spawn. */
-    onSpawn?: (description: string, opts?: {
-        provider?: string | undefined;
-        model?: string | undefined;
-        fallbackModels?: string[] | undefined;
-        tools?: string[] | undefined;
-        name?: string | undefined;
-        /** Explicit capability allowlist for the subagent's auto-approve policy.
-         *  When omitted the host applies the WIDE working default (read/write/
-         *  net/shell/install) — or, for a scoped tools slice, that plus the
-         *  tools' own capabilities. Pass this to narrow (e.g. read-only) or to
-         *  grant an escape-hatch cap (fs.write.outside-project, config.mutate). */
-        allowedCapabilities?: readonly string[] | undefined;
-        /** Legacy Shadow Agent interval in ms. Only used when name === 'shadow'. */
-        shadowIntervalMs?: number | undefined;
-        /**
-         * Free-form task context propagated into the spawned `TaskSpec.context`.
-         * Used by `/kanban task dispatch` to carry `{ kanban: { boardId, taskId } }`
-         * so the tool-runtime boundary gate (`evaluateToolKanbanBoundary`) can
-         * resolve the live policy instead of failing open.
-         */
-        context?: {
-            kanban?: {
-                boardId?: string;
-                taskId?: string;
-                projectRoot?: string;
-            };
-        } | undefined;
-    }) => Promise<string>;
-    /**
-     * Blocking spawn — waits for the subagent to complete and returns the full
-     * result. Used by /techstack and any other command that needs the subagent's
-     * actual output inline.
-     */
-    onSpawnAndWait?: (description: string, opts?: {
-        provider?: string | undefined;
-        model?: string | undefined;
-        fallbackModels?: string[] | undefined;
-        tools?: string[] | undefined;
-        name?: string | undefined;
-        /** Explicit capability allowlist for the subagent's auto-approve policy.
-         *  When omitted the host applies the WIDE working default (read/write/
-         *  net/shell/install) — or, for a scoped tools slice, that plus the
-         *  tools' own capabilities. Pass this to narrow (e.g. read-only) or to
-         *  grant an escape-hatch cap (fs.write.outside-project, config.mutate). */
-        allowedCapabilities?: readonly string[] | undefined;
-        /** Legacy Shadow Agent interval in ms. Only used when name === 'shadow'. */
-        shadowIntervalMs?: number | undefined;
-        /**
-         * Free-form task context propagated into the spawned `TaskSpec.context`.
-         * Used by `/kanban task dispatch` to carry `{ kanban: { boardId, taskId } }`
-         * so the tool-runtime boundary gate (`evaluateToolKanbanBoundary`) can
-         * resolve the live policy instead of failing open.
-         */
-        context?: {
-            kanban?: {
-                boardId?: string;
-                taskId?: string;
-                projectRoot?: string;
-            };
-        } | undefined;
-    }) => Promise<string>;
-    onAgents?: ((subagentId?: string) => string) | undefined;
-    onFleet?: (action: 'status' | 'usage' | 'kill' | 'manifest' | 'concurrency' | 'retry' | 'log', target?: string | undefined) => Promise<string>;
-    /**
-     * Get live coordinator status for /fleet. Returns null when no fleet is active.
-     */
-    onFleetStatus?: (() => import('@wrongstack/core/types').CoordinatorStatus | null) | undefined;
-    /**
-     * Read-only concurrency + lifetime spawn budget for `/fleet status`.
-     * Returns null when no fleet host is available.
-     */
-    onFleetBudget?: (() => {
-        maxConcurrent: number;
-        activeAgents: number;
-        maxSpawns: number;
-        usedSpawns: number;
-        remainingSpawns: number;
-        maxTokens?: number | undefined;
-        usedTokens?: number | undefined;
-        remainingTokens?: number | undefined;
-        maxCostUsd?: number | undefined;
-        usedCostUsd?: number | undefined;
-        remainingCostUsd?: number | undefined;
-        checkpointMaxSpawns?: number | undefined;
-        ceilingMismatch?: boolean | undefined;
-    } | null) | undefined;
-    /**
-     * Get fleet usage summary for /fleet usage.
-     */
-    onFleetUsage?: (() => import('@wrongstack/core/coordination').FleetUsage | null) | undefined;
-    /**
-     * Kill all running subagents. Returns count of killed subagents.
-     */
-    onFleetKill?: (() => number | Promise<number>) | undefined;
-    /**
-     * Abort the in-flight leader run. Installed by the surface (REPL/TUI) on
-     * startup so `/interrupt` can stop the current iteration — slash commands
-     * don't get the RunController directly. The default no-op returns false;
-     * a real handler returns true when it actually aborted a run.
-     */
-    interruptController?: {
-        abortLeader: () => boolean;
-        /**
-         * Report whether an operation (leader run, autonomy loop, or SDD run)
-         * is currently in flight. Used by `/clear` to confirm before wiping a
-         * session that still has active work. Absent → treated as idle.
-         */
-        isRunning?: (() => boolean) | undefined;
-        /**
-         * Ask the owning interactive surface to confirm a destructive clear.
-         * The TUI installs a panel-backed implementation; plain terminals
-         * fall back to the generic `confirm` callback below.
-         */
-        confirmClear?: ((info: {
-            leaderActive: boolean;
-            subagentCount: number;
-        }) => Promise<boolean>) | undefined;
-        /** Render a generic slash-command confirmation in the owning surface. */
-        confirmSlash?: ((question: string, defaultYes: boolean) => Promise<boolean | null>) | undefined;
-        /** Drop buffered output that belongs to the session being cleared. */
-        resetSession?: (() => void) | undefined;
-        /** Wait until the aborted leader turn can no longer mutate context. */
-        waitForIdle?: (() => Promise<void>) | undefined;
-    } | undefined;
-    /**
-     * Terminate a specific subagent by id. Returns true if terminated.
-     */
-    onFleetTerminate?: ((subagentId: string) => boolean | Promise<boolean>) | undefined;
-    /**
-     * Spawn a subagent of a given role. Returns the new subagent id.
-     */
-    onFleetSpawn?: ((role: string) => Promise<string>) | undefined;
-    /**
-     * Optional LLM classifier for `/fleet dispatch`. When wired, the smart
-     * dispatcher uses it to resolve ambiguous routing decisions; without it the
-     * dispatcher is heuristic-only. Built from the session provider in the host.
-     */
-    onDispatchClassify?: import('@wrongstack/core/coordination').DispatchClassifier | undefined;
-    /**
-     * Toggle subagent activity streaming into the leader's history. The
-     * TUI installs the actual setter on mount via a shared controller;
-     * before that, calls are buffered into the initial-value field so
-     * `/fleet stream off` issued before mount still takes effect.
-     */
-    fleetStreamController?: {
-        /** Fleet-chat verbosity (off | compact | full). */
-        mode: import('@wrongstack/core/types').FleetChatVerbosity;
-        /** Replaced by the TUI on mount with a dispatch-backed setter. */
-        setMode: (mode: import('@wrongstack/core/types').FleetChatVerbosity) => void;
-    } | undefined;
-    /**
-     * Toggle prompt refinement ("did you mean this?"). The TUI installs the
-     * actual dispatch-backed setter on mount via this shared controller; before
-     * that, `enabled` just mirrors the requested value so a pre-mount toggle
-     * still takes effect. Backed by `config.autonomy.enhance`.
-     */
-    enhanceController?: {
-        enabled: boolean;
-        setEnabled: (enabled: boolean) => void;
-    };
-    /**
-     * Re-run interrupted tasks from a prior director-state.json. Pass `undefined`
-     * to list them, a specific task id to retry one, or 'all' to retry every
-     * interrupted task. Returns a human-readable summary. Only wired when
-     * director mode is enabled.
-     */
-    onFleetRetry?: ((taskId?: string) => Promise<string>) | undefined;
-    /**
-     * Inspect per-subagent JSONL transcripts under `<fleetRoot>/subagents/`.
-     * Pass `undefined` to list available transcripts, a subagent id to show
-     * a compact event summary, or a subagent id with `mode='raw'` to dump
-     * the full JSONL. Only wired when a fleet root exists for this session.
-     */
-    onFleetLog?: (subagentId: string | undefined, mode: 'summary' | 'raw') => Promise<string>;
     /** Promote to director mode at runtime. Returns success message or null on failure. */
     onDirector?: (() => Promise<string | null>) | undefined;
     /** Manage plugin config from the interactive slash menu. */
@@ -473,104 +292,6 @@ export interface SlashCommandContext {
         message?: string | undefined;
         runText?: string | undefined;
     }>;
-    /**
-     * Start an SDD parallel fan-out run. Requires an active SDD session with
-     * an approved spec and generated task graph.
-     */
-    onSddParallelRun?: (opts?: {
-        parallelSlots?: number | undefined;
-    }) => Promise<string>;
-    /** Stop the currently running SDD parallel fan-out. */
-    onSddParallelStop?: (() => void) | undefined;
-    /** Requeue every failed task in the active SDD run to pending. Returns the count requeued. */
-    onSddRetryAllFailed?: (() => number) | undefined;
-    /**
-     * Split a task in the active SDD run into sub-tasks (refused while it runs).
-     * Returns the new leaf ids, or null when there is no active run / unknown task.
-     */
-    onSddSplitTask?: ((taskId: string, subtasks: Array<{
-        title: string;
-        description: string;
-    }>) => string[] | null) | undefined;
-    /**
-     * Remove the git worktrees + branches an SDD run created. Uses the live run
-     * when one is active (after a stop), else sweeps the project's leftovers from
-     * disk. Returns the number of worktrees removed.
-     */
-    onSddCleanWorktrees?: (() => Promise<number>) | undefined;
-    /**
-     * Roll back an SDD run's merged commits by reverting each on the base branch
-     * (history-preserving). Refuses while a run is still live. Returns the outcome.
-     */
-    onSddRollback?: (() => Promise<{
-        ok: boolean;
-        reverted: number;
-        reason?: string;
-    }>) | undefined;
-    /**
-     * Destroy the SDD project: stop any active run, clean worktrees, and delete the
-     * on-disk artifacts (specs, task-graphs, session, boards). Pass
-     * `{ revertMerged: true }` (`/sdd destroy --revert`) to also revert merged
-     * commits before wiping; otherwise they are left on the base branch.
-     */
-    onSddDestroy?: ((opts?: {
-        revertMerged?: boolean;
-    }) => Promise<{
-        worktreesRemoved: number;
-        deleted: string[];
-        reverted: number;
-        revertOk?: boolean | undefined;
-        revertReason?: string | undefined;
-    }>) | undefined;
-    /**
-     * Start a real, LLM-driven Goal run from a free-text goal. The host
-     * plans phases (each holding many todos), persists the phase-graph as
-     * per-project JSON, and drives the orchestrator — one subagent per task —
-     * in the background. Returns the built graph or an error.
-     */
-    onGoalStart?: (opts: {
-        goal: string;
-        projectContext?: string | undefined;
-    }) => Promise<{
-        ok: true;
-        graph: import('@wrongstack/core/goal').PhaseGraph;
-    } | {
-        ok: false;
-        error: string;
-    }>;
-    onGoalPause?: (() => void) | undefined;
-    onGoalResume?: (() => void) | undefined;
-    onGoalStop?: (() => void) | undefined;
-    /**
-     * Resume a persisted PhaseGraph. The host creates a new orchestrator for
-     * the loaded graph and starts executing pending tasks.
-     */
-    onGoalResumeFromGraph?: ((graph: import('@wrongstack/core/goal').PhaseGraph) => Promise<{
-        ok: true;
-        graph: import('@wrongstack/core/goal').PhaseGraph;
-    } | {
-        ok: false;
-        error: string;
-    }>) | undefined;
-    /** Live, read-only view of the running Goal (null when idle). */
-    getGoalRunner?: () => {
-        graph: import('@wrongstack/core/goal').PhaseGraph;
-        getProgress: () => import('@wrongstack/core/goal').PhaseProgress | null;
-        isRunning: () => boolean;
-    } | null;
-    /** Interactive board: move a task to another phase (returns false when idle/invalid). */
-    onGoalMoveTask?: ((taskId: string, toPhaseId: string) => boolean) | undefined;
-    /** Interactive board: (re)assign a task to an agent (clear with both omitted). */
-    onGoalAssignTask?: ((taskId: string, agentId?: string, agentName?: string) => boolean) | undefined;
-    /** Interactive board: add a new task to a phase, returning its id (or null when idle). */
-    onGoalAddTask?: ((phaseId: string, spec: {
-        title: string;
-        description?: string;
-        type?: import('@wrongstack/core/types').TaskNode['type'];
-        priority?: import('@wrongstack/core/types').TaskNode['priority'];
-    }) => string | null) | undefined;
-    /** Interactive board: requeue a task to pending so it (re)runs. */
-    onGoalRetryTask?: ((taskId: string) => boolean) | undefined;
     /**
      * Manage git worktrees used for per-phase Goal isolation.
      * `list` shows current worktrees, `merge <branch>` squash-merges a branch

package/dist/slash-commands/project-switch-interactive.d.ts

@@ -0,0 +1,11 @@
+import type { Context } from '@wrongstack/core/agent';
+import type { SlashCommandContext } from './command-context.js';
+/**
+ * Check for running agents/brain/fleet and warn the user before switching.
+ * Returns `true` if the switch should proceed, `false` if cancelled.
+ */
+export declare function confirmProjectSwitch(opts: SlashCommandContext, targetName: string): Promise<boolean>;
+export declare function switchInteractiveCommand(opts: SlashCommandContext, ctx: Context | undefined): Promise<{
+    message: string;
+}>;
+//# sourceMappingURL=project-switch-interactive.d.ts.map

package/dist/slash-commands/setmodel-helpers.d.ts

@@ -0,0 +1,36 @@
+import type { ModelMatrixEntry, ProviderConfig } from '@wrongstack/core/types';
+/**
+ * Catalog model ids per provider, resolved through the same alias rules as the
+ * capability overlay so a gateway saved as `ai-gateway` reads the models.dev id
+ * that actually publishes it. Includes anything auto-discovery merged into the
+ * registry at boot. Best-effort: a missing or failing registry yields an empty
+ * map and callers fall back to the saved list.
+ */
+export declare function resolveCatalogModelIds(registry: import('@wrongstack/core/types').ModelsRegistry | undefined, config: import('@wrongstack/core/types').Config, providerIds: string[]): Promise<Map<string, string[]>>;
+/** Keep a 300-model gateway list readable in a terminal. */
+export declare function summarizeModelIds(ids: string[], limit?: number): string;
+/** A provider is selectable when it has a stored key, a key list, or a
+ *  populated env var. Mirrors `hasApiKey` but config-only (no registry). */
+export declare function providerHasKey(entry: ProviderConfig | undefined): boolean;
+/** Provider ids the user can target — those with a key, plus the active one. */
+export declare function keyedProviderIds(config: {
+    provider: string;
+    providers?: Record<string, ProviderConfig>;
+}): string[];
+/**
+ * Parse `<provider>/<model>`, `<provider> <model>`, or a bare `<model>`
+ * (provider omitted → leader provider at resolve time) into a matrix entry.
+ */
+export declare function parseTarget(tokens: string[], profiles?: Record<string, string[]>): ModelMatrixEntry | {
+    error: string;
+};
+export declare function isReasoningMode(value: string | undefined): value is 'auto' | 'on' | 'off';
+export declare function parseBoolWord(value: string | undefined): boolean | undefined;
+export declare function fmtEntry(e: ModelMatrixEntry): string;
+/**
+ * Read the active profile config, apply `mutate`, write it back atomically, and
+ * mirror the change into the in-memory config store. Pure I/O — safe under
+ * both the plain REPL and the Ink TUI.
+ */
+export declare function patchProfileConfig(mutate: (cfg: Record<string, unknown>) => void, profileConfigPath: string): Promise<Record<string, unknown>>;
+//# sourceMappingURL=setmodel-helpers.d.ts.map

package/dist/subcommands/handlers/hq-token.d.ts

@@ -0,0 +1,3 @@
+import type { SubcommandDeps } from '../contracts.js';
+export declare function hqTokenCmd(args: string[], deps: SubcommandDeps): Promise<number>;
+//# sourceMappingURL=hq-token.d.ts.map