@wrongstack/cli 0.308.7 → 0.309.1

package/dist/diff-renderer.d.ts

@@ -1,2 +1,19 @@
+/**
+ * Colorize a single already-sanitized diff line.
+ *
+ * Exported so callers that must sanitize untrusted text themselves can apply
+ * the styling AFTER sanitizing — sanitizing colorized text would strip the
+ * colors, and colorizing before sanitizing would leave the untrusted escape
+ * sequences in place. See `permission-prompt.ts`.
+ */
+export declare function diffLineStyle(line: string): string;
+/**
+ * Render a diff for terminal display.
+ *
+ * The diff body can carry model-supplied or file-supplied text, so it is
+ * sanitized before styling: a raw `\x1b[2J\x1b[H` in a diff line clears the
+ * screen and lets a payload repaint the surrounding UI — including an approval
+ * prompt's header.
+ */
 export declare function renderDiff(diff: string): string;
 //# sourceMappingURL=diff-renderer.d.ts.map

package/dist/{execution-6HIKTAUB.js → execution-TYUXABWI.js}

@@ -2203,7 +2203,15 @@ function applyChimeraReviewerReadOnlyPolicy(config) {
     // mutation tools/capabilities so Chimera reviewers cannot repair files.
     tools: [...CHIMERA_REVIEW_READ_ONLY_TOOLS],
     allowedCapabilities: ["fs.read"],
-    worktree: "off"
+    worktree: "off",
+    // Mandatory model-driven completion: a reviewer must never be killed by
+    // the wall-clock watchdog. At its deadline (or when the leader's session
+    // ends and `Director.requestFinish()` fires) it receives an in-band
+    // `subagent.finish_requested` notification between tool batches and
+    // finishes its report in its own turn within the granted grace window.
+    // Only if that window also elapses does the terminal stop apply — the
+    // reviewer's bounded maximum lifetime.
+    gracefulFinish: true
   };
 }
 
@@ -2284,10 +2292,30 @@ async function finalizeExecutionCleanup(input) {
       sessionEndProducers.add(tracked);
     }
   });
+  if (director) {
+    try {
+      director.requestFinish("leader session ended \u2014 finish your review now");
+    } catch (finishErr) {
+      console.warn(
+        JSON.stringify({
+          level: "warn",
+          event: "shutdown.subagent_finish_notify_failed",
+          message: finishErr instanceof Error ? finishErr.message : String(finishErr),
+          timestamp: (/* @__PURE__ */ new Date()).toISOString()
+        })
+      );
+    }
+  }
   try {
     while (sessionEndProducers.size > 0) {
       await Promise.allSettled([...sessionEndProducers]);
     }
+    if (director) {
+      try {
+        director.requestFinish("leader session ended \u2014 finish your review now");
+      } catch {
+      }
+    }
     await chimeraWork?.drainAndClose();
   } catch (err) {
     console.warn(
@@ -2300,6 +2328,18 @@ async function finalizeExecutionCleanup(input) {
     );
   }
   if (director) {
+    try {
+      director.requestFinish("leader session ended \u2014 finish your review now");
+    } catch (finishErr) {
+      console.warn(
+        JSON.stringify({
+          level: "warn",
+          event: "shutdown.subagent_finish_notify_failed",
+          message: finishErr instanceof Error ? finishErr.message : String(finishErr),
+          timestamp: (/* @__PURE__ */ new Date()).toISOString()
+        })
+      );
+    }
     try {
       await director.terminateAll();
     } catch (termErr) {
@@ -3212,6 +3252,15 @@ function installChimeraCascadeHandler({
               // Cascade agents are ephemeral infrastructure: like reviewers,
               // they must not consume the leader's lifetime maxSpawns budget.
               spawnBudgetExempt: true,
+              // Model-driven completion (see core coordination/subagent-finish.ts):
+              // a rung crossing its wall-clock budget is notified in-band
+              // between tool batches and finishes its own turn within the
+              // grace window instead of being killed. Ladder-retry semantics
+              // are intact: a rung that still exhausts the grace window lands
+              // as a `timeout` task result, which advances the ladder, and
+              // `buildRetryPreamble` below already warns the successor that
+              // the tree may hold the dead rung's partial edits.
+              gracefulFinish: true,
               // Rung 0 stays unpinned so the role model matrix still decides;
               // later rungs pin a model precisely because it just failed.
               ...attempt.tier === "inherit" ? {} : {
@@ -6045,4 +6094,4 @@ export {
   execute,
   resolveReviewerFallbackModels
 };
-//# sourceMappingURL=execution-6HIKTAUB.js.map
+//# sourceMappingURL=execution-TYUXABWI.js.map

package/dist/index.js

@@ -6,7 +6,7 @@ import {
   makePromptDelegate,
   renderAgentsTemplate,
   renderDiff
-} from "./chunk-DOJLAULS.js";
+} from "./chunk-WOTGMHAH.js";
 import {
   theme
 } from "./chunk-QD544J2B.js";
@@ -1849,9 +1849,9 @@ var subcommandsWithFocusedHelp = Object.keys(helpTable);
 
 // src/subcommands/index.ts
 var loaders = {
-  acp: async () => (await import("./acp-5ZLGFHWP.js")).acpCmd,
+  acp: async () => (await import("./acp-7NWCC2GO.js")).acpCmd,
   init: async () => (await import("./init-E2NDDOHI.js")).initCmd,
-  auth: async () => (await import("./auth-WOKC2RVG.js")).authCmd,
+  auth: async () => (await import("./auth-GZ2FK5KR.js")).authCmd,
   update: async () => (await import("./update-VZSOZGYC.js")).updateCmd,
   sessions: async () => (await import("./sessions-config-YX2ZPAFM.js")).sessionsCmd,
   config: async () => (await import("./sessions-config-YX2ZPAFM.js")).configCmd,
@@ -1860,8 +1860,8 @@ var loaders = {
   audit: async () => (await import("./audit-BBR22QH3.js")).auditCmd,
   tools: async () => (await import("./tools-skills-UNKLOB7M.js")).toolsCmd,
   skills: async () => (await import("./tools-skills-UNKLOB7M.js")).skillsCmd,
-  providers: async () => (await import("./providers-models-4FAKM2WO.js")).providersCmd,
-  models: async () => (await import("./providers-models-4FAKM2WO.js")).modelsCmd,
+  providers: async () => (await import("./providers-models-D23WUD74.js")).providersCmd,
+  models: async () => (await import("./providers-models-D23WUD74.js")).modelsCmd,
   mcp: async () => (await import("./mcp-CMLFHRG2.js")).mcpCmd,
   plugin: async () => (await import("./plugin-usage-26LIIW3P.js")).pluginCmd,
   plugins: async () => (await import("./plugin-usage-26LIIW3P.js")).pluginCmd,
@@ -4466,7 +4466,7 @@ async function initializeCli(argv) {
 async function main(argv) {
   const cliCtx = await initializeCli(argv);
   if (typeof cliCtx === "number") return cliCtx;
-  const { runInteractive } = await import("./cli-main-L3T4KJKU.js");
+  const { runInteractive } = await import("./cli-main-XGDOIPN5.js");
   return runInteractive(cliCtx);
 }
 

package/dist/{providers-models-4FAKM2WO.js → providers-models-D23WUD74.js}

@@ -496,7 +496,7 @@ async function modelsCaps(args, deps) {
       "    disable:    " + (rc.disableSupported ? "supported" : "unsupported") + "\n"
     );
     deps.renderer.write(
-      "    effort:     " + (rc.effortSupported ? rc.effortLevels.join(", ") : "unsupported") + "\n"
+      "    effort:     " + (rc.effortSupported === void 0 ? "not enumerated (model reasons; any level forwarded)" : rc.effortSupported ? rc.effortLevels.join(", ") : "unsupported") + "\n"
     );
     deps.renderer.write("    preserve:   " + rc.preserveThinking + "\n");
   } else if (caps.reasoning) {
@@ -661,4 +661,4 @@ export {
   modelsCmd,
   providersCmd
 };
-//# sourceMappingURL=providers-models-4FAKM2WO.js.map
+//# sourceMappingURL=providers-models-D23WUD74.js.map

package/dist/slash-commands/dev.d.ts

@@ -1,5 +1,55 @@
 import type { SlashCommand } from '@wrongstack/core/types';
 import type { SlashCommandContext } from './command-context.js';
+export interface DevCommandResult {
+    stdout: string;
+    stderr: string;
+    exitCode: number;
+    /** True when the process died from a signal (timeout kill or foreign). */
+    killed: boolean;
+    /** True when the program never started (not found / not executable /
+     *  refused by the Windows shim builder). Rendered as SPAWN ERROR. */
+    spawnFailed: boolean;
+    /** Signal name when the process died from a signal (e.g. SIGTERM). */
+    signalName?: string | undefined;
+    /** True only when killed by the /dev timeout itself — not by a foreign
+     *  signal. The distinction matters: both arrive at `close(null, signal)`,
+     *  but only the former is a TIMEOUT. */
+    timedOut?: boolean | undefined;
+}
+/**
+ * Split a command line into program + argv, honoring single quotes, double
+ * quotes, and backslash escapes. Deliberately NOT a shell: no variable
+ * expansion, no globbing, no operators. Tokens are passed verbatim to a
+ * shell-less spawn — which is what makes `&`, `|`, `;` inert on POSIX
+ * (BIZ-001: the old code passed the whole string as one argv element, so
+ * every command with arguments ENOENT'd) and lets the win32 shim builder
+ * validate each token individually.
+ *
+ * Backslash handling is platform-aware (chimera follow-up to BIZ-002). On
+ * POSIX, OUTSIDE quotes `\` escapes the next character (shell convention);
+ * INSIDE double quotes it escapes only the four chars bash treats specially
+ * there (" \ $ `) plus newline-continuation, and is literal otherwise. On
+ * Windows it is the path separator and MUST stay literal everywhere —
+ * treating it as an escape silently corrupted `C:\Users\foo` into
+ * `C:Usersfoo`, defeating the very path-separator fix BIZ-002 made. Inside
+ * single quotes everything is literal on both platforms.
+ *
+ * Throws on an unterminated quoted argument.
+ */
+export declare function tokenizeCommand(command: string, platform?: NodeJS.Platform): string[];
+/**
+ * Run `/dev <command>` without a shell on POSIX and through the canonical
+ * hardened cmd.exe shim on Windows.
+ *
+ * - POSIX: `spawn(program, args, { shell: false })` — metacharacters are
+ *   literal argv, so `/dev git diff --stat` actually runs (BIZ-001).
+ * - Windows: Node cannot spawn `.cmd`/`.bat` shims without a shell
+ *   (CVE-2024-27980), so the invocation goes through
+ *   {@link buildWin32CmdShimInvocation}, which quotes every token and refuses
+ *   the real cmd.exe operators (`& | < > " %`, newlines) outright. Path
+ *   separators are no longer blocked — they are not operators (BIZ-002).
+ */
+export declare function runCommand(cmd: string, cwd: string, timeout?: number): Promise<DevCommandResult>;
 /**
  * `/dev <shell command>` — execute a shell command from the chat input and
  * display its output. The LLM does NOT see the result — this is a developer

package/dist/slash-commands/effort.d.ts

@@ -0,0 +1,33 @@
+import { type ReasoningEffort, type SlashCommand } from '@wrongstack/core/types';
+import type { SlashCommandContext } from './command-context.js';
+import type { WstackPaths } from '@wrongstack/core/utils';
+/**
+ * `/effort` — view or set the SESSION-WIDE reasoning effort applied to the
+ * active leader model. This is the quick, discoverable front-end for
+ * `Config.modelRuntime.reasoning.effort` — the same field `/settings
+ * reasoning-effort` writes and the WebUI "Reasoning effort" dropdown edits.
+ *
+ * Distinct from `/setmodel reasoning-effort <key>`, which pins effort onto a
+ * model-matrix entry (role/phase/*) for spawned subagents.
+ *
+ * Model-aware: when the active model's catalog entry advertises
+ * `effortLevels`, only those values are accepted and the view highlights the
+ * supported set. When capabilities are unknown, any canonical value is
+ * accepted (the runtime resolver drops unsupported values with a warning
+ * instead of erroring), and the view says so.
+ *
+ * Subcommands:
+ *   (none)        Show current effort, model-supported levels, and usage.
+ *   <level>       Set the session effort.
+ *   clear         Remove the setting (provider default applies).
+ *   matrix        Show per-key (role/phase/*) effort overrides, if any.
+ */
+export declare function buildEffortCommand(opts: SlashCommandContext): SlashCommand;
+/**
+ * Persist `Config.modelRuntime.reasoning.effort` to the active profile config.
+ * `undefined` removes the key entirely (JSON has no undefined). Uses the same
+ * read → decrypt → mutate → encrypt → atomicWrite cycle as `/setmodel` and
+ * `persistConfigSetting` so encrypted secrets round-trip byte-for-byte.
+ */
+export declare function patchSessionEffort(effort: ReasoningEffort | undefined, paths: WstackPaths, activeProfile: string): Promise<void>;
+//# sourceMappingURL=effort.d.ts.map

package/dist/wiring/cli-execute-builder.d.ts

@@ -1,90 +1,115 @@
+import { gatedEnhancerReasoning } from '@wrongstack/core/execution';
+import type { Container } from '@wrongstack/core/kernel';
+import type { Logger } from '@wrongstack/core/types';
+import { createAuthPanelHost } from '../auth-menu/panel-service.js';
+import type { CliGovernanceRuntimeHandle } from '../cli-main-helpers.js';
+import type { MultiAgentHost } from '../fleet/host.js';
+import { createRuntimeControllerDeps } from './runtime-controller-deps.js';
+import { createRuntimeLifecycleDeps } from './runtime-lifecycle-deps.js';
+import { createRuntimePickerDeps } from './runtime-picker-deps.js';
+import { toExecuteDeps } from './to-execute-deps.js';
+type X = Parameters<typeof toExecuteDeps>[0];
+type RC = Parameters<typeof createRuntimeControllerDeps>[0];
+type RP = Parameters<typeof createRuntimePickerDeps>[0];
+type RL = Parameters<typeof createRuntimeLifecycleDeps>[0];
+type AUP = Parameters<typeof createAuthPanelHost>[0];
 export declare function runCliExecution(params: {
-    agent: any;
-    events: any;
-    slashRegistry: any;
-    tokenCounter: any;
-    sessionRef: any;
-    activateSession: any;
-    config: any;
-    configStore: any;
-    wpaths: any;
+    agent: X['core']['agent'];
+    events: X['core']['events'];
+    slashRegistry: X['core']['slashRegistry'];
+    tokenCounter: X['core']['tokenCounter'];
+    sessionRef: NonNullable<X['core']['sessionRef']>;
+    activateSession: X['core']['activateSessionIdentity'];
+    config: X['core']['config'];
+    configStore: X['core']['configStore'];
+    wpaths: X['core']['wpaths'];
     projectRoot: string;
-    flags: any;
-    positional: any;
-    webuiSessionChild: any;
-    updateInfo: any;
-    attachments: any;
-    brainMailbox: any;
-    session: any;
-    mcpRegistry: any;
-    queueStore: any;
-    context: any;
-    detachTodosCheckpoint: any;
-    sessResult: any;
-    sessionStore: any;
-    memoryStore: any;
-    vectorMemoryStore: any;
-    vectorMemoryModelCacheDir: any;
-    modeStore: any;
-    needsSetup: any;
-    statusTracker: any;
-    multiAgentHost: any;
-    modelsRegistry: any;
-    savedProviderCfg: any;
-    resolvedProvider: any;
-    logger: any;
-    switchProviderAndModel: any;
-    applyMaxContext: any;
-    renderer: any;
-    reader: any;
-    secretInputController: any;
-    effectiveMaxContextRef: any;
-    stats: any;
-    skillLoader: any;
-    promptLoader: any;
-    modeId: any;
-    director: any;
-    coordinatorController: any;
-    fleetStreamController: any;
-    agentTranscripts?: any;
-    agentMonitor?: any;
-    vault: any;
+    flags: X['core']['flags'];
+    positional: X['core']['positional'];
+    webuiSessionChild: X['core']['webuiSessionChild'];
+    updateInfo: X['core']['updateInfo'];
+    attachments: X['session']['attachments'];
+    brainMailbox: X['session']['mailbox'];
+    session: X['session']['session'];
+    mcpRegistry: X['session']['mcpRegistry'];
+    queueStore: X['session']['queueStore'];
+    context: X['session']['context'];
+    detachTodosCheckpoint: X['session']['detachTodosCheckpoint'];
+    sessResult: {
+        rebindTodosCheckpoint: X['session']['rebindTodosCheckpoint'];
+        restoredMessages: X['session']['restoredMessages'];
+        restoredToolCalls: X['session']['restoredToolCalls'];
+        restoredEvents: X['session']['restoredEvents'];
+    };
+    sessionStore: X['session']['sessionStore'];
+    memoryStore: NonNullable<X['session']['memoryStore']>;
+    vectorMemoryStore: X['session']['vectorMemoryStore'];
+    vectorMemoryModelCacheDir: X['session']['vectorMemoryModelCacheDir'];
+    modeStore: X['session']['modeStore'];
+    needsSetup: X['session']['needsSetup'];
+    statusTracker: X['provider']['statusTracker'];
+    multiAgentHost: MultiAgentHost;
+    modelsRegistry: X['provider']['modelsRegistry'];
+    savedProviderCfg: X['provider']['savedProviderCfg'];
+    resolvedProvider: X['provider']['resolvedProvider'];
+    logger: Logger;
+    switchProviderAndModel: X['provider']['switchProviderAndModel'];
+    applyMaxContext: NonNullable<X['provider']['onModelContextResolved']>;
+    renderer: X['ui']['renderer'];
+    reader: X['ui']['reader'];
+    secretInputController: X['ui']['secretInputController'];
+    effectiveMaxContextRef: {
+        readonly current: X['ui']['effectiveMaxContext'];
+    };
+    stats: X['ui']['stats'];
+    skillLoader: X['ui']['skillLoader'];
+    promptLoader: X['ui']['promptLoader'];
+    modeId: X['ui']['modeId'];
+    director: X['fleet']['director'];
+    coordinatorController: X['fleet']['coordinatorController'];
+    fleetStreamController: X['fleet']['fleetStreamController'];
+    agentTranscripts?: X['fleet']['agentTranscripts'];
+    agentMonitor?: X['fleet']['agentTranscripts'];
+    vault: AUP['vault'];
     profileConfigPath: string;
-    onPanelOpen: any;
-    interruptController: any;
-    enhanceController: any;
-    activeReasoningConfig: any;
-    configRef: any;
-    buildProviderForModel: any;
-    statuslineHiddenItems: any;
-    setStatuslineHiddenItems: any;
-    saveStatuslineHiddenItems: any;
-    setYoloMode: any;
-    autonomyMode: any;
-    setAutonomyMode: any;
-    nextPredictEnabled: any;
-    setNextPredict: any;
-    container: any;
-    sessionBridge: any;
-    autoCompactor: any;
-    getPluginPickerItems: any;
-    togglePluginFromPicker: any;
-    getToolPickerItems: any;
-    brain: any;
-    brainSettings: any;
-    brainRuntime: any;
-    brainLog: any;
-    currentSuggestions: any;
-    setCurrentSuggestions: any;
-    eternalEngine: any;
-    parallelEngine: any;
-    sddRunRegistry: any;
-    eternalListeners: any;
-    stageListeners: any;
-    runSageSessionHygiene: any;
-    pluginHost: any;
-    teardownHandlers: any;
-    governanceHandle: any;
-    setConfig: (cfg: any) => void;
+    onPanelOpen: X['fleet']['onPanelOpen'];
+    interruptController: RC['interruptController'];
+    enhanceController: RC['enhanceController'];
+    activeReasoningConfig: Parameters<typeof gatedEnhancerReasoning>[0];
+    configRef: {
+        current: X['core']['config'];
+    };
+    buildProviderForModel: RC['buildProviderForModel'];
+    statuslineHiddenItems: RC['statuslineHiddenItems'];
+    setStatuslineHiddenItems: NonNullable<RC['setStatuslineHiddenItems']>;
+    saveStatuslineHiddenItems: NonNullable<RC['saveStatuslineHiddenItems']>;
+    setYoloMode: NonNullable<RC['getYolo']>;
+    autonomyMode: ReturnType<RC['getAutonomy']>;
+    setAutonomyMode: NonNullable<RC['setAutonomy']>;
+    nextPredictEnabled: ReturnType<RC['getNextPredict']>;
+    setNextPredict: NonNullable<RC['setNextPredict']>;
+    container: Container;
+    sessionBridge: RC['sessionBridge'];
+    autoCompactor: RC['autoCompactor'];
+    getPluginPickerItems: RP['getPluginItems'];
+    togglePluginFromPicker: RP['togglePlugin'];
+    getToolPickerItems: RP['getToolItems'];
+    brain: RP['brain'];
+    brainSettings: RP['brainSettings'];
+    brainRuntime: RP['brainRuntime'];
+    brainLog: ReturnType<NonNullable<RP['getBrainLog']>>;
+    currentSuggestions: ReturnType<RL['getCurrentSuggestions']>;
+    setCurrentSuggestions: RL['setCurrentSuggestions'];
+    eternalEngine: ReturnType<RL['getEternalEngine']>;
+    parallelEngine: ReturnType<RL['getParallelEngine']>;
+    sddRunRegistry: RL['sddRunRegistry'];
+    eternalListeners: RL['eternalListeners'];
+    stageListeners: RL['stageListeners'];
+    runSageSessionHygiene: RL['runSageSessionHygiene'];
+    pluginHost: RL['pluginHost'];
+    teardownHandlers: RL['teardownHandlers'];
+    governanceHandle: CliGovernanceRuntimeHandle | undefined;
+    setConfig: RC['setConfig'];
 }): Promise<number>;
+export {};
 //# sourceMappingURL=cli-execute-builder.d.ts.map

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