@wrongstack/cli 0.309.0 → 0.310.0

package/dist/wiring/cli-slash-commands-setup.d.ts

@@ -1,86 +1,116 @@
+import type { Container } from '@wrongstack/core/kernel';
+import { createCommandHostAdapters } from './command-host-adapters.js';
+import { createEternalCommandHandlers } from './eternal-command-handlers.js';
+import { createFleetCommandHandlers } from './fleet-command-handlers.js';
+import { createSddHandlers } from './sdd-handlers.js';
+import { createSessionCommandHandlers } from './session-command-handlers.js';
+import { buildCommandHostSlashCommands } from './slash-commands.js';
+type B = Parameters<typeof buildCommandHostSlashCommands>[0];
+type A = Parameters<typeof createCommandHostAdapters>[0];
+type F = Parameters<typeof createFleetCommandHandlers>[0];
+type SE = Parameters<typeof createSessionCommandHandlers>[0];
+type E = Parameters<typeof createEternalCommandHandlers>[0];
+type SD = Parameters<typeof createSddHandlers>[0];
 export declare function setupCliSlashCommands(params: {
-    slashRegistry: any;
-    toolRegistry: any;
-    agent: any;
-    interruptController: any;
-    reader: any;
-    wpaths: any;
-    container: any;
-    sessionStore: any;
-    skillLoader: any;
-    tokenCounter: any;
-    renderer: any;
-    events: any;
-    memoryStore: any;
+    slashRegistry: B['registry'];
+    toolRegistry: B['toolRegistry'];
+    agent: A['agent'];
+    interruptController: NonNullable<B['interruptController']>;
+    reader: A['reader'];
+    wpaths: B['paths'];
+    container: Container;
+    sessionStore: B['sessionStore'];
+    skillLoader: B['skillLoader'];
+    tokenCounter: B['tokenCounter'];
+    renderer: B['renderer'];
+    events: B['events'];
+    memoryStore: B['memoryStore'];
     /**
      * Vector memory store (semantic recall channel). When supplied, the
      * `/memory diagnostics` and `/memory race` slash commands can
      * surface cross-system health and the lexical vs semantic channel
      * comparison.
      */
-    vectorMemoryStore?: any;
-    context: any;
+    vectorMemoryStore?: B['vectorMemoryStore'];
+    context: NonNullable<B['context']>;
     cwd: string;
     projectRoot: string;
-    metricsSink: any;
-    healthRegistry: any;
-    metricsStatus: any;
+    metricsSink: B['metricsSink'];
+    healthRegistry: B['healthRegistry'];
+    metricsStatus: B['metricsStatus'];
     planPath: string;
-    modeStore: any;
-    fleetStreamController: any;
-    enhanceController: any;
-    provider: any;
-    config: any;
-    buildProviderForId: (pid: string) => any;
-    statuslineConfigDeps: any;
-    getCurrentHiddenItems: () => any[];
-    setStatuslineHiddenItems: any;
-    saveStatuslineHiddenItems: any;
-    agentsMonitorController: any;
-    agentMonitor: any;
-    onPanelOpen: any;
-    configStore: any;
-    secretInputController: any;
-    vault: any;
-    brain: any;
-    brainSettings: any;
-    brainRuntime: any;
-    brainLog: any;
-    coordinatorController: any;
-    statusTracker: any;
-    shadowController: any;
-    multiAgentHost: any;
-    director: any;
-    sessionRef: any;
-    session: any;
+    modeStore: B['modeStore'];
+    fleetStreamController: B['fleetStreamController'];
+    enhanceController: B['enhanceController'];
+    provider: B['llmProvider'];
+    config: SD['config'];
+    buildProviderForId: NonNullable<B['createProvider']>;
+    statuslineConfigDeps: B['statuslineConfig'];
+    getCurrentHiddenItems: () => NonNullable<B['statuslineHiddenItems']>;
+    setStatuslineHiddenItems: NonNullable<B['setStatuslineHiddenItems']>;
+    saveStatuslineHiddenItems: NonNullable<B['saveStatuslineHiddenItems']>;
+    agentsMonitorController: B['agentsMonitorController'];
+    agentMonitor: B['agentMonitor'];
+    onPanelOpen: B['onPanelOpen'];
+    configStore: B['configStore'];
+    secretInputController: {
+        readSecret: NonNullable<B['readSecret']>;
+        readText: NonNullable<B['readText']>;
+    };
+    vault: B['vault'];
+    brain: B['brain'];
+    brainSettings: B['brainSettings'];
+    brainRuntime: B['brainRuntime'];
+    initialBrainLog: ReturnType<NonNullable<B['getBrainLog']>>;
+    coordinatorController: B['coordinatorController'];
+    statusTracker: B['statusTracker'];
+    shadowController: B['shadowController'];
+    multiAgentHost: F['multiAgentHost'];
+    director: ReturnType<F['getDirector']>;
+    sessionRef: SD['sessionRef'];
+    session: SD['session'];
     fleetRootForPromotion: string;
     profileConfigPath: string;
-    effectiveMaxContextRef: any;
-    autoCompactor: any;
-    eventWiring: any;
-    mcpRegistry: any;
-    setYoloMode: (setTo?: boolean) => boolean;
-    getNextPredict: () => boolean;
-    setNextPredict: (enabled: boolean) => void;
-    getCurrentSuggestions: () => any;
-    setCurrentSuggestions: (s: any) => void;
-    teardownHandlers: Array<() => void>;
-    pluginHost: any;
-    logger: any;
-    flags: any;
-    errorRing: any;
-    stats: any;
-    broadcastEternalIteration: any;
-    broadcastAutonomyStage: any;
-    getAutonomyMode: () => any;
-    setAutonomyMode: (m: any) => void;
-    autonomyModeRef: any;
-    getEternalEngine: () => any;
-    setEternalEngine: (e: any) => void;
-    getParallelEngine: () => any;
-    setParallelEngine: (e: any) => void;
-    sddRunRegistry: any;
-    goalHost: any;
-    setConfig: (cfg: any) => void;
+    effectiveMaxContextRef: SE['effectiveMaxContext'];
+    autoCompactor: SE['autoCompactor'];
+    eventWiring: {
+        setEffectiveMaxContext: SE['setEventMaxContext'];
+    };
+    mcpRegistry: SE['mcpRegistry'];
+    setYoloMode: SE['onYolo'];
+    getNextPredict: SE['getNextPredict'];
+    setNextPredict: SE['setNextPredict'];
+    getCurrentSuggestions: SE['getCurrentSuggestions'];
+    setCurrentSuggestions: SE['setCurrentSuggestions'];
+    teardownHandlers: SE['teardownHandlers'];
+    pluginHost: SE['pluginHost'];
+    logger: SD['logger'];
+    flags: SE['flags'];
+    errorRing: SE['errorRing'];
+    stats: SE['stats'];
+    broadcastEternalIteration: E['onIteration'];
+    broadcastAutonomyStage: E['onStage'];
+    getAutonomyMode: E['getAutonomyMode'];
+    setAutonomyMode: E['setAutonomyMode'];
+    autonomyModeRef: E['autonomyModeRef'];
+    getEternalEngine: E['getEternalEngine'];
+    setEternalEngine: E['setEternalEngine'];
+    getParallelEngine: E['getParallelEngine'];
+    setParallelEngine: E['setParallelEngine'];
+    sddRunRegistry: SD['sddRunRegistry'];
+    goalHost?: {
+        onGoalStart: NonNullable<B['onGoalStart']>;
+        onGoalPause: NonNullable<B['onGoalPause']>;
+        onGoalResume: NonNullable<B['onGoalResume']>;
+        onGoalStop: NonNullable<B['onGoalStop']>;
+        getGoalRunner: NonNullable<B['getGoalRunner']>;
+        onGoalMoveTask: NonNullable<B['onGoalMoveTask']>;
+        onGoalAssignTask: NonNullable<B['onGoalAssignTask']>;
+        onGoalAddTask: NonNullable<B['onGoalAddTask']>;
+        onGoalRetryTask: NonNullable<B['onGoalRetryTask']>;
+        onWorktree: NonNullable<B['onWorktree']>;
+    };
+    setConfig: SE['setConfig'];
 }): void;
+export {};
 //# sourceMappingURL=cli-slash-commands-setup.d.ts.map

package/dist/wiring/director-announcement.d.ts

@@ -0,0 +1,31 @@
+import type { Director } from '@wrongstack/core/coordination';
+import type { ToolRegistry } from '@wrongstack/core/registry';
+import type { MultiAgentHost } from '../fleet/host.js';
+/**
+ * Phase: director activation + announcement (card #7C slice 4).
+ *
+ * Verbatim extraction of the cli-main.ts director block: resolves the Director
+ * from the multi-agent host, restores any fleet checkpoint state, registers
+ * the roster tools, and prints the mode announcement (short line for browser
+ * surfaces, full paths for the terminal; budget summary only when resuming
+ * from a checkpoint so fresh starts stay quiet).
+ *
+ * Returns the resolved Director (or null when Director mode is disabled) so
+ * the composition root keeps owning the mutable `director` binding.
+ */
+export declare function ensureDirectorAndAnnounce(args: {
+    multiAgentHost: MultiAgentHost;
+    /** Fleet checkpoint restored from the resumed session, if any. */
+    priorFleetState: Parameters<Director['setCheckpointState']>[0] | undefined;
+    renderer: {
+        writeInfo(msg: string): void;
+    };
+    toolRegistry: ToolRegistry;
+    flags: Record<string, unknown>;
+    /** Fleet paths are optional in DirectorAutonomyResult; the announcement prints them verbatim. */
+    fleetRoot: string | undefined;
+    manifestPath: string | undefined;
+    sharedScratchpadPath: string | undefined;
+    subagentSessionsRoot: string | undefined;
+}): Promise<Director | null>;
+//# sourceMappingURL=director-announcement.d.ts.map

package/dist/wiring/session-establishment.d.ts

@@ -0,0 +1,45 @@
+import type { CliContext } from '../cli-context.js';
+import type { loadOnlineAgentsForPrompt } from '../cli-main-helpers.js';
+import { setupSession } from './session.js';
+export interface SessionEstablishmentArgs {
+    /** Container used to resolve SessionStore + TokenCounter. */
+    container: Pick<CliContext['container'], 'resolve'>;
+    config: {
+        provider: string;
+        model: string;
+    };
+    wpaths: Parameters<typeof setupSession>[0]['wpaths'];
+    projectRoot: string;
+    cwd: string;
+    systemPrompt: Parameters<typeof setupSession>[0]['systemPrompt'];
+    provider: Parameters<typeof setupSession>[0]['provider'];
+    renderer: Parameters<typeof setupSession>[0]['renderer'];
+    flags: Parameters<typeof setupSession>[0]['flags'];
+    events: NonNullable<Parameters<typeof setupSession>[0]['events']>;
+    logger: Parameters<typeof setupSession>[0]['logger'];
+    /** Live ref so /resume writer swaps are picked up without re-wiring. */
+    sessionRef: {
+        current: {
+            id?: string;
+            flushSync?: () => void;
+        } | undefined;
+    };
+    onlineAgents: Awaited<ReturnType<typeof loadOnlineAgentsForPrompt>>;
+    /** Owned by the teardown-registrar phase; consumed here for clientType. */
+    tuiOwnsScreen: boolean;
+}
+export declare function setupSessionEstablishment(args: SessionEstablishmentArgs): Promise<{
+    sessionStore: import("@wrongstack/core").SessionStore;
+    tokenCounter: import("@wrongstack/core").TokenCounter;
+    context: import("@wrongstack/core").Context;
+    planPath: string;
+    session: import("@wrongstack/core").SessionWriter;
+    attachments: import("@wrongstack/core/storage").DefaultAttachmentStore;
+    queueStore: import("@wrongstack/core/storage").QueueStore;
+    detachTodosCheckpoint: () => void | Promise<void>;
+    priorFleetState: import("@wrongstack/core/storage").DirectorStateSnapshot | undefined;
+    /** Full SessionResult, passed through for downstream consumers
+     *  (runCliExecution, multi-agent setup read traceId/resumed* off it). */
+    sessResult: import("./session.js").SessionResult;
+}>;
+//# sourceMappingURL=session-establishment.d.ts.map

package/dist/wiring/session-registry.d.ts

@@ -20,7 +20,7 @@ export interface SetupSessionRegistryDeps {
 }
 export interface SetupSessionRegistryResult {
     /** AgentStatusTracker when the dynamic import and setup succeeded, else undefined. */
-    tracker: InstanceType<typeof import('@wrongstack/core/storage').AgentStatusTracker> | undefined;
+    tracker: InstanceType<typeof import('@wrongstack/core/coordination').AgentStatusTracker> | undefined;
     /**
      * Atomically move this process's registry ownership to another session.
      * Used by explicit resume; unrelated sessions in other processes are untouched.

package/dist/wiring/session-runtime.d.ts

@@ -0,0 +1,64 @@
+/**
+ * Session-runtime wiring for the interactive CLI (card #7C slice 4).
+ *
+ * Extracted verbatim from cli-main.ts. Owns the post-establishment session
+ * surface:
+ *
+ * - `wireSessionEvents` (error ring, session bridge, chronicle) plus the
+ *   `process.once('beforeExit')` hook that flushes the chronicle on the way
+ *   out — the last teardown hook that lived inline in the orchestrator.
+ * - `SessionStats` fed by the shared EventBus + token counter.
+ * - The active reasoning-config refresher (best-effort modelsRegistry lookup)
+ *   and the warning-dedup set behind `model-runtime` pipeline warnings.
+ * - `setupPipelines` with the modelRuntime overlay, then the governance
+ *   tool-boundary install when replay-governance is active.
+ *
+ * `getActiveReasoningConfig()` exposes the CURRENT reasoning config exactly
+ * the way the orchestrator's inline `let` did when `runCliExecution` read it
+ * by value at call time.
+ */
+import type { Context } from '@wrongstack/core/agent';
+import type { Provider } from '@wrongstack/core/types';
+import type { CliContext } from '../cli-context.js';
+import { wireSessionEvents } from '../session-event-wiring.js';
+import { SessionStats } from '../session-stats.js';
+import type { setupReplayAndGovernance } from './replay-governance-setup.js';
+type WireArgs = Parameters<typeof wireSessionEvents>[0];
+type GovernanceHandle = Awaited<ReturnType<typeof setupReplayAndGovernance>>['governanceHandle'];
+export interface SessionRuntimeArgs {
+    evOn: WireArgs['evOn'];
+    events: NonNullable<WireArgs['events']>;
+    /** Live config binding; provider/model are read once at setup time. */
+    config: CliContext['config'];
+    context: Context;
+    session: WireArgs['session'];
+    sessionRef: WireArgs['sessionRef'];
+    wpaths: WireArgs['wpaths'];
+    projectRoot: WireArgs['projectRoot'];
+    renderer: NonNullable<WireArgs['renderer']>;
+    tuiOwnsScreen: boolean;
+    tokenCounter: ConstructorParameters<typeof SessionStats>[1];
+    modelsRegistry: CliContext['modelsRegistry'];
+    configStore: CliContext['configStore'];
+    provider: {
+        capabilities: Provider['capabilities'];
+    };
+    logger: CliContext['logger'];
+    governanceHandle: GovernanceHandle;
+}
+export declare function setupSessionRuntime(args: SessionRuntimeArgs): {
+    errorRing: import("../session-event-wiring.js").ErrorEntry[];
+    sessionBridge: import("@wrongstack/core").SessionEventBridge;
+    stats: SessionStats;
+    pipelines: import("@wrongstack/core/agent").AgentPipelines;
+    refreshActiveReasoningConfig: (providerId: string, modelId: string) => Promise<void>;
+    getActiveReasoningConfig: () => import("@wrongstack/core/types").ReasoningConfig | undefined;
+    /**
+     * Lifecycle registration is intentionally NOT done here — this module is
+     * reusable and must not install process-level hooks (chimera review).
+     * The composition root owns `process.once('beforeExit', ...)` wiring.
+     */
+    disposeChronicle: () => Promise<void>;
+};
+export {};
+//# sourceMappingURL=session-runtime.d.ts.map

package/dist/wiring/teardown-registrar.d.ts

@@ -0,0 +1,41 @@
+/**
+ * Teardown-registrar phase (card #7C-2), extracted verbatim from
+ * `cli-main.ts` (was lines 164-179).
+ *
+ * Two concerns that must stay together because of the LIFO teardown
+ * contract:
+ *
+ * 1. `createTeardownEventRegistrar` wraps `events` so event-driven
+ *    subscriptions unregister themselves on shutdown (their disposers go
+ *    to the same chain).
+ * 2. The vector-memory SQLite `close()` teardown is pushed *after* the
+ *    registrar — in the original file the store-close push sat at line
+ *    170, after the mirror-dispose push at line 168 from the setup
+ *    phase, so on LIFO teardown close runs before the mirror dispose.
+ *    Keeping this registration inside the same function preserves that
+ *    exact ordering; moving it back into the setup phase would invert
+ *    the shutdown sequence.
+ *
+ * `tuiOwnsScreen` is resolved here as well (was line 164): it derives
+ * purely from flags and is consumed by the event wiring below.
+ */
+import type { VectorMemoryStore } from '@wrongstack/vector-memory';
+import { createTeardownEventRegistrar } from '../cli-main-helpers.js';
+export interface TeardownRegistrarArgs {
+    flags: {
+        tui?: unknown;
+        'no-tui'?: unknown;
+    };
+    events: Parameters<typeof createTeardownEventRegistrar>[0];
+    logger: {
+        debug?: (message: string) => void;
+    };
+    teardownHandlers: Array<() => void>;
+    vectorMemoryStore: VectorMemoryStore | undefined;
+}
+export interface TeardownRegistrarResult {
+    tuiOwnsScreen: boolean;
+    evOn: ReturnType<typeof createTeardownEventRegistrar>;
+}
+export declare function setupTeardownRegistrar(args: TeardownRegistrarArgs): TeardownRegistrarResult;
+//# sourceMappingURL=teardown-registrar.d.ts.map

package/dist/wiring/vector-memory-setup.d.ts

@@ -0,0 +1,30 @@
+import type { MemoryPort } from '@wrongstack/core/types';
+import { VectorMemoryStore } from '@wrongstack/vector-memory';
+export interface VectorMemoryArgs {
+    projectRoot: string;
+    flags: {
+        'vector-sync'?: unknown;
+    };
+    logger: {
+        warn: (message: string) => void;
+        info: (message: string) => void;
+        debug?: (message: string) => void;
+    };
+    /** The SAGE memory port; returned wrapped when the vector store comes up. */
+    memoryStore: MemoryPort;
+    /** Disposer chain; the mirror-dispose handler is pushed from inside. */
+    teardownHandlers: Array<() => void>;
+}
+export interface VectorMemoryResult {
+    memoryStore: MemoryPort;
+    vectorMemoryStore: VectorMemoryStore | undefined;
+    /**
+     * Model-cache directory (`.wrongstack/cache/transformers-models` under the
+     * project root). Surfaced because `session-start-payload` advertises the
+     * cache location to the WebUI — callers pass it onward (original
+     * cli-main.ts line 801 shorthand).
+     */
+    vectorMemoryModelCacheDir: string;
+}
+export declare function setupVectorMemory(args: VectorMemoryArgs): Promise<VectorMemoryResult>;
+//# sourceMappingURL=vector-memory-setup.d.ts.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@wrongstack/cli",
-  "version": "0.309.0",
+  "version": "0.310.0",
   "license": "MIT",
   "description": "WrongStack CLI — terminal AI coding agent with provider catalog from models.dev. Provides `wrongstack` and `wstack` binaries.",
   "keywords": [
@@ -42,32 +42,34 @@
   ],
   "dependencies": {
     "ws": "^8.21.3",
-    "@wrongstack/acp": "0.309.0",
-    "@wrongstack/core": "0.309.0",
-    "@wrongstack/kanban": "0.309.0",
-    "@wrongstack/bench": "0.309.0",
-    "@wrongstack/mcp": "0.309.0",
-    "@wrongstack/providers": "0.309.0",
-    "@wrongstack/requirement-intake": "0.309.0",
-    "@wrongstack/persistence": "0.309.0",
-    "@wrongstack/plug-lsp": "0.309.0",
-    "@wrongstack/sage": "0.309.0",
-    "@wrongstack/runtime": "0.309.0",
-    "@wrongstack/plugins": "0.309.0",
-    "@wrongstack/security-scanner": "0.309.0",
-    "@wrongstack/simpleui": "0.309.0",
-    "@wrongstack/sdd": "0.309.0",
-    "@wrongstack/telegram": "0.309.0",
-    "@wrongstack/techstack": "0.309.0",
-    "@wrongstack/tui": "0.309.0",
-    "@wrongstack/tools": "0.309.0",
-    "@wrongstack/vector-memory": "0.309.0",
-    "@wrongstack/webui": "0.309.0",
-    "@wrongstack/webui-hq": "0.309.0",
-    "@wrongstack/webui-server": "0.309.0"
+    "@wrongstack/acp": "0.310.0",
+    "@wrongstack/bench": "0.310.0",
+    "@wrongstack/core": "0.310.0",
+    "@wrongstack/persistence": "0.310.0",
+    "@wrongstack/kanban": "0.310.0",
+    "@wrongstack/plugins": "0.310.0",
+    "@wrongstack/plug-lsp": "0.310.0",
+    "@wrongstack/primitives": "0.310.0",
+    "@wrongstack/providers": "0.310.0",
+    "@wrongstack/runtime": "0.310.0",
+    "@wrongstack/sdd": "0.310.0",
+    "@wrongstack/mcp": "0.310.0",
+    "@wrongstack/requirement-intake": "0.310.0",
+    "@wrongstack/sage": "0.310.0",
+    "@wrongstack/security-scanner": "0.310.0",
+    "@wrongstack/techstack": "0.310.0",
+    "@wrongstack/telegram": "0.310.0",
+    "@wrongstack/simpleui": "0.310.0",
+    "@wrongstack/vector-memory": "0.310.0",
+    "@wrongstack/tools": "0.310.0",
+    "@wrongstack/webui": "0.310.0",
+    "@wrongstack/webui-server": "0.310.0",
+    "@wrongstack/webui-hq": "0.310.0",
+    "@wrongstack/tui": "0.310.0",
+    "@wrongstack/webui-protocol": "0.310.0"
   },
   "optionalDependencies": {
-    "@wrongstack/desktop": "0.309.0"
+    "@wrongstack/desktop": "0.310.0"
   },
   "devDependencies": {
     "@types/node": "^26.2.0",