@wrongstack/cli 0.54.1 → 0.66.13

package/dist/index.js

@@ -2,29 +2,30 @@
 import * as path8 from 'path';
 import { join } from 'path';
 import * as fsp3 from 'fs/promises';
-import { color, writeErr, DefaultTaskStore, TaskTracker, renderProgress, SpecStore, TaskGraphStore, analyzeCriticalPath, getTemplate, listTemplates, templateToMarkdown, SpecParser, renderSpecAnalysis, AISpecBuilder, renderTaskGraph, SpecVersioning, DefaultSecretScrubber, atomicWrite, DefaultPathResolver, TOKENS, mergeCustomModelDefs, DefaultSystemPromptBuilder, makeAutonomyPromptContributor, ToolRegistry, createContextManagerTool, EventBus, SlashCommandRegistry, BrainDecisionQueue, ObservableBrainArbiter, HumanEscalatingBrainArbiter, DefaultBrainArbiter, createDelegateTool, FLEET_ROSTER, createMcpControlTool, DefaultLogger, DefaultModelsRegistry, isStdinTTY, writeOut, runProviderWithRetry, ReplayLogStore, ReplayProviderRunner, ProviderRegistry, InMemoryMetricsSink, wireMetricsToEvents, DefaultHealthRegistry, startMetricsServer, RecoveryLock, DefaultAttachmentStore, QueueStore, Context, loadTodosCheckpoint, attachTodosCheckpoint, loadDirectorState, loadPlan, createDefaultPipelines, AutoCompactionMiddleware, estimateRequestTokensCalibrated, Agent, loadPlugins, FleetManager, makeDirectorSessionFactory, Director, makeFleetEmitTool, makeFleetStatusTool, resolveModelMatrix, AutoApprovePermissionPolicy, PhaseStore, AutoPhasePlanner, PhaseGraphBuilder, WorktreeManager, PhaseOrchestrator, makeLLMClassifier, ParallelEternalEngine, EternalAutonomyEngine, allServers as allServers$1, bootConfig as bootConfig$1, setRawMode, DefaultSessionReader, resolveWstackPaths, ToolAuditLog, DefaultSessionRewinder, DefaultSessionStore, DefaultPluginAPI, makeAgentSubagentRunner, NULL_FLEET_BUS, buildChildEnv, formatContextWindowModeList, repairToolUseAdjacency, getContextWindowMode, resolveContextWindowPolicy, AGENTS_BY_PHASE, dispatchAgent, formatTodosList, SessionRecovery, loadGoal, goalFilePath, summarizeUsage, saveGoal, emptyGoal, buildGoalPreamble, formatGoal, pendingBtwCount, setBtwNote, MATRIX_PHASE_KEYS, AGENT_CATALOG, matrixKeyKind, onResize, decryptConfigSecrets as decryptConfigSecrets$1, encryptConfigSecrets as encryptConfigSecrets$1, InputBuilder, FsError, ERROR_CODES } from '@wrongstack/core';
+import { color, writeErr, DefaultTaskStore, TaskTracker, renderProgress, SpecStore, TaskGraphStore, analyzeCriticalPath, getTemplate, listTemplates, templateToMarkdown, SpecParser, renderSpecAnalysis, AISpecBuilder, renderTaskGraph, SpecVersioning, DefaultSecretScrubber, atomicWrite, DefaultPathResolver, TOKENS, mergeCustomModelDefs, DefaultSystemPromptBuilder, makeAutonomyPromptContributor, ToolRegistry, createContextManagerTool, EventBus, resolveSessionLoggingConfig, createSessionEventBridge, HookRegistry, HookRunner, SlashCommandRegistry, BrainDecisionQueue, ObservableBrainArbiter, HumanEscalatingBrainArbiter, DefaultBrainArbiter, createDelegateTool, FLEET_ROSTER, createMcpControlTool, DefaultLogger, DefaultModelsRegistry, isStdinTTY, writeOut, runProviderWithRetry, ReplayLogStore, ReplayProviderRunner, ProviderRegistry, InMemoryMetricsSink, wireMetricsToEvents, DefaultHealthRegistry, startMetricsServer, RecoveryLock, DefaultAttachmentStore, QueueStore, Context, loadTodosCheckpoint, attachTodosCheckpoint, loadDirectorState, loadPlan, createDefaultPipelines, resolveContextWindowPolicy, resolveAuditLevel, AutoCompactionMiddleware, estimateRequestTokensCalibrated, Agent, loadPlugins, FleetManager, makeDirectorSessionFactory, Director, makeFleetEmitTool, makeFleetStatusTool, resolveModelMatrix, AutoApprovePermissionPolicy, PhaseStore, AutoPhasePlanner, PhaseGraphBuilder, WorktreeManager, PhaseOrchestrator, makeLLMClassifier, ParallelEternalEngine, EternalAutonomyEngine, allServers as allServers$1, bootConfig as bootConfig$1, setRawMode, DefaultSessionReader, resolveWstackPaths, ToolAuditLog, DefaultSessionRewinder, DefaultSessionStore, DefaultPluginAPI, ProviderError, makeAgentSubagentRunner, NULL_FLEET_BUS, buildChildEnv, formatContextWindowModeList, repairToolUseAdjacency, getContextWindowMode, AGENTS_BY_PHASE, dispatchAgent, formatTodosList, SessionRecovery, loadGoal, goalFilePath, summarizeUsage, saveGoal, emptyGoal, buildGoalPreamble, formatGoal, pendingBtwCount, setBtwNote, MATRIX_PHASE_KEYS, AGENT_CATALOG, matrixKeyKind, onResize, ERROR_CODES, decryptConfigSecrets as decryptConfigSecrets$1, encryptConfigSecrets as encryptConfigSecrets$1, InputBuilder, FsError } from '@wrongstack/core';
 import { createRequire } from 'module';
 import * as os2 from 'os';
 import os2__default from 'os';
 import * as crypto2 from 'crypto';
 import { randomUUID } from 'crypto';
+import { findFreePort, createHttpServer, openBrowser, registerInstance, unregisterInstance } from '@wrongstack/webui/server';
 import { DefaultSecretVault, decryptConfigSecrets, encryptConfigSecrets, isSecretField } from '@wrongstack/core/security';
 import { WebSocketServer, WebSocket } from 'ws';
-import { MCPRegistry } from '@wrongstack/mcp';
+import { MCPRegistry, MCPServer, serveHttp, serveStdio } from '@wrongstack/mcp';
 import { capabilitiesFor, buildProviderFactoriesFromRegistry, makeProviderFromConfig } from '@wrongstack/providers';
 import { createDefaultContainer, routeImagesForModel, readClipboardImage } from '@wrongstack/runtime';
 import { builtinToolsPack, rememberTool, forgetTool } from '@wrongstack/tools';
 import { fileURLToPath } from 'url';
 import * as readline from 'readline';
-import * as fs11 from 'fs';
+import * as fs12 from 'fs';
 import { writeFileSync, existsSync, readFileSync } from 'fs';
 import { WrongStackACPServer } from '@wrongstack/acp/agent';
 import { ACP_AGENT_COMMANDS, makeACPSubagentRunner, makeACPSubagentRunnerWithStop } from '@wrongstack/acp';
 import { ACP_AGENTS, SubagentBudget } from '@wrongstack/core/coordination';
 import { spawn } from 'child_process';
 import { allServers } from '@wrongstack/core/infrastructure';
-import { createToolVisionAdapters } from '@wrongstack/runtime/vision';
 import { ToolExecutor } from '@wrongstack/core/execution';
+import { createToolVisionAdapters } from '@wrongstack/runtime/vision';
 
 var __defProp = Object.defineProperty;
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
@@ -1694,13 +1695,63 @@ __export(webui_server_exports, {
   runWebUI: () => runWebUI
 });
 async function runWebUI(opts) {
-  const port = opts.port ?? 3457;
+  const host = "127.0.0.1";
+  const requestedWsPort = opts.port ?? 3457;
+  const requestedHttpPort = opts.httpPort ?? 3456;
+  const strictPort = process.env["WEBUI_STRICT_PORT"] === "1" || process.env["WEBUI_STRICT_PORT"] === "true";
+  let httpPort = requestedHttpPort;
+  let wsPort = requestedWsPort;
+  if (!strictPort) {
+    httpPort = await findFreePort(host, requestedHttpPort);
+    wsPort = await findFreePort(host, requestedWsPort, { exclude: /* @__PURE__ */ new Set([httpPort]) });
+  }
+  const port = wsPort;
+  const rateLimitMax = Number.parseInt(process.env["WEBUI_RATE_LIMIT"] ?? "0", 10);
   const clients = /* @__PURE__ */ new Map();
+  const pendingConfirms = /* @__PURE__ */ new Map();
   const secretScrubber = new DefaultSecretScrubber();
   let abortController = null;
   const authToken = crypto2.randomBytes(16).toString("hex");
-  const wss = new WebSocketServer({ port, host: "127.0.0.1", maxPayload: 1 * 1024 * 1024 });
-  console.log(`[WebUI] WebSocket server starting on ws://127.0.0.1:${port}`);
+  const wss = new WebSocketServer({ port, host, maxPayload: 1 * 1024 * 1024 });
+  console.log(`[WebUI] WebSocket server starting on ws://${host}:${port}`);
+  let httpServer = null;
+  try {
+    const requireFromHere = createRequire(import.meta.url);
+    const serverEntry = requireFromHere.resolve("@wrongstack/webui/server");
+    const distDir = path8.resolve(path8.dirname(serverEntry), "..");
+    httpServer = createHttpServer({ host, distDir, wsPort });
+    const openUrl = `http://${host}:${httpPort}`;
+    httpServer.listen(httpPort, host, () => {
+      console.log(
+        `
+  \u25B8 WebUI ready \u2014 open \x1B[1m${openUrl}\x1B[0m in your browser
+    (same agent as this terminal \xB7 ws:${wsPort})
+`
+      );
+      if (opts.open) openBrowser(openUrl);
+    });
+  } catch (err) {
+    console.warn(
+      `[WebUI] Frontend not served (run \`pnpm --filter @wrongstack/webui build\`): ${err instanceof Error ? err.message : String(err)}. WS bridge still active on ws://${host}:${wsPort}.`
+    );
+  }
+  const registryBaseDir = opts.globalConfigPath ? path8.dirname(opts.globalConfigPath) : void 0;
+  if (opts.projectRoot) {
+    void registerInstance(
+      {
+        pid: process.pid,
+        httpPort,
+        wsPort,
+        host,
+        projectRoot: opts.projectRoot,
+        projectName: path8.basename(opts.projectRoot) || opts.projectRoot,
+        startedAt: (/* @__PURE__ */ new Date()).toISOString(),
+        url: `http://${host}:${httpPort}`
+      },
+      registryBaseDir
+    ).catch(() => {
+    });
+  }
   const eventUnsubscribers = [];
   function setupEvents() {
     for (const unsub of eventUnsubscribers) unsub();
@@ -1794,6 +1845,88 @@ async function runWebUI(opts) {
         });
       })
     );
+    eventUnsubscribers.push(
+      opts.events.on("tool.confirm_needed", (e) => {
+        const id = e.toolUseId ?? `confirm_${Date.now()}`;
+        pendingConfirms.set(id, e.resolve);
+        broadcast({
+          type: "tool.confirm_needed",
+          payload: {
+            id,
+            toolName: e.tool?.name ?? "unknown",
+            input: secretScrubber.scrubObject(e.input),
+            suggestedPattern: e.suggestedPattern
+          }
+        });
+      })
+    );
+    const forwardSubagent = (kind, payload) => broadcast({ type: "subagent.event", payload: { kind, ...payload } });
+    eventUnsubscribers.push(
+      opts.events.on(
+        "subagent.spawned",
+        (e) => forwardSubagent("spawned", {
+          subagentId: e.subagentId,
+          taskId: e.taskId,
+          name: e.name,
+          provider: e.provider,
+          model: e.model,
+          description: e.description
+        })
+      ),
+      opts.events.on(
+        "subagent.task_started",
+        (e) => forwardSubagent("task_started", {
+          subagentId: e.subagentId,
+          taskId: e.taskId,
+          description: e.description
+        })
+      ),
+      opts.events.on(
+        "subagent.tool_executed",
+        (e) => forwardSubagent("tool_executed", {
+          subagentId: e.subagentId,
+          toolName: e.name,
+          durationMs: e.durationMs,
+          ok: e.ok
+        })
+      ),
+      opts.events.on(
+        "subagent.iteration_summary",
+        (e) => forwardSubagent("iteration_summary", {
+          subagentId: e.subagentId,
+          iteration: e.iteration,
+          toolCalls: e.toolCalls,
+          costUsd: e.costUsd,
+          currentTool: e.currentTool
+        })
+      ),
+      opts.events.on(
+        "subagent.budget_extended",
+        (e) => forwardSubagent("budget_extended", {
+          subagentId: e.subagentId,
+          totalExtensions: e.totalExtensions
+        })
+      ),
+      opts.events.on(
+        "subagent.ctx_pct",
+        (e) => forwardSubagent("ctx_pct", {
+          subagentId: e.subagentId,
+          load: e.load,
+          tokens: e.tokens,
+          maxContext: e.maxContext
+        })
+      ),
+      opts.events.on(
+        "subagent.task_completed",
+        (e) => forwardSubagent("task_completed", {
+          subagentId: e.subagentId,
+          status: e.status,
+          iterations: e.iterations,
+          toolCalls: e.toolCalls,
+          error: e.error ? { kind: e.error.kind, message: e.error.message } : void 0
+        })
+      )
+    );
     if (opts.subscribeEternalIteration) {
       eventUnsubscribers.push(
         opts.subscribeEternalIteration((entry) => {
@@ -1814,10 +1947,11 @@ async function runWebUI(opts) {
       );
     }
   }
-  return new Promise((resolve3) => {
+  return new Promise((resolve4) => {
     wss.on("listening", () => {
-      console.log(`[WebUI] WebSocket server running on ws://127.0.0.1:${port}`);
+      console.log(`[WebUI] WebSocket server running on ws://${host}:${port}`);
       setupEvents();
+      opts.onListening?.({ httpPort, wsPort, host });
     });
     wss.on("connection", (ws, req2) => {
       const isLoopback = (hostname) => hostname === "localhost" || hostname === "127.0.0.1" || hostname === "::1" || hostname === "[::1]";
@@ -1870,17 +2004,19 @@ async function runWebUI(opts) {
       let msgCount = 0;
       let windowResetAt = Date.now() + 6e4;
       ws.on("message", async (data) => {
-        const now = Date.now();
-        if (now > windowResetAt) {
-          msgCount = 0;
-          windowResetAt = now + 6e4;
-        }
-        if (++msgCount > 60) {
-          send(ws, {
-            type: "error",
-            payload: { phase: "rate_limit", message: "Too many messages. Please wait." }
-          });
-          return;
+        if (rateLimitMax > 0) {
+          const now = Date.now();
+          if (now > windowResetAt) {
+            msgCount = 0;
+            windowResetAt = now + 6e4;
+          }
+          if (++msgCount > rateLimitMax) {
+            send(ws, {
+              type: "error",
+              payload: { phase: "rate_limit", message: "Too many messages. Please wait." }
+            });
+            return;
+          }
         }
         try {
           const msg = JSON.parse(data.toString());
@@ -1892,6 +2028,12 @@ async function runWebUI(opts) {
       ws.on("close", () => {
         console.log("[WebUI] Client disconnected");
         clients.delete(ws);
+        if (clients.size === 0 && pendingConfirms.size > 0) {
+          for (const [id, resolve5] of pendingConfirms) {
+            resolve5("no");
+            pendingConfirms.delete(id);
+          }
+        }
       });
       send(ws, {
         type: "session.start",
@@ -1913,9 +2055,12 @@ async function runWebUI(opts) {
         ws.close();
       }
       clients.clear();
+      void unregisterInstance(process.pid, registryBaseDir).catch(() => {
+      });
+      httpServer?.close();
       wss.close(() => {
         console.log("[WebUI] Server stopped");
-        resolve3();
+        resolve4();
       });
     }
     process.on("SIGINT", shutdown);
@@ -1940,6 +2085,15 @@ async function runWebUI(opts) {
       case "ping":
         send(ws, { type: "pong", payload: {} });
         break;
+      case "tool.confirm_result": {
+        const { id, decision } = msg.payload;
+        const resolve4 = pendingConfirms.get(id);
+        if (resolve4) {
+          pendingConfirms.delete(id);
+          resolve4(decision);
+        }
+        break;
+      }
       case "providers.list":
         await handleProvidersList(ws);
         break;
@@ -2345,29 +2499,43 @@ async function resolveRuntimeMaxContext(input) {
   const providerConfig = input.runtimeProviderConfig ?? input.config.providers?.[input.providerId];
   const providerOverride = positiveNumber(readConfiguredMaxContext(providerConfig));
   if (providerOverride) return providerOverride;
-  const topLevelBaseUrlApplies = input.providerId === input.config.provider;
-  const hasCustomBaseUrl = Boolean(
-    providerConfig?.baseUrl || topLevelBaseUrlApplies && input.config.baseUrl
-  );
-  if (input.modelsRegistry && !hasCustomBaseUrl) {
-    const mergedModels = mergeCustomModelDefs(
-      providerConfig?.customModels,
-      input.config.models
-    );
-    const caps = await capabilitiesFor(
-      input.modelsRegistry,
-      input.providerId,
-      input.modelId,
-      mergedModels
-    ).catch(() => void 0);
-    const catalogMax = positiveNumber(caps?.maxContext);
-    if (catalogMax) return catalogMax;
-    const directModel = await input.modelsRegistry.getModel(input.providerId, input.modelId).catch(() => void 0);
-    const directMax = positiveNumber(directModel?.capabilities.maxContext);
-    if (directMax) return directMax;
+  const catalogId = providerConfig?.type && providerConfig.type !== input.providerId ? providerConfig.type : input.providerId;
+  if (input.modelsRegistry) {
+    const topLevelBaseUrlApplies = input.providerId === input.config.provider;
+    const configuredBaseUrl = providerConfig?.baseUrl ?? (topLevelBaseUrlApplies ? input.config.baseUrl : void 0);
+    let divergesFromCatalog = false;
+    if (configuredBaseUrl) {
+      const resolved = await safeGetProvider(input.modelsRegistry, catalogId);
+      divergesFromCatalog = normalizeBaseUrl(configuredBaseUrl) !== normalizeBaseUrl(resolved?.apiBase);
+    }
+    if (!divergesFromCatalog) {
+      const mergedModels = mergeCustomModelDefs(providerConfig?.customModels, input.config.models);
+      const caps = await capabilitiesFor(
+        input.modelsRegistry,
+        catalogId,
+        input.modelId,
+        mergedModels
+      ).catch(() => void 0);
+      const catalogMax = positiveNumber(caps?.maxContext);
+      if (catalogMax) return catalogMax;
+      const directModel = await input.modelsRegistry.getModel(catalogId, input.modelId).catch(() => void 0);
+      const directMax = positiveNumber(directModel?.capabilities.maxContext);
+      if (directMax) return directMax;
+    }
   }
   return positiveNumber(input.provider.capabilities.maxContext) ?? 0;
 }
+async function safeGetProvider(registry, id) {
+  try {
+    return await registry.getProvider(id);
+  } catch {
+    return void 0;
+  }
+}
+function normalizeBaseUrl(url) {
+  if (!url) return "";
+  return url.trim().toLowerCase().replace(/\/+$/, "");
+}
 function readConfiguredMaxContext(providerConfig) {
   if (!providerConfig || typeof providerConfig !== "object") return void 0;
   const capabilities = providerConfig.capabilities;
@@ -2381,6 +2549,8 @@ function positiveNumber(value) {
 // src/arg-parser.ts
 var BOOLEAN_FLAGS = /* @__PURE__ */ new Set([
   "yolo",
+  "yolo-destructive",
+  "confirm-destructive",
   "force-all-yolo",
   "verbose",
   "trace",
@@ -2399,6 +2569,7 @@ var BOOLEAN_FLAGS = /* @__PURE__ */ new Set([
   "prompt",
   "metrics",
   "webui",
+  "open",
   "no-check",
   "no-models-refresh",
   "director",
@@ -2407,7 +2578,8 @@ var BOOLEAN_FLAGS = /* @__PURE__ */ new Set([
   "autonomy",
   "eternal",
   "no-hints",
-  "hints"
+  "hints",
+  "no-hooks"
 ]);
 function parseArgs(argv) {
   const flags = {};
@@ -2735,10 +2907,12 @@ function buildAutonomyCommand(opts) {
       "  auto     \u2014 After each turn, agent picks the best next step and continues.",
       "             Runs indefinitely until you press Esc or Ctrl+C.",
       "  eternal  \u2014 Goal-driven sense/decide/execute/reflect loop. Requires /goal.",
-      "             Force-enables YOLO. Runs until /autonomy stop or Ctrl+C twice.",
+      "             Force-enables regular YOLO; destructive-gated calls still use",
+      "             the permission flow. Runs until /autonomy stop or Ctrl+C twice.",
       "  parallel \u2014 Fan-out 4\u20138 subagents per tick. Each tick decomposes the goal,",
       "             spawns N agents, awaits results, aggregates. Requires /goal.",
-      "             Force-enables YOLO. Runs until /autonomy stop or Ctrl+C twice.",
+      "             Force-enables regular YOLO; destructive-gated calls still use",
+      "             the permission flow. Runs until /autonomy stop or Ctrl+C twice.",
       "",
       "Eternal stage flow: decide \u2192 execute \u2192 reflect \u2192 sleep | paused | stopped",
       "Stage shown in real-time. Use /goal pause to pause, /goal resume to continue.",
@@ -2896,7 +3070,7 @@ function buildAutonomyCommand(opts) {
         opts.onEternalStart(newMode);
         const modeLabel = newMode === "eternal-parallel" ? `${color.magenta("PARALLEL")} mode` : `${color.red("ETERNAL")} mode`;
         const msg2 = `Autonomy mode: ${modeLabel} \u2014 engine launching against goal: ${color.bold(goal.goal)}
-${color.dim("YOLO forced ON. Use /autonomy stop to end. Journal at /goal journal.")}`;
+${color.dim("Regular YOLO enabled; destructive-gated calls still use the permission flow. Use /autonomy stop to end. Journal at /goal journal.")}`;
         opts.renderer.write(msg2);
         return { message: msg2 };
       }
@@ -3373,6 +3547,11 @@ function buildContextCommand(opts) {
       "  /context           Show counts: messages, est. tokens, tool calls, todos, read files.",
       "  /context detail    As above, plus model, cwd, projectRoot, and the file list.",
       "  /context repair    Repair orphan tool_use/tool_result blocks after manual compaction.",
+      "  /context limit     Show effective context window for this session.",
+      "  /context limit <tokens> Set effective context window for this session (e.g. 220k).",
+      "  /context limit <tokens> --persist Persist effective context window to config.",
+      "  /context thresholds <warn> <soft> <hard> Set compaction thresholds (percent or decimal).",
+      "  /context thresholds <warn> <soft> <hard> --persist Persist thresholds to config.",
       "  /context mode      List context-window modes.",
       "  /context mode <id> Switch context-window mode for this session."
     ].join("\n"),
@@ -3400,6 +3579,83 @@ ${formatContextWindowModeList(active)}`;
           `  empty msgs:   removed ${repaired.report.removedMessages}`
         ].join("\n") : "Context repair: no orphan tool_use/tool_result blocks found.";
         opts.renderer.write(`${msg2}
+`);
+        return { message: msg2 };
+      }
+      if (trimmed === "limit") {
+        const limit = readEffectiveLimit(ctx, opts);
+        const msg2 = limit > 0 ? `Effective context window: ${limit.toLocaleString()} tokens` : "Effective context window: unknown (auto-compaction may be disabled).";
+        opts.renderer.write(`${msg2}
+`);
+        return { message: msg2 };
+      }
+      if (trimmed.startsWith("limit ")) {
+        const persist = hasPersistFlag(trimmed);
+        const raw = stripPersistFlag(trimmed.slice("limit ".length)).trim();
+        const limit = parseTokenCount(raw);
+        if (!limit) {
+          const msg3 = `Invalid context limit "${raw}". Use a positive token count, e.g. 220k or 220000.`;
+          opts.renderer.write(`${color.red(msg3)}
+`);
+          return { message: msg3 };
+        }
+        ctx.meta["effectiveMaxContext"] = limit;
+        const effective = opts.onContextLimit?.(limit) ?? limit;
+        if (persist) {
+          const error = await persistContextConfig(opts, { effectiveMaxContext: limit });
+          if (error) {
+            opts.renderer.write(`${color.red(error)}
+`);
+            return { message: error };
+          }
+        }
+        const msg2 = `${color.green("Effective context window set:")} ${effective.toLocaleString()} tokens${persist ? " (persisted)" : ""}`;
+        opts.renderer.write(`${msg2}
+`);
+        return { message: msg2 };
+      }
+      if (trimmed.startsWith("thresholds ")) {
+        const persist = hasPersistFlag(trimmed);
+        const thresholdArgs = stripPersistFlag(trimmed.slice("thresholds ".length)).trim();
+        const parts = thresholdArgs.split(/\s+/).filter(Boolean);
+        if (parts.length !== 3) {
+          const msg3 = "Usage: /context thresholds <warn> <soft> <hard> (examples: 60% 75% 90% or 0.6 0.75 0.9)";
+          opts.renderer.write(`${color.red(msg3)}
+`);
+          return { message: msg3 };
+        }
+        const thresholds = parts.map(parseThreshold);
+        if (thresholds.some((v) => v === null)) {
+          const msg3 = "Invalid thresholds. Use percentages (60%) or decimals between 0 and 1.";
+          opts.renderer.write(`${color.red(msg3)}
+`);
+          return { message: msg3 };
+        }
+        const [warn, soft, hard] = thresholds;
+        if (!(warn < soft && soft < hard)) {
+          const msg3 = "Invalid thresholds: require warn < soft < hard.";
+          opts.renderer.write(`${color.red(msg3)}
+`);
+          return { message: msg3 };
+        }
+        const base = readPolicy(ctx) ?? resolveContextWindowPolicy({});
+        const policy2 = { ...base, thresholds: { warn, soft, hard } };
+        ctx.meta["contextWindowMode"] = policy2.id;
+        ctx.meta["contextWindowPolicy"] = policy2;
+        if (persist) {
+          const error = await persistContextConfig(opts, {
+            warnThreshold: warn,
+            softThreshold: soft,
+            hardThreshold: hard
+          });
+          if (error) {
+            opts.renderer.write(`${color.red(error)}
+`);
+            return { message: error };
+          }
+        }
+        const msg2 = `${color.green("Context thresholds set:")} warn ${pct(warn)}, soft ${pct(soft)}, hard ${pct(hard)}${persist ? " (persisted)" : ""}`;
+        opts.renderer.write(`${msg2}
 `);
         return { message: msg2 };
       }
@@ -3433,6 +3689,7 @@ ${formatContextWindowModeList(active)}`;
         `  messages:    ${messages.length} total (${countTurnPairs(messages)} user+assistant pairs)`,
         `  tokens (est): ${estimateTokens(messages).toLocaleString()} (chars / 4 estimate)`,
         `  mode:        ${policy ? `${policy.id} (${policy.name})` : "balanced"}`,
+        `  limit:       ${formatLimit(readEffectiveLimit(ctx, opts))}`,
         `  system prompt: ${ctx.systemPrompt.length} block${ctx.systemPrompt.length !== 1 ? "s" : ""}`,
         `  tools:       ${countToolUses(messages)} calls made, ${countToolResults(messages)} results in history`,
         `  read files:  ${ctx.readFiles.size} files`,
@@ -3459,6 +3716,68 @@ function readPolicy(ctx) {
   const policy = ctx.meta?.["contextWindowPolicy"];
   return policy && typeof policy === "object" ? policy : null;
 }
+function hasPersistFlag(input) {
+  return /(?:^|\s)--persist(?:\s|$)/.test(input);
+}
+function stripPersistFlag(input) {
+  return input.replace(/(?:^|\s)--persist(?:\s|$)/g, " ").trim();
+}
+async function persistContextConfig(opts, patch) {
+  if (!opts.configStore || !opts.paths) return "Cannot persist context settings: config store not available.";
+  let raw = "{}";
+  try {
+    raw = await fsp3.readFile(opts.paths.globalConfig, "utf8");
+  } catch (err) {
+    if (err.code !== "ENOENT") {
+      return `Could not read ${opts.paths.globalConfig}: ${err.message}`;
+    }
+  }
+  let parsed;
+  try {
+    parsed = JSON.parse(raw);
+  } catch (err) {
+    return `Config at ${opts.paths.globalConfig} is not valid JSON: ${err.message}`;
+  }
+  const current = opts.configStore.get();
+  const context = {
+    ...current.context,
+    ...parsed.context ?? {},
+    ...patch
+  };
+  parsed.context = context;
+  await atomicWrite(opts.paths.globalConfig, JSON.stringify(parsed, null, 2), { mode: 384 });
+  opts.configStore.update({ context });
+  return null;
+}
+function readEffectiveLimit(ctx, opts) {
+  const live = opts.onContextLimit?.();
+  if (typeof live === "number" && Number.isFinite(live) && live > 0) return live;
+  const metaLimit = ctx.meta?.["effectiveMaxContext"];
+  if (typeof metaLimit === "number" && Number.isFinite(metaLimit) && metaLimit > 0) return metaLimit;
+  const providerLimit = ctx.provider?.capabilities?.maxContext;
+  return typeof providerLimit === "number" && Number.isFinite(providerLimit) && providerLimit > 0 ? providerLimit : 0;
+}
+function parseTokenCount(raw) {
+  const normalized = raw.trim().toLowerCase().replace(/,/g, "").replace(/_/g, "");
+  const match = /^(\d+(?:\.\d+)?)([km])?$/.exec(normalized);
+  if (!match) return null;
+  const value = Number(match[1]);
+  const unit = match[2];
+  const scaled = unit === "m" ? value * 1e6 : unit === "k" ? value * 1e3 : value;
+  const rounded = Math.floor(scaled);
+  return Number.isFinite(rounded) && rounded > 0 ? rounded : null;
+}
+function parseThreshold(raw) {
+  const s = raw.trim();
+  const percent = s.endsWith("%");
+  const n = Number((percent ? s.slice(0, -1) : s).trim());
+  if (!Number.isFinite(n)) return null;
+  const value = percent ? n / 100 : n;
+  return value > 0 && value < 1 ? value : null;
+}
+function formatLimit(limit) {
+  return limit > 0 ? `${limit.toLocaleString()} tokens` : "unknown";
+}
 function pct(n) {
   return `${Math.round(n * 100)}%`;
 }
@@ -4867,12 +5186,20 @@ function parseMcpArgs(args) {
 }
 async function runMcpManagementCommand(parsed, deps) {
   const { config, configPath: configPath2, mcpRegistry, allServerPresets } = deps;
-  const configured = config.mcpServers ?? {};
+  const diskConfig = await readConfig(configPath2);
+  const configured = isMcpServerRecord(diskConfig.mcpServers) ? diskConfig.mcpServers : config.mcpServers ?? {};
   switch (parsed.action) {
     case "list":
       return renderList(configured, mcpRegistry, allServerPresets);
     case "add":
-      return runAdd(parsed.name, parsed.enable ?? false, configured, configPath2, allServerPresets);
+      return runAdd(
+        parsed.name,
+        parsed.enable ?? false,
+        configured,
+        configPath2,
+        mcpRegistry,
+        allServerPresets
+      );
     case "remove":
       return runRemove(parsed.name, configured, configPath2, mcpRegistry);
     case "enable":
@@ -4916,34 +5243,46 @@ function renderList(configured, mcpRegistry, all) {
   lines.push(color.dim("  /mcp restart <name>           (runtime restart)"));
   return lines.join("\n");
 }
-async function runAdd(name, enable, configured, configPath2, all) {
+async function runAdd(name, enable, configured, configPath2, mcpRegistry, all) {
   const preset = all[name];
   if (!preset) {
     const known = Object.keys(all).join(", ");
     return `Unknown server "${name}". Available: ${known}`;
   }
-  if (configured[name]) {
-    const full2 = await readConfig(configPath2);
-    full2.mcpServers = {
-      ...full2.mcpServers ?? {},
-      [name]: { ...preset, ...configured[name], enabled: enable }
-    };
-    await writeConfig(configPath2, full2);
-    return `${color.green("Updated")} "${name}" (${enable ? "enabled" : "disabled"}). Config written.`;
-  }
+  const existing = configured[name];
+  const nextCfg = existing ? { ...preset, ...existing, enabled: enable } : { ...preset, enabled: enable };
   const full = await readConfig(configPath2);
-  const mcpServers = { ...full.mcpServers ?? {}, [name]: { ...preset, enabled: enable } };
+  const mcpServers = {
+    ...isMcpServerRecord(full.mcpServers) ? full.mcpServers : {},
+    [name]: nextCfg
+  };
   full.mcpServers = mcpServers;
   await writeConfig(configPath2, full);
-  const verb = enable ? "Enabled" : "Added (disabled \u2014 /mcp enable to start)";
-  return `${color.green(verb)} "${name}" (${preset.transport}). Config written to ${configPath2}.`;
+  if (!enable) {
+    const verb = existing ? "Updated" : "Added (disabled \u2014 /mcp enable to start)";
+    return `${color.green(verb)} "${name}" (${nextCfg.transport}). Config written to ${configPath2}.`;
+  }
+  try {
+    if (mcpRegistry.list().some((server) => server.name === name)) {
+      await mcpRegistry.restart(name);
+    } else {
+      await mcpRegistry.start(nextCfg);
+    }
+    const verb = existing ? "Updated and started" : "Enabled and started";
+    return `${color.green(verb)} "${name}" (${nextCfg.transport}). Config written to ${configPath2}.`;
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    return `${color.yellow("Enabled")} "${name}" in config, but failed to start: ${message}`;
+  }
 }
 async function runRemove(name, configured, configPath2, mcpRegistry) {
   if (!configured[name]) return `Server "${name}" is not in config.`;
   await mcpRegistry.stop(name).catch(() => {
   });
   const full = await readConfig(configPath2);
-  const mcpServers = { ...full.mcpServers ?? {} };
+  const mcpServers = {
+    ...full.mcpServers ?? {}
+  };
   delete mcpServers[name];
   full.mcpServers = mcpServers;
   await writeConfig(configPath2, full);
@@ -4962,7 +5301,9 @@ async function runEnable(name, configured, configPath2, mcpRegistry) {
     }
   }
   const full = await readConfig(configPath2);
-  const mcpServers = { ...full.mcpServers ?? {} };
+  const mcpServers = {
+    ...full.mcpServers ?? {}
+  };
   mcpServers[name] = { ...mcpServers[name], enabled: true };
   full.mcpServers = mcpServers;
   await writeConfig(configPath2, full);
@@ -4979,7 +5320,9 @@ async function runDisable(name, configured, configPath2, mcpRegistry) {
   await mcpRegistry.stop(name).catch(() => {
   });
   const full = await readConfig(configPath2);
-  const mcpServers = { ...full.mcpServers ?? {} };
+  const mcpServers = {
+    ...full.mcpServers ?? {}
+  };
   mcpServers[name] = { ...mcpServers[name], enabled: false };
   full.mcpServers = mcpServers;
   await writeConfig(configPath2, full);
@@ -5020,6 +5363,9 @@ async function readConfig(path25) {
     return {};
   }
 }
+function isMcpServerRecord(value) {
+  return !!value && typeof value === "object" && !Array.isArray(value);
+}
 async function writeConfig(path25, cfg) {
   const raw = JSON.stringify(cfg, null, 2);
   const tmp = path25 + ".tmp";
@@ -6339,13 +6685,13 @@ function buildYoloCommand(opts) {
     description: "Toggle or query YOLO (auto-approve) mode.",
     help: [
       "Usage:",
-      "  /yolo          Show current YOLO status",
-      "  /yolo on       Enable YOLO mode (auto-approve every tool call)",
-      "  /yolo off      Disable YOLO mode (restore permission prompts)",
-      "  /yolo toggle   Toggle YOLO mode",
+      "  /yolo              Show current YOLO status",
+      "  /yolo on           Enable YOLO mode (auto-approve all tool calls)",
+      "  /yolo off          Disable YOLO mode (restore permission prompts)",
+      "  /yolo destructive  Toggle destructive confirmation gate (YOLO mode only)",
       "",
-      "YOLO mode skips all permission prompts and auto-approves every tool call.",
-      "Use with caution \u2014 the agent can execute any tool without asking."
+      "YOLO mode auto-approves everything, including destructive calls.",
+      "Use /yolo destructive to re-enable confirmation for risky operations."
     ].join("\n"),
     async run(args) {
       const arg = args.trim().toLowerCase();
@@ -6356,7 +6702,7 @@ function buildYoloCommand(opts) {
       }
       if (!arg) {
         const current = opts.onYolo();
-        const status = current ? `${color.yellow("ON")} ${color.dim("(auto-approving all tool calls)")}` : `${color.green("OFF")} ${color.dim("(permission prompts active)")}`;
+        const status = current ? `${color.yellow("ON")} ${color.dim("(auto-approving normal project work)")}` : `${color.green("OFF")} ${color.dim("(permission prompts active)")}`;
         const msg2 = `YOLO mode: ${status}`;
         opts.renderer.write(msg2);
         return { message: msg2 };
@@ -6374,7 +6720,7 @@ function buildYoloCommand(opts) {
         return { message: msg2 };
       }
       opts.onYolo(newState);
-      const label = newState ? `${color.yellow("ENABLED")} \u2014 all tool calls will be auto-approved` : `${color.green("DISABLED")} \u2014 permission prompts are active`;
+      const label = newState ? `${color.yellow("ENABLED")} \u2014 normal project tool calls will be auto-approved` : `${color.green("DISABLED")} \u2014 permission prompts are active`;
       const msg = `YOLO mode: ${label}`;
       opts.renderer.write(msg);
       return { message: msg };
@@ -6527,10 +6873,10 @@ async function runProjectCheck(opts) {
     if (answer2 === "y" || answer2 === "yes") {
       try {
         const { spawn: spawn3 } = await import('child_process');
-        await new Promise((resolve3, reject) => {
+        await new Promise((resolve4, reject) => {
           const child = spawn3("git", ["init"], { cwd: projectRoot });
           child.on("error", reject);
-          child.on("close", (code) => code === 0 ? resolve3() : reject(new Error(`git init failed with ${code}`)));
+          child.on("close", (code) => code === 0 ? resolve4() : reject(new Error(`git init failed with ${code}`)));
         });
         renderer.write(`  ${color.green("\u2713")} Git repository initialized
 `);
@@ -6581,7 +6927,7 @@ async function runLaunchPrompts(opts) {
     yolo = yoloPinned;
   } else {
     const answer = (await reader.readLine(
-      `  ${color.amber("?")} YOLO mode ${color.dim("(auto-approve every tool call)")} ${color.dim("[Y/n/q]")} `
+      `  ${color.amber("?")} YOLO mode ${color.dim("(auto-approve normal project work)")} ${color.dim("[Y/n/q]")} `
     )).trim().toLowerCase();
     if (answer === "q") {
       renderer.write(color.dim("  Goodbye!\n"));
@@ -6674,7 +7020,7 @@ var ReadlineInputReader = class {
   async readLine(prompt) {
     if (this.history.length === 0) await this.loadHistory();
     while (this.pending) {
-      await new Promise((resolve3) => setTimeout(resolve3, 50));
+      await new Promise((resolve4) => setTimeout(resolve4, 50));
     }
     this.pending = true;
     try {
@@ -6684,15 +7030,15 @@ var ReadlineInputReader = class {
         this.rl = void 0;
       }
       const fresh = this.ensure();
-      return new Promise((resolve3) => {
+      return new Promise((resolve4) => {
         fresh.question(prompt ?? "> ", (line) => {
           if (line.trim()) {
             this.history.push(line);
             void this.saveHistory();
           }
-          resolve3(line);
+          resolve4(line);
         });
-        fresh.once("close", () => resolve3(""));
+        fresh.once("close", () => resolve4(""));
       }).then((result) => {
         this.rl?.close();
         this.rl = void 0;
@@ -6704,7 +7050,7 @@ var ReadlineInputReader = class {
   }
   async readKey(prompt, options) {
     writeOut(prompt);
-    return new Promise((resolve3) => {
+    return new Promise((resolve4) => {
       const stdin = process.stdin;
       const wasRaw = stdin.isRaw;
       const wasPaused = stdin.isPaused();
@@ -6715,7 +7061,7 @@ var ReadlineInputReader = class {
         if (key === "") {
           cleanup();
           writeOut("\n");
-          resolve3("");
+          resolve4("");
           return;
         }
         const opt = options.find(
@@ -6725,12 +7071,12 @@ var ReadlineInputReader = class {
           cleanup();
           writeOut(`${opt.key}
 `);
-          resolve3(opt.value);
+          resolve4(opt.value);
         }
       };
       const onClose = () => {
         cleanup();
-        resolve3("");
+        resolve4("");
       };
       const cleanup = () => {
         stdin.off("data", onData);
@@ -6758,7 +7104,7 @@ var ReadlineInputReader = class {
     this.rl?.close();
     this.rl = void 0;
     writeOut(prompt);
-    return new Promise((resolve3) => {
+    return new Promise((resolve4) => {
       let buf = "";
       const wasRaw = stdin.isRaw;
       setRawMode(stdin, true);
@@ -6776,7 +7122,7 @@ var ReadlineInputReader = class {
             cleanup();
             writeOut(`  ${dim(`[${buf.length} chars]`)}
 `);
-            resolve3(buf);
+            resolve4(buf);
             return;
           }
           if (ch === "") {
@@ -7138,11 +7484,11 @@ async function restoreLast(homeFn = defaultHomeDir) {
 var theme = { primary: color.amber };
 async function saveToGlobalConfig(configPath2, provider, model, homeFn = () => process.env.HOME ?? __require("os").homedir()) {
   try {
-    const { atomicWrite: atomicWrite12 } = await import('@wrongstack/core');
-    const fs24 = await import('fs/promises');
+    const { atomicWrite: atomicWrite13 } = await import('@wrongstack/core');
+    const fs25 = await import('fs/promises');
     let existing = {};
     try {
-      const raw = await fs24.readFile(configPath2, "utf8");
+      const raw = await fs25.readFile(configPath2, "utf8");
       existing = JSON.parse(raw);
     } catch {
     }
@@ -7150,7 +7496,7 @@ async function saveToGlobalConfig(configPath2, provider, model, homeFn = () => p
     existing.provider = provider;
     existing.model = model;
     await backupCurrent(homeFn);
-    await atomicWrite12(configPath2, JSON.stringify(existing, null, 2), { mode: 384 });
+    await atomicWrite13(configPath2, JSON.stringify(existing, null, 2), { mode: 384 });
     try {
       await appendHistory(
         oldCfg,
@@ -7440,7 +7786,7 @@ var GROUPS = [
     items: [
       { key: "/mode", blurb: "switch persona: code-reviewer, debugger, architect, tester, devops, \u2026" },
       { key: "/model", blurb: "two-step provider \u2192 model picker, hot-swap at runtime" },
-      { key: "/yolo on|off|toggle", blurb: "auto-approve every tool call without restart" },
+      { key: "/yolo on|off|toggle", blurb: "auto-approve normal project work without restart" },
       { key: "/context mode frugal|balanced|deep|archival", blurb: "pick how aggressively history is trimmed" },
       { key: "/compact", blurb: "manually compact the in-flight context window" },
       { key: "/plan show|add|start|done", blurb: "strategic roadmap, survives /resume across sessions" }
@@ -7473,12 +7819,12 @@ function pickGroupIndex(opts) {
     try {
       let current = 0;
       try {
-        const parsed = Number.parseInt(fs11.readFileSync(opts.cursorFile, "utf8").trim(), 10);
+        const parsed = Number.parseInt(fs12.readFileSync(opts.cursorFile, "utf8").trim(), 10);
         if (Number.isFinite(parsed)) current = wrap(parsed);
       } catch {
       }
-      fs11.mkdirSync(path8.dirname(opts.cursorFile), { recursive: true });
-      fs11.writeFileSync(opts.cursorFile, String(wrap(current + 1)));
+      fs12.mkdirSync(path8.dirname(opts.cursorFile), { recursive: true });
+      fs12.writeFileSync(opts.cursorFile, String(wrap(current + 1)));
       return current;
     } catch {
     }
@@ -8680,8 +9026,9 @@ var updateCmd = async (args, deps) => {
   deps.renderer.write(`Updating wrongstack from v${info.current} to v${info.latest}...
 `);
   try {
-    const result = await new Promise((resolve3, reject) => {
-      const child = spawn("npm", ["install", "-g", "wrongstack@latest"], {
+    const result = await new Promise((resolve4, reject) => {
+      const npmCommand = process.platform === "win32" ? "npm.cmd" : "npm";
+      const child = spawn(npmCommand, ["install", "-g", "wrongstack@latest"], {
         cwd,
         stdio: "pipe"
       });
@@ -8690,7 +9037,7 @@ var updateCmd = async (args, deps) => {
         _stderr += d;
       });
       child.on("error", reject);
-      child.on("close", (code) => resolve3({ code: code ?? 0 }));
+      child.on("close", (code) => resolve4({ code: code ?? 0 }));
     });
     if (result.code === 0) {
       deps.renderer.write(`
@@ -9016,9 +9363,160 @@ var initCmd = async (_args, deps) => {
   deps.renderer.writeInfo('Try: wstack "<task>"  or  wstack');
   return 0;
 };
+var AllowAllPermissionPolicy = class extends AutoApprovePermissionPolicy {
+  async evaluate() {
+    return { permission: "auto", source: "default" };
+  }
+};
+function parseToolsFlag(flags) {
+  const raw = flags["tools"];
+  if (typeof raw !== "string") return null;
+  const set = new Set(
+    raw.split(",").map((s) => s.trim()).filter(Boolean)
+  );
+  return set.size > 0 ? set : null;
+}
+function makeServeContext(cwd, projectRoot, signal) {
+  const provider = {
+    id: "mcp-serve",
+    capabilities: { maxContext: 0 },
+    complete: async () => {
+      throw new Error("no model provider in `mcp serve` mode");
+    },
+    stream: () => {
+      throw new Error("no model provider in `mcp serve` mode");
+    }
+  };
+  const session = { append: async () => {
+  } };
+  const tokenCounter = {
+    account: () => {
+    },
+    total: () => ({ input: 0, output: 0 }),
+    estimateCost: () => ({ total: 0 })
+  };
+  return new Context({
+    systemPrompt: [],
+    provider,
+    session,
+    signal,
+    tokenCounter,
+    cwd,
+    projectRoot,
+    model: "mcp-serve",
+    tools: []
+  });
+}
+async function selectExposedTools(registry, ctx, policy, whitelist) {
+  const allowed = [];
+  for (const tool of registry.list()) {
+    if (whitelist && !whitelist.has(tool.name)) continue;
+    const decision = await policy.evaluate(tool, {}, ctx);
+    if (decision.permission === "auto") allowed.push(tool);
+  }
+  return allowed;
+}
+async function serveMcpStdio(deps) {
+  const flags = deps.flags ?? {};
+  const yolo = flags["yolo"] === true || flags["allow-all"] === true;
+  const whitelist = parseToolsFlag(flags);
+  const log = (m) => process.stderr.write(`${m}
+`);
+  let registry = deps.toolRegistry;
+  if (!registry) {
+    registry = new ToolRegistry();
+    registry.registerAllOrThrow([...builtinToolsPack.tools ?? []], builtinToolsPack.name);
+  }
+  const controller = new AbortController();
+  const ctx = makeServeContext(deps.cwd, deps.projectRoot, controller.signal);
+  const permissionPolicy = yolo ? new AllowAllPermissionPolicy() : new AutoApprovePermissionPolicy();
+  const executor = new ToolExecutor(registry, {
+    permissionPolicy,
+    secretScrubber: new DefaultSecretScrubber(),
+    perIterationOutputCapBytes: 1e6
+  });
+  const allowed = await selectExposedTools(registry, ctx, permissionPolicy, whitelist);
+  const allowedNames = new Set(allowed.map((t) => t.name));
+  if (allowed.length === 0) {
+    log(
+      "wrongstack MCP server: no tools to expose (all withheld by policy or filtered out). Pass --yolo to expose write/exec tools, or --tools <names> to whitelist."
+    );
+  }
+  let counter = 0;
+  const host = {
+    listTools: () => allowed.map((t) => ({
+      name: t.name,
+      description: t.description,
+      inputSchema: t.inputSchema ?? { type: "object" }
+    })),
+    callTool: async (name, callArgs) => {
+      if (!allowedNames.has(name)) {
+        return { content: `Tool "${name}" is not exposed by this server`, isError: true };
+      }
+      const use = {
+        type: "tool_use",
+        id: `srv_${++counter}`,
+        name,
+        input: callArgs
+      };
+      const batch = await executor.executeBatch([use], ctx, "sequential");
+      const result = batch.outputs[0]?.result;
+      if (!result || result.type === "tool_confirm_pending") {
+        return {
+          content: `Tool "${name}" requires interactive confirmation, which is unavailable over MCP`,
+          isError: true
+        };
+      }
+      return { content: result.content, isError: Boolean(result.is_error) };
+    }
+  };
+  const server = new MCPServer({
+    host,
+    logger: { warn: (m) => log(`[mcp-serve] ${m}`) }
+  });
+  const mode = yolo ? "yolo: all tools" : "safe: read-only tools";
+  if (flags["http"] === true || typeof flags["http"] === "string" || flags["port"] || flags["host"]) {
+    const port = Number(flags["port"] ?? flags["http"] ?? 0) || 0;
+    const httpHost = typeof flags["host"] === "string" ? flags["host"] : "127.0.0.1";
+    const token = typeof flags["token"] === "string" ? flags["token"] : void 0;
+    let handle2;
+    try {
+      handle2 = await serveHttp(server, {
+        port,
+        host: httpHost,
+        token,
+        logger: { warn: (m) => log(`[mcp-serve] ${m}`) }
+      });
+    } catch (err) {
+      log(`wrongstack MCP server: ${err instanceof Error ? err.message : String(err)}`);
+      return 1;
+    }
+    log(
+      `wrongstack MCP server ready at ${handle2.url} \u2014 exposing ${allowed.length} tool(s) (${mode})${token ? " [token auth]" : ""}.`
+    );
+    await new Promise((resolve4) => {
+      const stop = () => resolve4();
+      process.once("SIGINT", stop);
+      process.once("SIGTERM", stop);
+    });
+    await handle2.close();
+    controller.abort();
+    return 0;
+  }
+  log(`wrongstack MCP server ready on stdio \u2014 exposing ${allowed.length} tool(s) (${mode}).`);
+  const handle = serveStdio(server);
+  await handle.done;
+  controller.abort();
+  return 0;
+}
+
+// src/subcommands/handlers/mcp.ts
 var BUILT_IN_MCP = allServers();
 var mcpCmd = async (args, deps) => {
   const sub = args[0];
+  if (sub === "serve") {
+    return serveMcpStdio(deps);
+  }
   if (!sub || sub === "list") {
     const servers = deps.config.mcpServers ?? {};
     if (Object.keys(servers).length === 0) {
@@ -10266,10 +10764,10 @@ var auditCmd = async (args, deps) => {
   return verify.ok ? 0 : 1;
 };
 async function listAudits(log, dir, deps) {
-  const fs24 = await import('fs/promises');
+  const fs25 = await import('fs/promises');
   let entries;
   try {
-    entries = await fs24.readdir(dir);
+    entries = await fs25.readdir(dir);
   } catch {
     deps.renderer.write(
       color.dim(`No sessions dir found at ${dir}. Run a session first.`) + "\n"
@@ -10356,7 +10854,18 @@ var helpCmd = async (_args, deps) => {
     "  wstack doctor                Health checks",
     "  wstack export <id> [opts]    Render a session",
     "  wstack usage                 Token + cost summary",
-    "  wstack version               Print version"
+    "  wstack version               Print version",
+    "",
+    color.bold("Common flags"),
+    "  --yolo                       Auto-approve all tool calls (including destructive)",
+    "  --confirm-destructive         In YOLO mode, still prompt for destructive operations",
+    "  --yolo-destructive            Deprecated \u2014 YOLO now auto-approves everything by default",
+    "  --tui / --no-tui             Force or disable TUI mode",
+    "  --webui [--port <n>] [--open] Serve the browser UI + WS bridge (prints a URL,",
+    "                               --open pops the browser; shares this terminal's",
+    "                               agent; auto-picks free ports)",
+    '  --eternal "<mission>"        Start an eternal-autonomy loop',
+    "  --no-hints                   Hide launch hints"
   ];
   deps.renderer.write(lines.join("\n") + "\n");
   return 0;
@@ -10529,7 +11038,8 @@ async function boot(argv) {
       vault,
       cwd,
       projectRoot,
-      userHome
+      userHome,
+      flags
     });
     await reader.close();
     return code;
@@ -10582,6 +11092,10 @@ async function boot(argv) {
       return 2;
     }
   }
+  if (flags["webui"]) {
+    flags["tui"] = false;
+    flags["no-tui"] = true;
+  }
   if (isInteractiveTTY) {
     let modePinned;
     if (flags["no-tui"]) modePinned = "repl";
@@ -10647,6 +11161,20 @@ async function boot(argv) {
     updateInfo
   };
 }
+var CONTEXT_OVERFLOW_RE = /context window|exceeds the context|too many tokens|context.*tokens/i;
+function contextOverflowHint(err) {
+  const structured = err.code === ERROR_CODES.PROVIDER_CONTEXT_OVERFLOW || err.code === ERROR_CODES.AGENT_CONTEXT_OVERFLOW;
+  const textual = CONTEXT_OVERFLOW_RE.test(`${err.message}
+${err.describe()}`);
+  if (!structured && !textual) return null;
+  return [
+    "Provider rejected the request as over its effective context window.",
+    "If you use a custom baseUrl/proxy, the real limit may be lower than models.dev reports.",
+    "Try: /context limit 220k",
+    "Then, if needed: /context thresholds 50% 70% 85%",
+    "Persistent config: set context.effectiveMaxContext."
+  ].join("\n");
+}
 function fmtElapsed(ms) {
   const s = Math.floor(ms / 1e3);
   if (s < 60) return `${s}s`;
@@ -11006,7 +11534,7 @@ async function runRepl(opts) {
               `[eternal] ${err instanceof Error ? err.message : String(err)}`
             );
           }
-          await new Promise((resolve3) => setTimeout(resolve3, 250));
+          await new Promise((resolve4) => setTimeout(resolve4, 250));
           continue;
         }
       } else if (opts.getAutonomy?.() === "eternal-parallel") {
@@ -11052,7 +11580,7 @@ async function runRepl(opts) {
               `[parallel] ${err instanceof Error ? err.message : String(err)}`
             );
           }
-          await new Promise((resolve3) => setTimeout(resolve3, 250));
+          await new Promise((resolve4) => setTimeout(resolve4, 250));
           continue;
         }
       }
@@ -11238,6 +11766,8 @@ ${taskList}`;
           if (err) {
             const tag = err.recoverable ? " (recoverable)" : "";
             opts.renderer.writeError(`Failed [${err.severity}]${tag}: ${err.describe()}`);
+            const hint = contextOverflowHint(err);
+            if (hint) opts.renderer.writeWarning(hint);
           } else {
             opts.renderer.writeError("Failed.");
           }
@@ -11679,6 +12209,8 @@ async function execute(deps) {
           if (err) {
             const tag = err.recoverable ? " (recoverable)" : "";
             renderer.writeError(`Failed [${err.severity}]${tag}: ${err.describe()}`);
+            const hint = contextOverflowHint(err);
+            if (hint) renderer.writeWarning(hint);
           } else {
             renderer.writeError("Failed.");
           }
@@ -11698,7 +12230,7 @@ async function execute(deps) {
           ) + "\n"
         );
       }
-    } else if (flags.tui && !flags["no-tui"]) {
+    } else if (flags.tui && !flags["no-tui"] && !flags.webui) {
       agent.disableInteractiveConfirmation();
       const { runTui } = await import('@wrongstack/tui');
       renderer.setSilent(true);
@@ -11887,12 +12419,15 @@ async function execute(deps) {
         renderer.setSilent(false);
       }
     } else if (flags.webui) {
+      agent.disableInteractiveConfirmation();
       const { runWebUI: runWebUI2 } = await Promise.resolve().then(() => (init_webui_server(), webui_server_exports));
       const webuiPromise = runWebUI2({
         agent,
         events,
         session,
         port: Number.parseInt(String(flags.port ?? "3457"), 10),
+        projectRoot,
+        open: !!flags.open,
         modelsRegistry,
         globalConfigPath: wpaths.globalConfig,
         subscribeEternalIteration
@@ -12823,7 +13358,7 @@ function samplePaths(set) {
 }
 var WORKTREE_PHASE_CONCURRENCY = 4;
 function gitText(args, cwd) {
-  return new Promise((resolve3) => {
+  return new Promise((resolve4) => {
     let out = "";
     const child = spawn("git", args, {
       cwd,
@@ -12836,8 +13371,8 @@ function gitText(args, cwd) {
     child.stderr?.on("data", (c) => {
       out += c.toString();
     });
-    child.on("error", () => resolve3({ code: 1, out }));
-    child.on("close", (code) => resolve3({ code: code ?? 1, out: out.trim() }));
+    child.on("error", () => resolve4({ code: 1, out }));
+    child.on("close", (code) => resolve4({ code: code ?? 1, out: out.trim() }));
   });
 }
 async function isGitRepo(cwd) {
@@ -12845,7 +13380,7 @@ async function isGitRepo(cwd) {
   return code === 0 && out.trim() === "true";
 }
 function runCmd(cmd, args, cwd, shell = false) {
-  return new Promise((resolve3) => {
+  return new Promise((resolve4) => {
     let out = "";
     const child = spawn(cmd, args, {
       cwd,
@@ -12859,8 +13394,8 @@ function runCmd(cmd, args, cwd, shell = false) {
     child.stderr?.on("data", (c) => {
       out += c.toString();
     });
-    child.on("error", (e) => resolve3({ code: 1, out: `${out}${String(e)}` }));
-    child.on("close", (code) => resolve3({ code: code ?? 1, out: out.trim() }));
+    child.on("error", (e) => resolve4({ code: 1, out: `${out}${String(e)}` }));
+    child.on("close", (code) => resolve4({ code: code ?? 1, out: out.trim() }));
   });
 }
 function detectPackageManager2(root) {
@@ -13253,13 +13788,6 @@ function renderProgress3(ratio, width) {
   const capped = Math.min(width, filled);
   return FILLED2.repeat(capped) + EMPTY2.repeat(width - capped);
 }
-var createSessionEventBridge = (_writer, level) => ({
-  append: async (_e) => {
-  },
-  level: level ?? "standard",
-  allows: () => true
-});
-var resolveAuditLevel = (cfg) => cfg?.session?.auditLevel ?? "standard";
 function setupPipelines(params) {
   const { events, logger } = params;
   const pipelines = createDefaultPipelines();
@@ -13305,6 +13833,10 @@ async function setupCompaction(params) {
     providerId: config.provider ?? provider.id,
     modelId: config.model ?? context.model
   });
+  const initialPolicy = resolveContextWindowPolicy(config.context);
+  context.meta ??= {};
+  context.meta["contextWindowMode"] = initialPolicy.id;
+  context.meta["contextWindowPolicy"] = initialPolicy;
   let autoCompactor;
   if (config.context.autoCompact !== false && effectiveMaxContext > 0) {
     const auditLevel = resolveAuditLevel(fullConfig ?? config);
@@ -13315,15 +13847,15 @@ async function setupCompaction(params) {
       // Calibrated estimator: recordActualUsage() is called after each API
       // response so this converges on real token counts for compaction decisions.
       (ctx) => estimateRequestTokensCalibrated(ctx.messages, ctx.systemPrompt, ctx.tools ?? []).total,
+      initialPolicy.thresholds,
       {
-        warn: config.context.warnThreshold,
-        soft: config.context.softThreshold,
-        hard: config.context.hardThreshold
-      },
-      {
-        aggressiveOn: "soft",
+        aggressiveOn: initialPolicy.aggressiveOn,
         failureMode: "throw_on_hard",
         events,
+        policyProvider: (ctx) => {
+          const policy = ctx.meta?.["contextWindowPolicy"];
+          return policy && typeof policy === "object" ? policy : null;
+        },
         sessionBridge
       }
     );
@@ -13342,7 +13874,8 @@ function createAgent(params) {
     confirmAwaiter: params.confirmAwaiter,
     iterationTimeoutMs: params.config.tools.iterationTimeoutMs,
     perIterationOutputCapBytes: params.config.tools.perIterationOutputCapBytes,
-    tracer: params.tracer
+    tracer: params.tracer,
+    hookRunner: params.hookRunner
   });
   return new Agent({
     container: params.container,
@@ -13360,6 +13893,139 @@ function createAgent(params) {
     tracer: params.tracer
   });
 }
+function parseModelRef(ref) {
+  const trimmed = ref.trim();
+  const slash = trimmed.indexOf("/");
+  if (slash !== -1) {
+    return {
+      provider: trimmed.slice(0, slash) || void 0,
+      model: trimmed.slice(slash + 1).trim()
+    };
+  }
+  const parts = trimmed.split(/\s+/);
+  if (parts.length >= 2) {
+    return { provider: parts[0], model: parts.slice(1).join(" ") };
+  }
+  return { model: trimmed };
+}
+function overloadStatus(err) {
+  if (!(err instanceof ProviderError)) return null;
+  const s = err.status;
+  if (s === 429 || s === 529 || s >= 500) return s;
+  return null;
+}
+function createFallbackModelExtension(deps) {
+  const initial = deps.getConfig().fallbackModels ?? [];
+  if (initial.length === 0) return null;
+  let dirty = false;
+  return {
+    name: "fallback-model",
+    beforeRun: (ctx) => {
+      if (!dirty) return;
+      const cfg = deps.getConfig();
+      try {
+        ctx.provider = deps.buildProvider(cfg.provider);
+        ctx.model = cfg.model;
+        deps.onModelSwitch?.(cfg.provider, cfg.model);
+      } catch (err) {
+        deps.logger.warn(
+          `fallback-model: could not restore primary "${cfg.provider}/${cfg.model}": ${err instanceof Error ? err.message : String(err)}`
+        );
+      }
+      dirty = false;
+    },
+    wrapProviderRunner: async (ctx, request, inner) => {
+      try {
+        return await inner(ctx, request);
+      } catch (firstErr) {
+        let lastErr = firstErr;
+        const cfg = deps.getConfig();
+        const chain = cfg.fallbackModels ?? [];
+        for (const ref of chain) {
+          const status = overloadStatus(lastErr);
+          if (status === null) break;
+          const parsed = parseModelRef(ref);
+          if (!parsed.model) continue;
+          const targetProviderId = parsed.provider ?? cfg.provider;
+          const from = { providerId: ctx.provider.id, model: ctx.model };
+          let nextProvider;
+          try {
+            nextProvider = deps.buildProvider(targetProviderId);
+          } catch (err) {
+            deps.logger.warn(
+              `fallback-model: skipping "${ref}" \u2014 cannot build provider "${targetProviderId}": ${err instanceof Error ? err.message : String(err)}`
+            );
+            continue;
+          }
+          const providerSwitched = nextProvider.id !== from.providerId;
+          ctx.provider = nextProvider;
+          ctx.model = parsed.model;
+          request.model = parsed.model;
+          dirty = true;
+          deps.onModelSwitch?.(targetProviderId, parsed.model);
+          deps.events.emit("provider.fallback", {
+            from,
+            to: { providerId: nextProvider.id, model: parsed.model },
+            status,
+            providerSwitched
+          });
+          try {
+            return await inner(ctx, request);
+          } catch (err) {
+            lastErr = err;
+          }
+        }
+        throw lastErr;
+      }
+    }
+  };
+}
+
+// src/hooks-wiring.ts
+var HookBlockedError = class extends Error {
+  constructor(reason) {
+    super(`Prompt blocked by hook: ${reason}`);
+    this.name = "HookBlockedError";
+  }
+};
+function createUserPromptSubmitMiddleware(hookRunner) {
+  return {
+    name: "UserPromptSubmitHooks",
+    handler: async (payload, next) => {
+      const prompt = payload.text;
+      if (prompt && hookRunner.has("UserPromptSubmit")) {
+        const r = await hookRunner.userPromptSubmit(prompt, payload.ctx);
+        if (r.block) throw new HookBlockedError(r.reason ?? "no reason given");
+        if (r.additionalContext) {
+          const block = { type: "text", text: r.additionalContext };
+          payload.content = [...payload.content, block];
+          payload.text = `${prompt}
+
+${r.additionalContext}`;
+        }
+      }
+      return next(payload);
+    }
+  };
+}
+function createLifecycleHooksExtension(hookRunner) {
+  let started = false;
+  return {
+    name: "lifecycle-hooks",
+    beforeRun: async (ctx) => {
+      if (started) return;
+      started = true;
+      if (!hookRunner.has("SessionStart")) return;
+      const r = await hookRunner.sessionStart(ctx);
+      if (r.additionalContext) {
+        ctx.systemPrompt.push({ type: "text", text: r.additionalContext });
+      }
+    },
+    afterRun: async (ctx) => {
+      if (hookRunner.has("Stop")) await hookRunner.stop(ctx);
+    }
+  };
+}
 function setupMetrics(params) {
   const { flags, wpaths, events, logger, config } = params;
   let metricsSink;
@@ -13475,7 +14141,8 @@ async function setupPlugins(params) {
     skillLoader,
     configStore,
     pipelines,
-    paths
+    paths,
+    hookRegistry
   } = params;
   const builtinPlugins = [];
   const disabledBuiltins = new Set(
@@ -13540,6 +14207,7 @@ async function setupPlugins(params) {
       config: pluginConfig,
       log,
       extensions: agent.extensions,
+      hookRegistry,
       sessionWriter: {
         transcriptPath: sessionWriter.transcriptPath,
         append: (e) => sessionWriter.append(e)
@@ -13785,10 +14453,8 @@ async function launchEternalFromFlag(deps) {
     lastActivityAt: (/* @__PURE__ */ new Date()).toISOString()
   } : emptyGoal2(eternalFlag);
   await saveGoal2(goalPath, next);
-  const policy = deps.container.resolve(
-    TOKENS.PermissionPolicy
-  );
-  policy.setYolo(true);
+  const policy = deps.container.resolve(TOKENS.PermissionPolicy);
+  policy.setYolo?.(true);
   deps.configRef.current = patchConfig(deps.configRef.current, { yolo: true });
   const compactor = deps.container.resolve(TOKENS.Compactor);
   const engine = new EternalAutonomyEngine({
@@ -13810,21 +14476,6 @@ async function launchEternalFromFlag(deps) {
 }
 
 // src/index.ts
-var createSessionEventBridge2 = (_writer, level, _opts) => ({
-  append: async (_e) => {
-  },
-  level: level ?? "standard",
-  allows: () => true
-});
-var resolveAuditLevel2 = (cfg) => cfg?.session?.auditLevel ?? "standard";
-var resolveSessionLoggingConfig = (cfg) => ({
-  auditLevel: resolveAuditLevel2(cfg),
-  sampling: {
-    toolProgress: {
-      sampleRate: cfg?.session?.sampling?.toolProgress?.sampleRate ?? 8
-    }
-  }
-});
 async function main(argv) {
   const ctx = await boot(argv);
   if (typeof ctx === "number") return ctx;
@@ -13851,7 +14502,8 @@ async function main(argv) {
     modelsRegistry,
     permission: {
       yolo: config.yolo,
-      forceAllYolo: flags["force-all-yolo"] === true,
+      yoloDestructive: flags["yolo-destructive"] === true || flags["force-all-yolo"] === true,
+      confirmDestructive: flags["confirm-destructive"] === true,
       promptDelegate: makePromptDelegate(reader)
     },
     compactor: {
@@ -14042,9 +14694,13 @@ async function main(argv) {
   const detachTodosCheckpoint = sessResult.detachTodosCheckpoint;
   const priorFleetState = sessResult.priorFleetState;
   const sessionConfig = resolveSessionLoggingConfig(config);
-  const sessionBridge = createSessionEventBridge2(
+  const sessionBridge = createSessionEventBridge(
     session,
-    sessionConfig.auditLevel);
+    sessionConfig.auditLevel,
+    {
+      sampling: sessionConfig.sampling
+    }
+  );
   const stats = new SessionStats(events, tokenCounter);
   const errorRing = [];
   events.on("error", (e) => {
@@ -14121,6 +14777,19 @@ async function main(argv) {
     });
   });
   const pipelines = setupPipelines({ events, logger });
+  const hooksEnabled = flags["no-hooks"] !== true;
+  const hookRegistry = new HookRegistry();
+  if (hooksEnabled) hookRegistry.loadShellHooks(config.hooks);
+  container.bind(TOKENS.HookRegistry, () => hookRegistry);
+  const hookRunner = new HookRunner({
+    registry: hookRegistry,
+    logger,
+    allowShell: hooksEnabled,
+    sessionId: () => session.id
+  });
+  if (hooksEnabled) {
+    pipelines.userInput.use(createUserPromptSubmitMiddleware(hookRunner));
+  }
   const compactor = container.resolve(TOKENS.Compactor);
   const compactionSetup = await setupCompaction({
     compactor,
@@ -14167,8 +14836,12 @@ async function main(argv) {
     pipelines,
     context,
     config,
-    confirmAwaiter: makeConfirmAwaiter(reader)
+    confirmAwaiter: makeConfirmAwaiter(reader),
+    hookRunner
   });
+  if (hooksEnabled) {
+    agent.extensions.register(createLifecycleHooksExtension(hookRunner));
+  }
   const mcpRegistry = new MCPRegistry({ toolRegistry, events, log: logger });
   if (config.features.mcp) {
     for (const cfg of Object.values(config.mcpServers ?? {})) {
@@ -14196,24 +14869,41 @@ async function main(argv) {
     healthRegistry,
     skillLoader: config.features.skills ? skillLoader : void 0,
     configStore,
-    paths: wpaths
+    paths: wpaths,
+    hookRegistry
+  });
+  const resolveProviderCfg = (providerId) => {
+    const savedCfg = config.providers?.[providerId];
+    const resolvedProviderId = savedCfg?.type ?? providerId;
+    const cfgWithType = {
+      ...savedCfg ?? { type: providerId, apiKey: config.apiKey, baseUrl: config.baseUrl },
+      type: resolvedProviderId
+    };
+    return { resolvedProviderId, cfgWithType };
+  };
+  const buildProviderForId = (providerId) => {
+    const { resolvedProviderId, cfgWithType } = resolveProviderCfg(providerId);
+    return config.features.modelsRegistry && providerRegistry.has(resolvedProviderId) ? providerRegistry.create(cfgWithType) : makeProviderFromConfig(resolvedProviderId, cfgWithType);
+  };
+  const refreshMaxContextFor = (providerId, modelId) => {
+    const { resolvedProviderId, cfgWithType } = resolveProviderCfg(providerId);
+    void refreshMaxContext(resolvedProviderId, modelId, cfgWithType);
+  };
+  const fallbackExtension = createFallbackModelExtension({
+    getConfig: () => config,
+    buildProvider: buildProviderForId,
+    onModelSwitch: refreshMaxContextFor,
+    events,
+    logger
   });
+  if (fallbackExtension) agent.extensions.register(fallbackExtension);
   const switchProviderAndModel = (providerId, modelId) => {
     try {
-      const savedCfg = config.providers?.[providerId];
-      const resolvedProviderId = savedCfg?.type ?? providerId;
-      const newCfg = savedCfg ?? {
-        type: providerId,
-        apiKey: config.apiKey,
-        baseUrl: config.baseUrl
-      };
-      const cfgWithType = { ...newCfg, type: resolvedProviderId };
-      const newProvider = config.features.modelsRegistry && providerRegistry.has(resolvedProviderId) ? providerRegistry.create(cfgWithType) : makeProviderFromConfig(resolvedProviderId, cfgWithType);
-      context.provider = newProvider;
+      context.provider = buildProviderForId(providerId);
       context.model = modelId;
       config = patchConfig(config, { provider: providerId, model: modelId });
       configStore.update({ provider: providerId, model: modelId });
-      void refreshMaxContext(resolvedProviderId, modelId, cfgWithType);
+      refreshMaxContextFor(providerId, modelId);
       return null;
     } catch (err) {
       return err instanceof Error ? err.message : String(err);
@@ -14820,6 +15510,21 @@ Restart WrongStack to load or unload plugin code in this session.`;
       }
       return result.message;
     },
+    onContextLimit: (tokens) => {
+      if (typeof tokens === "number" && Number.isFinite(tokens) && tokens > 0) {
+        effectiveMaxContext = tokens;
+        context.provider.capabilities.maxContext = tokens;
+        context.meta["effectiveMaxContext"] = tokens;
+        autoCompactor?.setMaxContext(tokens);
+        events.emit("ctx.max_context", {
+          providerId: config.provider,
+          modelId: context.model,
+          maxContext: tokens
+        });
+        updateSpinnerContext();
+      }
+      return effectiveMaxContext;
+    },
     onMcp: async (args) => {
       const parsed = parseMcpArgs(args);
       if (!parsed) {
@@ -14838,11 +15543,11 @@ Restart WrongStack to load or unload plugin code in this session.`;
     onYolo: (setTo) => {
       const policy = container.resolve(TOKENS.PermissionPolicy);
       if (setTo !== void 0) {
-        policy.setYolo(setTo);
+        policy.setYolo?.(setTo);
         config = patchConfig(config, { yolo: setTo });
         return setTo;
       }
-      return policy.getYolo();
+      return policy.getYolo?.() ?? config.yolo ?? false;
     },
     onNextPredict: (setTo) => {
       if (setTo !== void 0) {
@@ -14905,7 +15610,7 @@ Restart WrongStack to load or unload plugin code in this session.`;
       const { spawn: spawn3 } = await import('child_process');
       const cwd2 = projectRoot;
       const statusResult = await new Promise(
-        (resolve3, reject) => {
+        (resolve4, reject) => {
           const child = spawn3("git", ["status", "--porcelain"], {
             cwd: cwd2,
             stdio: ["ignore", "pipe", "pipe"]
@@ -14915,7 +15620,7 @@ Restart WrongStack to load or unload plugin code in this session.`;
             stdout += d;
           });
           child.on("error", reject);
-          child.on("close", (code) => resolve3({ stdout, code: code ?? 0 }));
+          child.on("close", (code) => resolve4({ stdout, code: code ?? 0 }));
         }
       );
       if (statusResult.stdout.trim().length > 0) {
@@ -15076,7 +15781,7 @@ Restart WrongStack to load or unload plugin code in this session.`;
     setStatuslineHiddenItems,
     getYolo: () => {
       const policy = container.resolve(TOKENS.PermissionPolicy);
-      return policy.getYolo();
+      return policy.getYolo?.() ?? config.yolo ?? false;
     },
     getAutonomy: () => autonomyMode,
     onAutonomy: (setTo) => {