@wrongstack/cli 0.141.0 → 0.148.0

package/dist/index.js

@@ -2,7 +2,7 @@
 import { color, writeErr, renderProgress, SpecStore, TaskGraphStore, analyzeCriticalPath, getTemplate, listTemplates, templateToMarkdown, SpecParser, renderSpecAnalysis, AISpecBuilder, expectDefined, DefaultTaskStore, TaskTracker, renderTaskGraph, DefaultSecretScrubber, DefaultPathResolver, EventBus, TOKENS, mergeCustomModelDefs, DefaultSystemPromptBuilder, makeAutonomyPromptContributor, ToolRegistry, createContextManagerTool, resolveSessionLoggingConfig, createSessionEventBridge, HookRegistry, HookRunner, SlashCommandRegistry, SessionMemoryConsolidator, BrainDecisionQueue, ObservableBrainArbiter, HumanEscalatingBrainArbiter, DefaultBrainArbiter, createDelegateTool, FLEET_ROSTER, createMcpControlTool, SpecVersioning, atomicWrite, DefaultLogger, DefaultModelsRegistry, isStdinTTY, writeOut, runProviderWithRetry, ReplayLogStore, ReplayProviderRunner, ProviderRegistry, InMemoryMetricsSink, wireMetricsToEvents, DefaultHealthRegistry, startMetricsServer, DEFAULT_SESSION_PRUNE_DAYS, RecoveryLock, DefaultAttachmentStore, QueueStore, Context, loadTodosCheckpoint, attachTodosCheckpoint, loadDirectorState, loadPlan, createDefaultPipelines, resolveContextWindowPolicy, resolveAuditLevel, AutoCompactionMiddleware, estimateRequestTokensCalibrated, Agent, loadPlugins, FleetManager, makeDirectorSessionFactory, Director, makeFleetEmitTool, makeFleetStatusTool, resolveModelMatrix, DEFAULT_SUBAGENT_BASELINE, AutoApprovePermissionPolicy, PhaseStore, AutoPhasePlanner, PhaseGraphBuilder, WorktreeManager, PhaseOrchestrator, makeLLMClassifier, ParallelEternalEngine, EternalAutonomyEngine, allServers as allServers$1, decryptConfigSecrets as decryptConfigSecrets$1, encryptConfigSecrets as encryptConfigSecrets$1, bootConfig as bootConfig$1, setOutputLineGuard, setRawMode, DefaultSessionReader, resolveWstackPaths, ToolAuditLog, DefaultSessionRewinder, DefaultSessionStore, DefaultPluginAPI, StreamHangError, ProviderError, makeAgentSubagentRunner, NULL_FLEET_BUS, buildChildEnv, formatContextWindowModeList, repairToolUseAdjacency, getContextWindowMode, AGENTS_BY_PHASE, dispatchAgent, formatTodosList, loadTasks, emptyTaskFile, saveTasks, formatTaskProgress, formatTaskList, SessionRecovery, loadGoal, goalFilePath, summarizeUsage, saveGoal, formatGoal, emptyGoal, buildGoalPreamble, pendingBtwCount, setBtwNote, MATRIX_PHASE_KEYS, AGENT_CATALOG, matrixKeyKind, phaseForRole, onResize, ERROR_CODES, InputBuilder, FsError, estimateMessageTokens } from '@wrongstack/core';
 import * as fsp4 from 'fs/promises';
 import { DefaultSecretVault, decryptConfigSecrets, encryptConfigSecrets, isSecretField } from '@wrongstack/core/security';
-import * as path9 from 'path';
+import * as path10 from 'path';
 import { join } from 'path';
 import { createRequire } from 'module';
 import * as os2 from 'os';
@@ -11,14 +11,14 @@ import * as crypto2 from 'crypto';
 import { randomUUID } from 'crypto';
 import { findFreePort, createHttpServer, openBrowser, registerInstance, unregisterInstance } from '@wrongstack/webui/server';
 import { WebSocketServer, WebSocket } from 'ws';
-import { spawn } from 'child_process';
+import { spawn, exec, execFileSync } from 'child_process';
 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, searchMemoryTool, relatedMemoryTool, runStartupIndex, isIndexableFile, enqueueReindex, cancelPendingReindexes } from '@wrongstack/tools';
 import { fileURLToPath } from 'url';
 import * as readline from 'readline';
-import * as fs14 from 'fs';
+import * as fs15 from 'fs';
 import { writeFileSync, existsSync, readFileSync } from 'fs';
 import { WrongStackACPServer } from '@wrongstack/acp/agent';
 import { ACP_AGENT_COMMANDS, makeACPSubagentRunner, makeACPSubagentRunnerWithStop } from '@wrongstack/acp';
@@ -96,7 +96,7 @@ async function loadConfigProviders(configPath2, vault, opts) {
 }
 async function mutateConfigProviders(configPath2, vault, mutator) {
   let raw;
-  let fileExists = true;
+  let fileExists2 = true;
   try {
     raw = await fsp4.readFile(configPath2, "utf8");
   } catch (err) {
@@ -106,14 +106,14 @@ async function mutateConfigProviders(configPath2, vault, mutator) {
         { cause: err }
       );
     }
-    fileExists = false;
+    fileExists2 = false;
     raw = "{}";
   }
   let parsed;
   try {
     parsed = JSON.parse(raw);
   } catch (err) {
-    if (fileExists) {
+    if (fileExists2) {
       throw new Error(
         `Refusing to overwrite corrupt config at ${configPath2} (${err.message}). Fix or move the file aside before retrying.`,
         { cause: err }
@@ -386,7 +386,7 @@ async function findSpec(store, idOrTitle) {
 async function gatherProjectContext2(projectRoot) {
   const parts = [];
   try {
-    const pkgPath = path9.join(projectRoot, "package.json");
+    const pkgPath = path10.join(projectRoot, "package.json");
     const pkgRaw = await fsp4.readFile(pkgPath, "utf8");
     const pkg = JSON.parse(pkgRaw);
     parts.push(`Project: ${String(pkg.name ?? "unknown")}`);
@@ -402,13 +402,13 @@ async function gatherProjectContext2(projectRoot) {
   } catch {
   }
   try {
-    const tsconfigPath = path9.join(projectRoot, "tsconfig.json");
+    const tsconfigPath = path10.join(projectRoot, "tsconfig.json");
     await fsp4.access(tsconfigPath);
     parts.push("Language: TypeScript");
   } catch {
   }
   try {
-    const srcDir = path9.join(projectRoot, "src");
+    const srcDir = path10.join(projectRoot, "src");
     const entries = await fsp4.readdir(srcDir, { withFileTypes: true });
     const dirs = entries.filter((e) => e.isDirectory()).map((e) => e.name);
     if (dirs.length > 0) parts.push(`Source structure: src/${dirs.join(", src/")}`);
@@ -1602,7 +1602,7 @@ __export(update_check_exports, {
   getUpdateNotification: () => getUpdateNotification
 });
 function cachePath(homeFn = defaultHomeDir2) {
-  return path9.join(homeFn(), ".wrongstack", "update-cache.json");
+  return path10.join(homeFn(), ".wrongstack", "update-cache.json");
 }
 function currentVersion() {
   const req2 = createRequire(import.meta.url);
@@ -1639,7 +1639,7 @@ async function readCache(homeFn = defaultHomeDir2) {
 }
 async function writeCache(entry, homeFn = defaultHomeDir2) {
   try {
-    const dir = path9.dirname(cachePath(homeFn));
+    const dir = path10.dirname(cachePath(homeFn));
     await fsp4.mkdir(dir, { recursive: true });
     await fsp4.writeFile(cachePath(homeFn), JSON.stringify(entry, null, 2), "utf8");
   } catch {
@@ -1746,7 +1746,7 @@ async function runWebUI(opts) {
   try {
     const requireFromHere = createRequire(import.meta.url);
     const serverEntry = requireFromHere.resolve("@wrongstack/webui/server");
-    const distDir = path9.resolve(path9.dirname(serverEntry), "..");
+    const distDir = path10.resolve(path10.dirname(serverEntry), "..");
     httpServer = createHttpServer({ host, distDir, wsPort });
     const openUrl = `http://${host}:${httpPort}`;
     httpServer?.listen(httpPort, host, () => {
@@ -1763,7 +1763,7 @@ async function runWebUI(opts) {
       `[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 ? path9.dirname(opts.globalConfigPath) : void 0;
+  const registryBaseDir = opts.globalConfigPath ? path10.dirname(opts.globalConfigPath) : void 0;
   if (opts.projectRoot) {
     void registerInstance(
       {
@@ -1772,7 +1772,7 @@ async function runWebUI(opts) {
         wsPort,
         host,
         projectRoot: opts.projectRoot,
-        projectName: path9.basename(opts.projectRoot) || opts.projectRoot,
+        projectName: path10.basename(opts.projectRoot) || opts.projectRoot,
         startedAt: (/* @__PURE__ */ new Date()).toISOString(),
         url: `http://${host}:${httpPort}`
       },
@@ -2159,15 +2159,12 @@ async function runWebUI(opts) {
         await handleProviderRemove(ws, m.payload.providerId);
         break;
       }
-      default:
-        send(ws, {
-          type: "error",
-          payload: {
-            phase: "ws.dispatch",
-            message: `Unknown message type: ${String(msg.type)}`
-          }
-        });
+      default: {
+        console.debug(
+          `[WebUI] Unhandled message type: ${String(msg.type)}`
+        );
         break;
+      }
     }
   }
   async function handleUserMessage(ws, _client, content) {
@@ -2408,7 +2405,7 @@ async function runWebUI(opts) {
     }
   }
   function getVault() {
-    const keyFile = path9.join(path9.dirname(opts.globalConfigPath ?? ""), ".key");
+    const keyFile = path10.join(path10.dirname(opts.globalConfigPath ?? ""), ".key");
     return new DefaultSecretVault({ keyFile });
   }
   async function loadSavedProviders() {
@@ -2709,10 +2706,10 @@ async function detectPackageManager(root, declared) {
     const name = declared.split("@")[0];
     if (name) return name;
   }
-  if (await pathExists(path9.join(root, "pnpm-lock.yaml"))) return "pnpm";
-  if (await pathExists(path9.join(root, "bun.lockb"))) return "bun";
-  if (await pathExists(path9.join(root, "bun.lock"))) return "bun";
-  if (await pathExists(path9.join(root, "yarn.lock"))) return "yarn";
+  if (await pathExists(path10.join(root, "pnpm-lock.yaml"))) return "pnpm";
+  if (await pathExists(path10.join(root, "bun.lockb"))) return "bun";
+  if (await pathExists(path10.join(root, "bun.lock"))) return "bun";
+  if (await pathExists(path10.join(root, "yarn.lock"))) return "yarn";
   return "npm";
 }
 function hasUsableScript(scripts, name) {
@@ -2733,7 +2730,7 @@ function parseMakeTargets(makefile) {
 async function detectProjectFacts(root) {
   const facts = { hints: [] };
   try {
-    const pkg = JSON.parse(await fsp4.readFile(path9.join(root, "package.json"), "utf8"));
+    const pkg = JSON.parse(await fsp4.readFile(path10.join(root, "package.json"), "utf8"));
     const scripts = pkg.scripts ?? {};
     const pm = await detectPackageManager(root, pkg.packageManager);
     if (hasUsableScript(scripts, "build")) facts.build = `${pm} run build`;
@@ -2747,14 +2744,14 @@ async function detectProjectFacts(root) {
   } catch {
   }
   try {
-    if (!await pathExists(path9.join(root, "pyproject.toml"))) throw new Error("not python");
+    if (!await pathExists(path10.join(root, "pyproject.toml"))) throw new Error("not python");
     facts.test ??= "pytest";
     facts.lint ??= "ruff check .";
     facts.hints.push("pyproject.toml");
   } catch {
   }
   try {
-    if (!await pathExists(path9.join(root, "go.mod"))) throw new Error("not go");
+    if (!await pathExists(path10.join(root, "go.mod"))) throw new Error("not go");
     facts.build ??= "go build ./...";
     facts.test ??= "go test ./...";
     facts.run ??= "go run .";
@@ -2762,7 +2759,7 @@ async function detectProjectFacts(root) {
   } catch {
   }
   try {
-    if (!await pathExists(path9.join(root, "Cargo.toml"))) throw new Error("not rust");
+    if (!await pathExists(path10.join(root, "Cargo.toml"))) throw new Error("not rust");
     facts.build ??= "cargo build";
     facts.test ??= "cargo test";
     facts.lint ??= "cargo clippy";
@@ -2771,7 +2768,7 @@ async function detectProjectFacts(root) {
   } catch {
   }
   try {
-    const makefile = await fsp4.readFile(path9.join(root, "Makefile"), "utf8");
+    const makefile = await fsp4.readFile(path10.join(root, "Makefile"), "utf8");
     const targets = parseMakeTargets(makefile);
     facts.build ??= targets.has("build") ? "make build" : "make";
     if (targets.has("test")) facts.test ??= "make test";
@@ -3066,7 +3063,7 @@ function formatPhaseList(graph) {
 }
 async function gatherProjectContext(projectRoot) {
   try {
-    const raw = await fsp4.readFile(path9.join(projectRoot, "package.json"), "utf8");
+    const raw = await fsp4.readFile(path10.join(projectRoot, "package.json"), "utf8");
     const pkg = JSON.parse(raw);
     const parts = [
       `Project: ${String(pkg.name ?? "unknown")}`,
@@ -3964,6 +3961,94 @@ function formatLimit(limit) {
 function pct(n) {
   return `${Math.round(n * 100)}%`;
 }
+var DEFAULT_TIMEOUT_MS = 6e4;
+var MAX_OUTPUT_LINES = 500;
+function runCommand(cmd, cwd, timeout) {
+  return new Promise((resolve5) => {
+    exec(
+      cmd,
+      {
+        cwd,
+        timeout,
+        maxBuffer: 2 * 1024 * 1024,
+        // 2 MB
+        windowsHide: true
+      },
+      (error, stdout, stderr) => {
+        resolve5({
+          stdout,
+          stderr,
+          exitCode: error?.code ?? 0,
+          killed: error?.killed ?? false
+        });
+      }
+    );
+  });
+}
+function formatOutput(cmd, result, elapsed) {
+  const lines = [];
+  const exitLabel = result.killed ? color.red("TIMEOUT") : result.exitCode === 0 ? color.green("OK") : color.red(`EXIT ${result.exitCode}`);
+  lines.push(`${color.cyan("$")} ${color.bold(cmd)}  ${exitLabel}  ${color.dim(`${elapsed}ms`)}`);
+  const combined = (result.stdout + result.stderr).trimEnd();
+  if (combined) {
+    const outputLines = combined.split("\n");
+    const truncated = outputLines.length > MAX_OUTPUT_LINES;
+    const shown = truncated ? outputLines.slice(0, MAX_OUTPUT_LINES) : outputLines;
+    lines.push("");
+    lines.push(color.dim("\u2500\u2500"));
+    for (const line of shown) {
+      lines.push(line);
+    }
+    if (truncated) {
+      lines.push(color.dim(`\u2026 (truncated, showing first ${MAX_OUTPUT_LINES} of ${outputLines.length} lines)`));
+    }
+    lines.push(color.dim("\u2500\u2500"));
+  } else {
+    lines.push(color.dim("(no output)"));
+  }
+  return lines.join("\n");
+}
+function buildDevCommand(opts) {
+  return {
+    name: "dev",
+    category: "Run",
+    description: "Run a shell command and see the output (LLM does not see it).",
+    argsHint: "<shell command>",
+    help: [
+      "Usage:",
+      "  /dev <shell command>    Run a command from the chat input.",
+      "",
+      "Examples:",
+      "  /dev pnpm release:check",
+      "  /dev git diff --stat",
+      "  /dev ls -la src/",
+      "",
+      "The command runs in the current working directory. Output is displayed",
+      "in the chat history but is NOT fed to the LLM \u2014 use this for your own",
+      "eyes only. Timeout: 60s. Max output: 500 lines.",
+      "",
+      "This is a convenience shortcut \u2014 equivalent to switching to a terminal",
+      "tab. For commands the LLM should see, use the `exec` tool instead."
+    ].join("\n"),
+    async run(args, _ctx) {
+      const cmd = args.trim();
+      if (!cmd) {
+        return { message: `${color.yellow("Usage:")} /dev <shell command>
+
+Examples:
+  /dev pnpm release:check
+  /dev git diff --stat` };
+      }
+      const cwd = opts.cwd;
+      const startedAt = Date.now();
+      opts.renderer.write(color.dim(`$ ${cmd}`));
+      const result = await runCommand(cmd, cwd, DEFAULT_TIMEOUT_MS);
+      const elapsed = Date.now() - startedAt;
+      const display = formatOutput(cmd, result, elapsed);
+      return { message: display };
+    }
+  };
+}
 
 // src/slash-commands/diag-stats.ts
 function buildDiagCommand(opts) {
@@ -3997,7 +4082,7 @@ function resolvePersistPath(deps) {
   return deps.globalConfigPath;
 }
 async function ensureProjectDir(filePath) {
-  const dir = path9.dirname(filePath);
+  const dir = path10.dirname(filePath);
   try {
     await fsp4.mkdir(dir, { recursive: true });
   } catch {
@@ -4036,21 +4121,21 @@ async function persistAutonomySetting(deps, mutator) {
   const targetPath = resolvePersistPath(deps);
   await ensureProjectDir(targetPath);
   let raw;
-  let fileExists = true;
+  let fileExists2 = true;
   try {
     raw = await fsp4.readFile(targetPath, "utf8");
   } catch (err) {
     if (err.code !== "ENOENT") {
       throw new Error(`Could not read ${targetPath}: ${err.message}`);
     }
-    fileExists = false;
+    fileExists2 = false;
     raw = "{}";
   }
   let parsed;
   try {
     parsed = JSON.parse(raw);
   } catch (err) {
-    if (fileExists) {
+    if (fileExists2) {
       throw new Error(`Config at ${targetPath} is not valid JSON: ${err.message}`);
     }
     parsed = {};
@@ -4073,21 +4158,21 @@ async function persistConfigSetting(deps, mutator) {
   const targetPath = resolvePersistPath(deps);
   await ensureProjectDir(targetPath);
   let raw;
-  let fileExists = true;
+  let fileExists2 = true;
   try {
     raw = await fsp4.readFile(targetPath, "utf8");
   } catch (err) {
     if (err.code !== "ENOENT") {
       throw new Error(`Could not read ${targetPath}: ${err.message}`);
     }
-    fileExists = false;
+    fileExists2 = false;
     raw = "{}";
   }
   let parsed;
   try {
     parsed = JSON.parse(raw);
   } catch (err) {
-    if (fileExists) {
+    if (fileExists2) {
       throw new Error(`Config at ${targetPath} is not valid JSON: ${err.message}`);
     }
     parsed = {};
@@ -4106,21 +4191,21 @@ async function persistConfigSetting(deps, mutator) {
 }
 async function persistTelegramConfig(deps, mutator) {
   let raw;
-  let fileExists = true;
+  let fileExists2 = true;
   try {
     raw = await fsp4.readFile(deps.globalConfigPath, "utf8");
   } catch (err) {
     if (err.code !== "ENOENT") {
       throw new Error(`Could not read ${deps.globalConfigPath}: ${err.message}`);
     }
-    fileExists = false;
+    fileExists2 = false;
     raw = "{}";
   }
   let parsed;
   try {
     parsed = JSON.parse(raw);
   } catch (err) {
-    if (fileExists) {
+    if (fileExists2) {
       throw new Error(`Config at ${deps.globalConfigPath} is not valid JSON: ${err.message}`);
     }
     parsed = {};
@@ -4214,6 +4299,7 @@ function buildEnhanceCommand(opts) {
 
 // src/slash-commands/fix-classifier.ts
 var TS = ["typescript-strict"];
+var TC = ["tech-stack"];
 var BH = ["bug-hunter"];
 var SS = ["security-scanner"];
 var NM = ["node-modern"];
@@ -4588,6 +4674,90 @@ var P = [
     detail: "JavaScript runtime error",
     conf: 0.95
   },
+  // ── Tech stack validation — BEFORE generic dep patterns ─────────────
+  // Technology choice questions: "should I use X?", "is Y deprecated?", etc.
+  {
+    pat: /\b(should I (use|install|add|pick|choose)|is .+ (still (good|maintained|supported|relevant)|deprecated|dead|obsolete|outdated)|what replaces|alternative to|instead of)\b/i,
+    cat: "tech",
+    sub: "tech-choice",
+    lang: void 0,
+    hints: TC,
+    detail: "Technology choice validation",
+    conf: 0.85
+  },
+  {
+    pat: /\bwhat (is the latest|are the latest|version of|versions of)|what version|upgrade to latest|downgrade to|which version of\b/i,
+    cat: "tech",
+    sub: "version-check",
+    lang: void 0,
+    hints: TC,
+    detail: "Version verification needed",
+    conf: 0.9
+  },
+  {
+    pat: /\b(adding|installing|using|switching to|migrating to) (a |an |the )?(package|dependency|library|module|framework|gem|crate)\b/i,
+    cat: "tech",
+    sub: "tech-choice",
+    lang: void 0,
+    hints: TC,
+    detail: "Technology choice validation",
+    conf: 0.8
+  },
+  // Commands that imply tech choices: "pip install X", "cargo add X", etc.
+  {
+    pat: /\b(pip install|pip3 install|pipenv install|poetry add|uv add)\s+[a-zA-Z0-9_-]+/i,
+    cat: "tech",
+    sub: "python-pkg",
+    lang: "python",
+    hints: TC,
+    detail: "Python package choice \u2014 validate before installing",
+    conf: 0.85
+  },
+  {
+    pat: /\b(cargo add|cargo install)\s+[a-zA-Z0-9_-]+/i,
+    cat: "tech",
+    sub: "rust-crate",
+    lang: "rust",
+    hints: TC,
+    detail: "Rust crate choice \u2014 validate before installing",
+    conf: 0.85
+  },
+  {
+    pat: /\b(go get|go install)\s+[a-zA-Z0-9_./-]+/i,
+    cat: "tech",
+    sub: "go-module",
+    lang: "go",
+    hints: TC,
+    detail: "Go module choice \u2014 validate before installing",
+    conf: 0.85
+  },
+  {
+    pat: /\b(gem install|bundle add)\s+[a-zA-Z0-9_-]+/i,
+    cat: "tech",
+    sub: "ruby-gem",
+    lang: "ruby",
+    hints: TC,
+    detail: "Ruby gem choice \u2014 validate before installing",
+    conf: 0.85
+  },
+  {
+    pat: /\b(npm install|pnpm add|yarn add)\s+[a-zA-Z0-9@/_-]+/i,
+    cat: "tech",
+    sub: "js-pkg",
+    lang: "javascript",
+    hints: TC,
+    detail: "JS package choice \u2014 validate before installing",
+    conf: 0.85
+  },
+  {
+    pat: /\b(composer require|nuget install|dotnet add package)\s+[a-zA-Z0-9./_-]+/i,
+    cat: "tech",
+    sub: "pkg-choice",
+    lang: void 0,
+    hints: TC,
+    detail: "Package choice \u2014 validate before installing",
+    conf: 0.85
+  },
   // ── Dependency / Import ───────────────────────────────────────────────
   {
     pat: /\bcannot find module|modulenotfounderror|no such module|missing module/i,
@@ -4724,7 +4894,7 @@ function needsSubagent(c) {
   return c.confidence < 0.85;
 }
 function isSimpleFix(c) {
-  return c.category === "ts" && c.confidence >= 0.9 || c.category === "runtime" && c.subcategory === "null-undefined-access" && c.confidence >= 0.85;
+  return c.category === "ts" && c.confidence >= 0.9 || c.category === "runtime" && c.subcategory === "null-undefined-access" && c.confidence >= 0.85 || c.category === "tech" && c.confidence >= 0.85;
 }
 
 // src/slash-commands/fix.ts
@@ -4820,6 +4990,22 @@ function buildDirective(cli, errorText) {
         "3. Fix the config",
         "4. Verify"
       ].join("\n");
+    case "tech":
+      return [
+        `## Tech Stack Validation${lang}`,
+        "",
+        "```",
+        `${errorText}`,
+        "```",
+        "",
+        "Your task:",
+        "1. Detect the ecosystem from project files or context",
+        "2. Verify the package/version against the correct registry",
+        "3. Check if the package is dead, deprecated, or superseded (prehistoric)",
+        "4. Check if the language standard library already covers this need",
+        "5. Report APPROVED (with install command) or REJECTED (with replacement + migration)",
+        `6. Use "This isn't code, this is X-year-old technology" when rejecting on age grounds`
+      ].join("\n");
     case "perf":
       return [
         `## Fix: Performance / Memory Issue${lang}`,
@@ -4859,6 +5045,8 @@ function delegateRoleFor(cli) {
       return "security-scanner";
     case "perf":
       return "refactor-planner";
+    case "tech":
+      return "tech-stack";
     default:
       return "bug-hunter";
   }
@@ -4905,7 +5093,8 @@ Docker, Git, CI/CD, and more.
 | Security / secrets  | Any                      | \`security-scanner\`     |
 | Compiler error      | Rust, Go, C/C++, Python  | \`bug-hunter\`           |
 | Dependency / import | Any                      | \`bug-hunter\`           |
-| Performance / leak | Any                      | \`bug-hunter\` + \`refactor-planner\` |
+| Tech choice / pkg   | Any                      | \`tech-stack\`           |
+| Performance / leak  | Any                      | \`bug-hunter\` + \`refactor-planner\` |
 | Infrastructure      | Config, Docker, Git, CI  | \`bug-hunter\`           |
 | React / Next.js     | JavaScript               | \`react-modern\`         |
 | Node.js             | JavaScript               | \`node-modern\`           |
@@ -4927,6 +5116,10 @@ When the error confidence is low (< 0.85) or the problem spans multiple files,
 /fix react-dom.development.js:172 Error: Invalid hook call
 /fix Security: hardcoded API key in config.ts
 /fix ERRO1014: SQL injection vulnerability in query builder
+/fix Should I use axios for API calls?
+/fix is moment.js still maintained?
+/fix pip install urllib2
+/fix what replaces lodash?
 \`\`\`
 `,
     async run(args, _ctx) {
@@ -4948,6 +5141,7 @@ When the error confidence is low (< 0.85) or the problem spans multiple files,
             `  /fix ${color.dim("AttributeError: 'NoneType' object has no attribute 'encode'")}`,
             `  /fix ${color.dim("react-dom.development.js:172 Error: Invalid hook call")}`,
             `  /fix ${color.dim("Security: hardcoded API key in config.ts")}`,
+            `  /fix ${color.dim("Should I use axios for API calls?")}`,
             "",
             "Run `/help fix` for full documentation."
           ].join("\n")
@@ -5746,28 +5940,52 @@ function buildInitCommand(opts) {
     category: "Config",
     description: "Create or update .wrongstack/AGENTS.md project context for the system prompt.",
     async run(_args, ctx) {
-      const dir = path9.join(ctx.projectRoot, ".wrongstack");
-      const file = path9.join(dir, "AGENTS.md");
+      const dir = path10.join(ctx.projectRoot, ".wrongstack");
+      const file = path10.join(dir, "AGENTS.md");
+      const isFirstInit = !await fileExists(file);
       const detected = await detectProjectFacts(ctx.projectRoot);
       const body = renderAgentsTemplate(detected);
       await fsp4.mkdir(dir, { recursive: true });
       await fsp4.writeFile(file, body, "utf8");
+      let nodePkg = false;
+      try {
+        await fsp4.access(path10.join(ctx.projectRoot, "package.json"));
+        nodePkg = true;
+      } catch {
+      }
+      const lines = [];
+      lines.push(`Wrote ${file}`);
       if (detected.hints.length > 0) {
-        const msg2 = `Wrote ${file}
-Pre-filled: ${detected.hints.join(", ")}. Edit the file with project context and instructions the system prompt should carry.`;
         opts.renderer.writeInfo(`Wrote ${file}`);
-        opts.renderer.writeInfo(
-          `Pre-filled: ${detected.hints.join(", ")}. Edit the file with project context and instructions the system prompt should carry.`
-        );
-        return { message: msg2 };
+        const hintLine = `Pre-filled: ${detected.hints.join(", ")}. Edit the file with project context and instructions the system prompt should carry.`;
+        opts.renderer.writeInfo(hintLine);
+        lines.push(hintLine);
+      } else {
+        opts.renderer.writeInfo(`Wrote ${file}`);
+        lines.push("No project type auto-detected. Edit the file with project context and instructions the system prompt should carry.");
       }
-      const msg = `Wrote ${file}
-No project type auto-detected. Edit the file with project context and instructions the system prompt should carry.`;
-      opts.renderer.writeInfo(`Wrote ${file}`);
-      return { message: msg };
+      if (nodePkg && isFirstInit) {
+        const techHint = [
+          "",
+          `${color.cyan("\u{1F4A1}")} ${color.bold("Tech Stack Audit")} \u2014 This is a Node.js project with a fresh init.`,
+          color.dim("  The LLM may have suggested stale version numbers. Run"),
+          `  ${color.cyan("/techstack --init")}  to scan dependencies and verify versions.`
+        ].join("\n");
+        opts.renderer.write(techHint);
+        lines.push(techHint);
+      }
+      return { message: lines.join("\n") };
     }
   };
 }
+async function fileExists(filePath) {
+  try {
+    await fsp4.access(filePath);
+    return true;
+  } catch {
+    return false;
+  }
+}
 function parseMcpArgs(args) {
   const trimmed = args.trim();
   if (!trimmed || trimmed === "list") return { action: "list", name: "" };
@@ -5962,9 +6180,9 @@ function stateBadge(state) {
       return color.dim(state);
   }
 }
-async function readConfig(path27) {
+async function readConfig(path28) {
   try {
-    return JSON.parse(await fsp4.readFile(path27, "utf8"));
+    return JSON.parse(await fsp4.readFile(path28, "utf8"));
   } catch {
     return {};
   }
@@ -5972,11 +6190,11 @@ async function readConfig(path27) {
 function isMcpServerRecord(value) {
   return !!value && typeof value === "object" && !Array.isArray(value);
 }
-async function writeConfig(path27, cfg) {
+async function writeConfig(path28, cfg) {
   const raw = JSON.stringify(cfg, null, 2);
-  const tmp = path27 + ".tmp";
+  const tmp = path28 + ".tmp";
   await fsp4.writeFile(tmp, raw, "utf8");
-  await fsp4.rename(tmp, path27);
+  await fsp4.rename(tmp, path28);
 }
 
 // src/slash-commands/mcp.ts
@@ -6506,18 +6724,18 @@ var noOpVault2 = {
 };
 async function patchGlobalConfig(globalConfigPath, mutate) {
   let raw = "{}";
-  let fileExists = true;
+  let fileExists2 = true;
   try {
     raw = await fsp4.readFile(globalConfigPath, "utf8");
   } catch (err) {
     if (err.code !== "ENOENT") throw err;
-    fileExists = false;
+    fileExists2 = false;
   }
   let parsed;
   try {
     parsed = JSON.parse(raw);
   } catch (err) {
-    if (fileExists) {
+    if (fileExists2) {
       throw new Error(`Config at ${globalConfigPath} is not valid JSON: ${err.message}`);
     }
     parsed = {};
@@ -6724,31 +6942,51 @@ function buildModelsCommand(opts) {
 function buildNextCommand(opts) {
   return {
     name: "next",
-    category: "Config",
-    description: "Toggle next-task prediction \u2014 show likely next steps after each turn.",
-    argsHint: "[on|off|toggle]",
+    category: "Agent",
+    description: "Show or select next-step suggestions. /next 1 to execute, /next list to view.",
+    argsHint: "[on|off|toggle|list|clear|1 2 3...]",
     help: [
       "Usage:",
-      "  /next            Show whether next-task prediction is on or off",
-      "  /next on         Enable \u2014 after each turn, show 1-3 predicted next steps",
-      "  /next off        Disable (default)",
-      "  /next toggle     Flip the current state",
+      "  /next                 Show whether next-task prediction is on or off",
+      "  /next on              Enable \u2014 after each turn, show 1-3 predicted next steps",
+      "  /next off             Disable (default)",
+      "  /next toggle          Flip the current state",
+      "  /next list            Show the current suggestion list",
+      "  /next clear           Clear the suggestion list",
+      "  /next 1               Execute suggestion #1 as the next agent turn",
+      "  /next 1 2 3           Execute suggestions 1, 2, and 3 in sequence",
+      "  /next 1,2,3           Same \u2014 comma separators work too",
       "",
-      "Predictions are informational only. They come from a cheap single-shot",
-      "model call (no tools, no context replay) and are never run automatically \u2014",
-      "copy or retype one to act on it. The setting persists across sessions."
+      "Suggestions are generated automatically after each turn (when prediction is",
+      `on) or manually via ${color.cyan("/suggest")}. Selected suggestions execute`,
+      "immediately \u2014 no refinement or classification step."
     ].join("\n"),
     async run(args) {
+      const trimmed = args.trim();
+      if (/^\d[\d,\s]*$/.test(trimmed) && /\d/.test(trimmed)) {
+        return handleSelection(trimmed, opts);
+      }
+      const arg = trimmed.toLowerCase();
+      if (arg === "list" || arg === "ls" || arg === "show") {
+        return handleList(opts);
+      }
+      if (arg === "clear" || arg === "reset") {
+        opts.onSuggestions?.([]);
+        return { message: color.dim("Suggestion list cleared.") };
+      }
       if (!opts.onNextPredict) {
         const msg2 = "Next-task prediction is not available in this session.";
         opts.renderer.writeWarning(msg2);
         return { message: msg2 };
       }
-      const arg = args.trim().toLowerCase();
       const current = opts.onNextPredict();
       const label = (on) => on ? `${color.cyan("ON")} ${color.dim("(predicted next steps shown after each turn)")}` : `${color.green("OFF")} ${color.dim("(no predictions)")}`;
       if (!arg || arg === "status") {
-        const msg2 = `Next-task prediction: ${label(current)}`;
+        const suggestions = opts.onSuggestions?.() ?? [];
+        const msg2 = [
+          `Next-task prediction: ${label(current)}`,
+          suggestions.length > 0 ? color.dim(`  ${suggestions.length} suggestion(s) available \u2014 use /next list to view, /next 1 to execute`) : color.dim("  No suggestions stored \u2014 use /suggest to generate")
+        ].join("\n");
         opts.renderer.write(msg2);
         return { message: msg2 };
       }
@@ -6760,7 +6998,7 @@ function buildNextCommand(opts) {
       } else if (arg === "toggle" || arg === "cycle") {
         target = !current;
       } else {
-        const msg2 = `Unknown argument: ${arg}. Use /next on, off, or toggle.`;
+        const msg2 = `Unknown argument: ${arg}. Use /next on, off, toggle, list, clear, or a number (e.g. /next 1).`;
         opts.renderer.writeWarning(msg2);
         return { message: msg2 };
       }
@@ -6771,6 +7009,67 @@ function buildNextCommand(opts) {
     }
   };
 }
+function handleSelection(input, opts) {
+  const parts = input.split(/[\s,]+/).filter(Boolean);
+  const indices = parts.map((p) => Number.parseInt(p, 10)).filter((n) => !Number.isNaN(n) && n > 0);
+  if (indices.length === 0) {
+    return { message: color.amber("No valid suggestion numbers found. Use /next 1, /next 1 2 3, etc.") };
+  }
+  const suggestions = opts.onSuggestions?.() ?? [];
+  if (suggestions.length === 0) {
+    return {
+      message: color.amber("No suggestions available. Run /suggest first, or enable prediction with /next on.")
+    };
+  }
+  const invalid = indices.filter((i) => i > suggestions.length);
+  if (invalid.length > 0) {
+    const max = suggestions.length;
+    return {
+      message: color.amber(`Invalid suggestion number(s): ${invalid.join(", ")}. Valid range: 1\u2013${max}.`)
+    };
+  }
+  const selected = indices.map((i) => suggestions[i - 1]).filter((s) => s !== void 0);
+  if (selected.length === 1) {
+    const text = selected[0] ?? "";
+    return {
+      message: `${color.green("\u25B6")} Executing suggestion #${indices[0]}: ${color.dim(text)}`,
+      runText: text
+    };
+  }
+  const tasks = selected.map((s, i) => `${i + 1}. ${s}`).join("\n");
+  const runText = [
+    `## Execute the following tasks in order`,
+    "",
+    tasks,
+    "",
+    "Complete each task before moving to the next. Report results as you go."
+  ].join("\n");
+  return {
+    message: `${color.green("\u25B6")} Executing ${selected.length} tasks: ${indices.join(", ")}`,
+    runText
+  };
+}
+function handleList(opts) {
+  const suggestions = opts.onSuggestions?.() ?? [];
+  if (suggestions.length === 0) {
+    return {
+      message: [
+        color.dim("No suggestions available."),
+        "",
+        `Generate suggestions with ${color.cyan("/suggest")} or enable`,
+        `prediction with ${color.cyan("/next on")}.`
+      ].join("\n")
+    };
+  }
+  const lines = [
+    `  ${color.cyan("\u{1F4A1} Suggestions")}  ${color.dim(`(use /next 1, /next 1 2 3 to execute)`)}`,
+    ""
+  ];
+  for (let i = 0; i < suggestions.length; i++) {
+    lines.push(`  ${color.bold(`${i + 1}.`)} ${suggestions[i]}`);
+  }
+  return { message: lines.join("\n") };
+}
 
 // src/slash-commands/plugin.ts
 function buildPluginCommand(opts) {
@@ -7108,18 +7407,18 @@ function fmtEntry(e) {
 }
 async function patchGlobalConfig2(globalConfigPath, mutate) {
   let raw = "{}";
-  let fileExists = true;
+  let fileExists2 = true;
   try {
     raw = await fsp4.readFile(globalConfigPath, "utf8");
   } catch (err) {
     if (err.code !== "ENOENT") throw err;
-    fileExists = false;
+    fileExists2 = false;
   }
   let parsed;
   try {
     parsed = JSON.parse(raw);
   } catch (err) {
-    if (fileExists)
+    if (fileExists2)
       throw new Error(`Config at ${globalConfigPath} is not valid JSON: ${err.message}`);
     parsed = {};
   }
@@ -7559,6 +7858,161 @@ function buildModelCapsCommand(opts) {
     }
   };
 }
+function collectContext(opts) {
+  const parts = [];
+  try {
+    const gitStatus = execFileSync("git", ["status", "--short", "--branch"], {
+      cwd: opts.projectRoot,
+      encoding: "utf8",
+      timeout: 5e3,
+      windowsHide: true
+    }).trim();
+    if (gitStatus) {
+      parts.push("### Git Status", "```", gitStatus, "```");
+    }
+  } catch {
+  }
+  parts.push(`Working directory: ${opts.cwd}`);
+  parts.push(`Project root: ${opts.projectRoot}`);
+  return parts.join("\n");
+}
+function buildSuggestPrompt(contextText) {
+  return [
+    "## Suggest Next Steps",
+    "",
+    "Based on the current project state below, generate 3-5 actionable next-step",
+    "suggestions. Each suggestion must be a single imperative sentence that can be",
+    "executed immediately. Be specific \u2014 mention file names, tool names, or commands",
+    "when relevant. Do NOT include preamble, explanation, or wrap in code blocks.",
+    "",
+    "Rules:",
+    '- One suggestion per line, prefixed with the number (e.g. "1. Run tests...")',
+    "- Order by priority: most impactful first",
+    "- Suggestions should be independent \u2014 user can pick any subset",
+    '- If nothing is needed, say "No pending actions \u2014 everything is up to date."',
+    "",
+    contextText || "(No project context available \u2014 suggest generic next steps.)",
+    "",
+    "Output format (strict \u2014 no other text):",
+    "1. First suggestion here",
+    "2. Second suggestion here",
+    "3. Third suggestion here"
+  ].join("\n");
+}
+function buildSuggestCommand(opts) {
+  return {
+    name: "suggest",
+    aliases: ["next-steps", "what-next"],
+    category: "Agent",
+    description: "Generate context-aware next-step suggestions for the current session.",
+    argsHint: "[--fast]",
+    help: [
+      "Usage:",
+      "  /suggest           Generate suggestions using a lightweight subagent",
+      "  /suggest --fast    Heuristic-only suggestions (no subagent, instant)",
+      "",
+      "Analyzes the current session state (git status, working directory, recent",
+      "activity) and generates 3-5 actionable next-step suggestions. Suggestions",
+      "are stored and can be selected with `/next 1`, `/next 1 2 3`, etc.",
+      "",
+      "Use `/next list` to see the current suggestions at any time."
+    ].join("\n"),
+    async run(args, _ctx) {
+      const trimmed = args.trim().toLowerCase();
+      const fast = /\b(--fast|-f)\b/.test(trimmed);
+      if (fast) {
+        const suggestions = generateHeuristicSuggestions(opts);
+        opts.onSuggestions?.(suggestions);
+        const display = formatSuggestions(suggestions);
+        return { message: display };
+      }
+      if (!opts.onSpawnAndWait) {
+        const suggestions = generateHeuristicSuggestions(opts);
+        opts.onSuggestions?.(suggestions);
+        const display = formatSuggestions(suggestions) + "\n" + color.dim("(Heuristic fallback \u2014 multi-agent not enabled)");
+        return { message: display };
+      }
+      const contextText = collectContext({
+        cwd: opts.cwd,
+        projectRoot: opts.projectRoot
+      });
+      const task = buildSuggestPrompt(contextText);
+      opts.renderer.write(color.dim("Generating suggestions..."));
+      try {
+        const raw = await opts.onSpawnAndWait(task, {
+          name: "suggest"
+        });
+        const suggestions = parseSuggestions(raw);
+        if (suggestions.length === 0) {
+          const fallback = ["No pending actions \u2014 everything is up to date."];
+          opts.onSuggestions?.(fallback);
+          return { message: formatSuggestions(fallback) };
+        }
+        opts.onSuggestions?.(suggestions);
+        return { message: formatSuggestions(suggestions) };
+      } catch (err) {
+        const msg = `Suggestion generation failed: ${err instanceof Error ? err.message : String(err)}`;
+        opts.renderer.writeWarning(msg);
+        return { message: msg };
+      }
+    }
+  };
+}
+function parseSuggestions(raw) {
+  const lines = raw.split("\n").map((l) => l.trim()).filter(Boolean);
+  const numbered = lines.filter((l) => /^\d+[.)]\s/.test(l)).map((l) => l.replace(/^\d+[.)]\s*/, "").trim());
+  if (numbered.length > 0) return numbered.slice(0, 5);
+  const bullets = lines.filter((l) => /^[-*•]\s/.test(l)).map((l) => l.replace(/^[-*•]\s*/, "").trim());
+  if (bullets.length > 0) return bullets.slice(0, 5);
+  return lines.filter((l) => l.length > 10 && !l.startsWith("#") && !l.startsWith("```")).slice(0, 5);
+}
+function generateHeuristicSuggestions(opts) {
+  const suggestions = [];
+  try {
+    const gitStatus = execFileSync("git", ["status", "--short"], {
+      cwd: opts.projectRoot,
+      encoding: "utf8",
+      timeout: 5e3,
+      windowsHide: true
+    }).trim();
+    if (gitStatus) {
+      const staged = gitStatus.split("\n").filter((l) => /^[MADRC]/.test(l)).length;
+      const unstaged = gitStatus.split("\n").filter((l) => /^.[MADRC]/.test(l)).length;
+      const untracked = gitStatus.split("\n").filter((l) => l.startsWith("??")).length;
+      if (staged > 0) {
+        suggestions.push(`Commit ${staged} staged file(s) with a descriptive message`);
+      }
+      if (unstaged > 0) {
+        suggestions.push(`Stage and review ${unstaged} modified file(s)`);
+      }
+      if (untracked > 0) {
+        suggestions.push(`Review ${untracked} untracked file(s) \u2014 add to git or .gitignore`);
+      }
+    }
+  } catch {
+  }
+  if (suggestions.length === 0) {
+    suggestions.push("Review recent changes with a diff");
+    suggestions.push("Run the test suite to verify everything passes");
+    suggestions.push("Check for lint or type errors");
+  }
+  return suggestions.slice(0, 5);
+}
+function formatSuggestions(suggestions) {
+  if (suggestions.length === 0) {
+    return color.dim("No suggestions available.");
+  }
+  const lines = [
+    `  ${color.cyan("\u{1F4A1} Next steps")}  ${color.dim("(use /next 1, /next 2, or /next 1 2 3)")}`,
+    ""
+  ];
+  for (let i = 0; i < suggestions.length; i++) {
+    const num = color.bold(`${i + 1}.`);
+    const text = suggestions[i] ?? "";
+    lines.push(`  ${num} ${text}`);
+  }
+  return lines.join("\n");
+}
 var noOpVault4 = {
   encrypt: (v) => v,
   decrypt: (v) => v,
@@ -7956,7 +8410,7 @@ var DEFAULTS = {
   cost: true
 };
 function resolveConfigPath() {
-  return process.env[CONFIG_ENV] ?? path9.join(process.env.HOME ?? "", ".wrongstack", "statusline.json");
+  return process.env[CONFIG_ENV] ?? path10.join(process.env.HOME ?? "", ".wrongstack", "statusline.json");
 }
 async function loadStatuslineConfig() {
   const p = resolveConfigPath();
@@ -7970,7 +8424,7 @@ async function loadStatuslineConfig() {
 async function saveStatuslineConfig(cfg) {
   const p = resolveConfigPath();
   try {
-    await fsp4.mkdir(path9.dirname(p), { recursive: true });
+    await fsp4.mkdir(path10.dirname(p), { recursive: true });
     await atomicWrite(p, JSON.stringify(cfg, null, 2));
   } catch (err) {
     throw new FsError({
@@ -8397,6 +8851,199 @@ function buildWorktreeCommand(opts) {
     }
   };
 }
+async function discoverPackageFiles(projectRoot) {
+  const files = [];
+  const rootPkg = path10.join(projectRoot, "package.json");
+  try {
+    await fsp4.access(rootPkg);
+    files.push(rootPkg);
+  } catch {
+  }
+  const workspaceFile = path10.join(projectRoot, "pnpm-workspace.yaml");
+  try {
+    await fsp4.access(workspaceFile);
+    const content = await fsp4.readFile(workspaceFile, "utf8");
+    const globMatch = /packages?:\s*\[([^\]]+)\]/s.exec(content);
+    const rawGlobs = globMatch?.[1];
+    if (!rawGlobs) return files;
+    const globs = rawGlobs.split(/[\s,]+/).filter(Boolean).map((g) => g.replace(/['"]/g, ""));
+    for (const g of globs) {
+      const dirPrefix = g.replace(/\/?\*$/, "").replace(/\/\*$/, "");
+      const dir = path10.join(projectRoot, dirPrefix);
+      try {
+        const entries = await fsp4.readdir(dir, { withFileTypes: true });
+        for (const e of entries) {
+          if (!e.isDirectory()) continue;
+          const subPkg = path10.join(dir, e.name, "package.json");
+          try {
+            await fsp4.access(subPkg);
+            files.push(subPkg);
+          } catch {
+          }
+        }
+      } catch {
+      }
+    }
+  } catch {
+  }
+  return files;
+}
+function buildTechStackTask(opts) {
+  const pkgList = opts.packageFiles.map((f) => `  - ${path10.relative(opts.projectRoot, f)}`).join("\n");
+  const header = opts.isInit ? [
+    "## Tech Stack Audit \u2014 First-Time Project Init",
+    "",
+    "This project is being initialized for the first time. Scan its dependencies,",
+    "check every package and framework version against the npm registry, and produce",
+    "a report that warns about outdated choices. The LLM that scaffolded this project",
+    "may have suggested stale version numbers \u2014 verify every single one.",
+    ""
+  ].join("\n") : [
+    "## Tech Stack Audit \u2014 Full Project Scan",
+    "",
+    "Scan all project dependencies, verify every package version against the npm",
+    "registry, and produce a report that flags outdated, dead, or obsolete packages.",
+    ""
+  ].join("\n");
+  const outputPath = opts.outputFormat === "json" ? "techstack.json" : "techstack.md";
+  return [
+    header,
+    "",
+    "### Project package files to scan",
+    `${pkgList || "  - package.json (root only)"}`,
+    "",
+    "### Instructions",
+    "",
+    "1. **Read** each package.json and extract ALL dependencies (dependencies +",
+    "   devDependencies + peerDependencies). Include the workspace root.",
+    "",
+    "2. **For every dependency**, look up its latest version from the npm registry:",
+    '   - `fetch("https://registry.npmjs.org/<package>/latest")`',
+    "   - Extract the `version` field from the JSON response",
+    "   - Also check `description`, `license`, and `time` fields for age/dead checks",
+    "",
+    "3. **For each package, determine status:**",
+    "   - \u{1F7E2} CURRENT: installed version is within 1 minor of latest",
+    "   - \u{1F7E1} OUTDATED: installed version is behind latest (major or >1 minor gap)",
+    "   - \u{1F534} CRITICAL: package has known CVEs, is deprecated, or >2 years without release",
+    "   - \u2620\uFE0F DEAD: package is deprecated, archived, or superseded \u22655 years ago",
+    "",
+    "4. **Apply the tech-stack skill rules:**",
+    '   - Reject packages that are "prehistoric" (superseded \u22655 years ago)',
+    "   - Flag dead packages (no release >2 years + critical issues)",
+    "   - Prefer Node.js built-ins over third-party packages",
+    "",
+    `5. **Write the report** to \`${outputPath}\` in the project root:`,
+    "   - Markdown format: grouped by category, with version tables and warnings",
+    "   - JSON format: structured array with name, current, latest, status, notes",
+    "",
+    "6. **Report a summary to chat**: total packages scanned, counts per status,",
+    "   top 5 most urgent issues, and total cost estimate (optional).",
+    "",
+    "### Output format (markdown)",
+    "",
+    "```markdown",
+    "# Tech Stack Report",
+    "",
+    "Generated: <date>  \xB7  Scanned: <total> packages across <N> files",
+    "",
+    "## \u{1F7E2} Up to Date (<count>)",
+    "| Package | Current | Latest | Age | Notes |",
+    "|---------|---------|--------|-----|-------|",
+    "",
+    "## \u{1F7E1} Outdated (<count>)",
+    "...",
+    "",
+    "## \u{1F534} Critical Issues (<count>)",
+    "...",
+    "",
+    "## \u2620\uFE0F Dead / Obsolete (<count>)",
+    "...",
+    "",
+    "## Recommendations",
+    "- Top 3-5 actionable fixes",
+    "```",
+    "",
+    "### Guardrails",
+    "",
+    "- Use `fetch()` with `AbortSignal.timeout(10000)` on every npm registry call.",
+    "- Skip packages that return 404 (private/internal packages).",
+    "- Deduplicate: same package in multiple package.json files = one row.",
+    "- Do NOT modify any files except writing the report.",
+    "- Run in 2-3 iterations max. Parallel fetch where possible.",
+    "- **IMPORTANT**: Output the chat summary FIRST, then write the file. I need to see results."
+  ].join("\n");
+}
+function buildTechStackCommand(opts) {
+  return {
+    name: "techstack",
+    category: "Inspect",
+    aliases: ["tech", "deps"],
+    description: "Scan all project dependencies, verify versions against npm, and produce a techstack report.",
+    argsHint: "[--json] [--init]",
+    help: [
+      "Usage:",
+      "  /techstack              Scan dependencies + write techstack.md report",
+      "  /techstack --json       Write techstack.json instead of markdown",
+      "  /techstack --init       Init-mode scan (compares scaffolded vs latest)",
+      "",
+      "Spawns a subagent that:",
+      "  1. Reads every package.json in the project",
+      "  2. Looks up latest versions on the npm registry",
+      "  3. Flags outdated, dead, or obsolete packages",
+      `  4. Writes a ${color.cyan("techstack.md")} (or .json) report to the project root`,
+      "",
+      "Uses the `tech-stack` skill for version verification rules.",
+      `Hooked into ${color.cyan("/init")} \u2014 runs automatically on first project setup.`
+    ].join("\n"),
+    async run(args, _ctx) {
+      const trimmed = args.trim().toLowerCase();
+      const outputFormat = /\b(--json|-j)\b/.test(trimmed) ? "json" : "md";
+      const isInit = /\b(--init|-i)\b/.test(trimmed);
+      let packageFiles = [];
+      let discoveryNote = "";
+      try {
+        packageFiles = await discoverPackageFiles(opts.projectRoot);
+        if (packageFiles.length === 0) {
+          discoveryNote = color.amber(
+            "\u26A0 No package.json files found. This does not look like a Node.js project."
+          );
+        }
+      } catch (err) {
+        discoveryNote = color.red(
+          `Could not scan for package files: ${err instanceof Error ? err.message : String(err)}`
+        );
+      }
+      const task = buildTechStackTask({
+        projectRoot: opts.projectRoot,
+        packageFiles,
+        outputFormat,
+        isInit
+      });
+      if (!opts.onSpawnAndWait) {
+        const msg = "Multi-agent is not enabled in this session. Cannot spawn techstack subagent.";
+        opts.renderer.writeWarning(msg);
+        return { message: msg };
+      }
+      const header = isInit ? "Tech Stack Init Audit" : "Tech Stack Audit";
+      const label = `${color.cyan("\u{1F50D}")} ${color.bold(header)} ${color.dim(`(${packageFiles.length} package files)`)}`;
+      opts.renderer.write(label);
+      if (discoveryNote) opts.renderer.write(discoveryNote);
+      opts.renderer.write(
+        color.dim(`Spawning tech-stack subagent \u2192 writes ${outputFormat === "json" ? "techstack.json" : "techstack.md"} when done.`)
+      );
+      try {
+        const name = isInit ? "techstack-init" : "techstack-audit";
+        const summary = await opts.onSpawnAndWait(task, { name });
+        return { message: summary };
+      } catch (err) {
+        const msg = `Tech stack scan failed: ${err instanceof Error ? err.message : String(err)}`;
+        opts.renderer.writeWarning(msg);
+        return { message: msg };
+      }
+    }
+  };
+}
 function buildYoloCommand(opts) {
   return {
     name: "yolo",
@@ -8455,11 +9102,14 @@ function buildBuiltinSlashCommands(opts) {
     buildClearCommand(opts),
     buildCompactCommand(opts),
     buildContextCommand(opts),
+    buildDevCommand(opts),
     buildCodebaseReindexCommand(opts),
+    buildTechStackCommand(opts),
     buildToolsCommand(opts),
     buildPluginCommand(opts),
     buildPruneCommand(opts),
     buildMcpSlashCommand(opts),
+    buildSuggestCommand(opts),
     buildAuthCommand(opts),
     buildDiagCommand(opts),
     buildStatsCommand(opts),
@@ -8517,13 +9167,13 @@ var MANIFESTS = [
 ];
 async function detectProjectKind(projectRoot) {
   try {
-    await fsp4.access(path9.join(projectRoot, ".wrongstack", "AGENTS.md"));
+    await fsp4.access(path10.join(projectRoot, ".wrongstack", "AGENTS.md"));
     return "initialized";
   } catch {
   }
   for (const m of MANIFESTS) {
     try {
-      await fsp4.access(path9.join(projectRoot, m));
+      await fsp4.access(path10.join(projectRoot, m));
       return "project";
     } catch {
     }
@@ -8531,8 +9181,8 @@ async function detectProjectKind(projectRoot) {
   return "empty";
 }
 async function scaffoldAgentsMd(projectRoot) {
-  const dir = path9.join(projectRoot, ".wrongstack");
-  const file = path9.join(dir, "AGENTS.md");
+  const dir = path10.join(projectRoot, ".wrongstack");
+  const file = path10.join(dir, "AGENTS.md");
   const facts = await detectProjectFacts(projectRoot);
   const body = renderAgentsTemplate(facts);
   await fsp4.mkdir(dir, { recursive: true });
@@ -8545,7 +9195,7 @@ async function runProjectCheck(opts) {
   if (kind === "initialized") {
     renderer.write(
       `
-  ${color.green("\u2713")} Project initialized ${color.dim(`(${path9.join(projectRoot, ".wrongstack", "AGENTS.md")})`)}
+  ${color.green("\u2713")} Project initialized ${color.dim(`(${path10.join(projectRoot, ".wrongstack", "AGENTS.md")})`)}
 `
     );
     return true;
@@ -8576,7 +9226,7 @@ async function runProjectCheck(opts) {
     }
     return true;
   }
-  const gitDir = path9.join(projectRoot, ".git");
+  const gitDir = path10.join(projectRoot, ".git");
   let hasGit = false;
   try {
     await fsp4.access(gitDir);
@@ -8770,7 +9420,7 @@ var ReadlineInputReader = class {
   history = [];
   pending = false;
   constructor(opts = {}) {
-    this.historyFile = opts.historyFile ?? path9.join(os2.homedir(), ".wrongstack", "history");
+    this.historyFile = opts.historyFile ?? path10.join(os2.homedir(), ".wrongstack", "history");
   }
   async loadHistory() {
     try {
@@ -8782,7 +9432,7 @@ var ReadlineInputReader = class {
   }
   async saveHistory() {
     try {
-      await fsp4.mkdir(path9.dirname(this.historyFile), { recursive: true });
+      await fsp4.mkdir(path10.dirname(this.historyFile), { recursive: true });
       await fsp4.writeFile(this.historyFile, this.history.slice(-1e3).join("\n"));
     } catch {
     }
@@ -9075,20 +9725,20 @@ function assertSafeToDelete(filename, parentDir) {
   if (PROTECTED_BASENAMES.has(filename)) {
     throw new Error(`Refusing to delete protected file: ${filename}`);
   }
-  if (filename !== path9.basename(filename)) {
+  if (filename !== path10.basename(filename)) {
     throw new Error(`Refusing to delete path with traversal: ${filename}`);
   }
   if (!filename.startsWith("config.json.") || !filename.endsWith(".bak")) {
     throw new Error(`Refusing to delete unknown file: ${filename}`);
   }
-  const resolvedParent = path9.resolve(parentDir);
+  const resolvedParent = path10.resolve(parentDir);
   if (!resolvedParent.endsWith(".wrongstack")) {
     throw new Error(`Unexpected parent directory for bak prune: ${resolvedParent}`);
   }
 }
 async function safeDelete(filePath) {
-  const dir = path9.dirname(filePath);
-  const filename = path9.basename(filePath);
+  const dir = path10.dirname(filePath);
+  const filename = path10.basename(filePath);
   try {
     assertSafeToDelete(filename, dir);
     await fsp4.unlink(filePath);
@@ -9133,16 +9783,16 @@ function diffSummary(oldCfg, newCfg) {
 }
 var defaultHomeDir = () => os2__default.homedir();
 function historyDir(homeFn = defaultHomeDir) {
-  return path9.join(homeFn(), ".wrongstack", "config.history", "entries");
+  return path10.join(homeFn(), ".wrongstack", "config.history", "entries");
 }
 function historyIndexPath(homeFn = defaultHomeDir) {
-  return path9.join(homeFn(), ".wrongstack", "config.history", "index.json");
+  return path10.join(homeFn(), ".wrongstack", "config.history", "index.json");
 }
 function configPath(homeFn = defaultHomeDir) {
-  return path9.join(homeFn(), ".wrongstack", "config.json");
+  return path10.join(homeFn(), ".wrongstack", "config.json");
 }
 function backupLastPath(homeFn = defaultHomeDir) {
-  return path9.join(homeFn(), ".wrongstack", "config.json.last");
+  return path10.join(homeFn(), ".wrongstack", "config.json.last");
 }
 function entryId(ts) {
   return ts.replace(/[:.]/g, "-").slice(0, 19);
@@ -9197,17 +9847,17 @@ async function backupCurrent(homeFn = defaultHomeDir) {
   }
   if (content !== void 0) {
     try {
-      const bakPath = path9.join(homeFn(), ".wrongstack", `config.json.${ts}.bak`);
+      const bakPath = path10.join(homeFn(), ".wrongstack", `config.json.${ts}.bak`);
       await atomicWrite(bakPath, content);
     } catch {
     }
   }
   try {
-    const dir = path9.join(homeFn(), ".wrongstack");
+    const dir = path10.join(homeFn(), ".wrongstack");
     const files = await fsp4.readdir(dir);
     const baks = files.filter((f) => f.startsWith("config.json.") && f.endsWith(".bak")).sort().reverse();
     for (const f of baks.slice(10)) {
-      await safeDelete(path9.join(dir, f));
+      await safeDelete(path10.join(dir, f));
     }
   } catch {
   }
@@ -9225,7 +9875,7 @@ async function appendHistory(oldCfg, newCfg, description, homeFn = defaultHomeDi
   };
   try {
     await fsp4.writeFile(
-      path9.join(historyDir(homeFn), `${id}.json`),
+      path10.join(historyDir(homeFn), `${id}.json`),
       JSON.stringify(entry, null, 2),
       "utf8"
     );
@@ -9233,7 +9883,7 @@ async function appendHistory(oldCfg, newCfg, description, homeFn = defaultHomeDi
     throw new FsError({
       message: err instanceof Error ? err.message : String(err),
       code: ERROR_CODES.FS_WRITE_FAILED,
-      path: path9.join(historyDir(homeFn), `${id}.json`),
+      path: path10.join(historyDir(homeFn), `${id}.json`),
       cause: err
     });
   }
@@ -9248,7 +9898,7 @@ async function listHistory(homeFn = defaultHomeDir) {
 }
 async function getHistoryEntry(id, homeFn = defaultHomeDir) {
   try {
-    const raw = await fsp4.readFile(path9.join(historyDir(homeFn), `${id}.json`), "utf8");
+    const raw = await fsp4.readFile(path10.join(historyDir(homeFn), `${id}.json`), "utf8");
     return JSON.parse(raw);
   } catch {
     return null;
@@ -9314,10 +9964,10 @@ var theme = { primary: color.amber };
 async function saveToGlobalConfig(configPath2, provider, model, homeFn = () => process.env.HOME ?? os2__default.homedir()) {
   try {
     const { atomicWrite: atomicWrite14 } = await import('@wrongstack/core');
-    const fs29 = await import('fs/promises');
+    const fs30 = await import('fs/promises');
     let existing = {};
     try {
-      const raw = await fs29.readFile(configPath2, "utf8");
+      const raw = await fs30.readFile(configPath2, "utf8");
       existing = JSON.parse(raw);
     } catch {
     }
@@ -9653,12 +10303,12 @@ function pickGroupIndex(opts) {
     try {
       let current = 0;
       try {
-        const parsed = Number.parseInt(fs14.readFileSync(opts.cursorFile, "utf8").trim(), 10);
+        const parsed = Number.parseInt(fs15.readFileSync(opts.cursorFile, "utf8").trim(), 10);
         if (Number.isFinite(parsed)) current = wrap(parsed);
       } catch {
       }
-      fs14.mkdirSync(path9.dirname(opts.cursorFile), { recursive: true });
-      fs14.writeFileSync(opts.cursorFile, String(wrap(current + 1)));
+      fs15.mkdirSync(path10.dirname(opts.cursorFile), { recursive: true });
+      fs15.writeFileSync(opts.cursorFile, String(wrap(current + 1)));
       return current;
     } catch {
     }
@@ -9994,14 +10644,14 @@ function summarize(value, name) {
   if (typeof v === "object" && v !== null) {
     const o = v;
     if (name === "edit") {
-      const path27 = typeof o["path"] === "string" ? o["path"] : "";
+      const path28 = typeof o["path"] === "string" ? o["path"] : "";
       const reps = typeof o["replacements"] === "number" ? o["replacements"] : 0;
-      return `${path27}  ${reps} replacement${reps === 1 ? "" : "s"}`.trim();
+      return `${path28}  ${reps} replacement${reps === 1 ? "" : "s"}`.trim();
     }
     if (name === "write") {
-      const path27 = typeof o["path"] === "string" ? o["path"] : "";
+      const path28 = typeof o["path"] === "string" ? o["path"] : "";
       const bytes = typeof o["bytes"] === "number" ? o["bytes"] : void 0;
-      return bytes !== void 0 ? `${path27}  ${bytes}B` : path27;
+      return bytes !== void 0 ? `${path28}  ${bytes}B` : path28;
     }
     if (typeof o["count"] === "number") {
       return `${o["count"]} match${o["count"] === 1 ? "" : "es"}`;
@@ -11219,7 +11869,7 @@ var doctorCmd = async (_args, deps) => {
   }
   try {
     await fsp4.mkdir(deps.paths.projectSessions, { recursive: true });
-    const probe = path9.join(deps.paths.projectSessions, `.probe-${Date.now()}`);
+    const probe = path10.join(deps.paths.projectSessions, `.probe-${Date.now()}`);
     await fsp4.writeFile(probe, "");
     await fsp4.unlink(probe);
     checks.push({ name: "sessions writable", status: "ok", detail: deps.paths.projectSessions });
@@ -11322,8 +11972,8 @@ var exportCmd = async (args, deps) => {
     return 1;
   }
   if (output) {
-    await fsp4.mkdir(path9.dirname(path9.resolve(deps.cwd, output)), { recursive: true });
-    await fsp4.writeFile(path9.resolve(deps.cwd, output), rendered, "utf8");
+    await fsp4.mkdir(path10.dirname(path10.resolve(deps.cwd, output)), { recursive: true });
+    await fsp4.writeFile(path10.resolve(deps.cwd, output), rendered, "utf8");
     deps.renderer.write(`Wrote ${rendered.length} bytes to ${output}
 `);
   } else {
@@ -11396,8 +12046,8 @@ var initCmd = async (_args, deps) => {
   const vault = new DefaultSecretVault({ keyFile: deps.paths.secretsKey });
   const encrypted = encryptConfigSecrets(config, vault);
   await atomicWrite(deps.paths.globalConfig, JSON.stringify(encrypted, null, 2), { mode: 384 });
-  await fsp4.mkdir(path9.join(deps.projectRoot, ".wrongstack"), { recursive: true });
-  const agentsFile = path9.join(deps.projectRoot, ".wrongstack", "AGENTS.md");
+  await fsp4.mkdir(path10.join(deps.projectRoot, ".wrongstack"), { recursive: true });
+  const agentsFile = path10.join(deps.projectRoot, ".wrongstack", "AGENTS.md");
   const projectFacts = await detectProjectFacts(deps.projectRoot);
   await atomicWrite(agentsFile, renderAgentsTemplate(projectFacts));
   deps.renderer.writeInfo(`Wrote ${deps.paths.globalConfig}`);
@@ -11854,7 +12504,7 @@ var usageCmd = async (_args, deps) => {
   return 0;
 };
 var projectsCmd = async (_args, deps) => {
-  const projectsRoot = path9.join(deps.paths.globalRoot, "projects");
+  const projectsRoot = path10.join(deps.paths.globalRoot, "projects");
   try {
     const entries = await fsp4.readdir(projectsRoot);
     if (entries.length === 0) {
@@ -11864,7 +12514,7 @@ var projectsCmd = async (_args, deps) => {
     for (const hash of entries) {
       try {
         const meta = JSON.parse(
-          await fsp4.readFile(path9.join(projectsRoot, hash, "meta.json"), "utf8")
+          await fsp4.readFile(path10.join(projectsRoot, hash, "meta.json"), "utf8")
         );
         deps.renderer.write(
           `  ${color.dim(hash)}  ${color.dim(meta.lastSeen ?? "")}  ${meta.root ?? "?"}
@@ -12071,20 +12721,20 @@ ${navLines.join(" \xB7 ")}
 async function mutateModelsConfig(deps, mutator) {
   const vault = deps.vault;
   const configPath2 = deps.paths.globalConfig;
-  let fileExists = true;
+  let fileExists2 = true;
   let raw;
   try {
     raw = await fsp4.readFile(configPath2, "utf8");
   } catch (err) {
     if (err.code !== "ENOENT") throw err;
-    fileExists = false;
+    fileExists2 = false;
     raw = "{}";
   }
   let parsed;
   try {
     parsed = JSON.parse(raw);
   } catch (err) {
-    if (fileExists) {
+    if (fileExists2) {
       throw new Error(
         `Refusing to overwrite corrupt config at ${configPath2} (${err.message}).`
       );
@@ -12243,7 +12893,7 @@ async function listFleetRuns(deps) {
   }
   const runs = [];
   for (const id of entries) {
-    const runDir = path9.join(deps.paths.projectSessions, id);
+    const runDir = path10.join(deps.paths.projectSessions, id);
     let stat4;
     try {
       stat4 = await fsp4.stat(runDir);
@@ -12256,17 +12906,17 @@ async function listFleetRuns(deps) {
     let subagentCount = 0;
     let subagentsDir;
     try {
-      await fsp4.access(path9.join(runDir, "fleet.json"));
+      await fsp4.access(path10.join(runDir, "fleet.json"));
       manifest = true;
     } catch {
     }
     try {
-      await fsp4.access(path9.join(runDir, "checkpoint.json"));
+      await fsp4.access(path10.join(runDir, "checkpoint.json"));
       checkpoint = true;
     } catch {
     }
     try {
-      subagentsDir = path9.join(runDir, "subagents");
+      subagentsDir = path10.join(runDir, "subagents");
       const files = await fsp4.readdir(subagentsDir);
       subagentCount = files.filter((f) => f.endsWith(".jsonl")).length;
     } catch {
@@ -12295,7 +12945,7 @@ async function listFleetRuns(deps) {
   return 0;
 }
 async function showFleetRun(runId, deps) {
-  const runDir = path9.join(deps.paths.projectSessions, runId);
+  const runDir = path10.join(deps.paths.projectSessions, runId);
   let stat4;
   try {
     stat4 = await fsp4.stat(runDir);
@@ -12312,7 +12962,7 @@ async function showFleetRun(runId, deps) {
   deps.renderer.write(color.bold(`
 Fleet Run: ${runId}
 `) + "\n");
-  const manifestPath = path9.join(runDir, "fleet.json");
+  const manifestPath = path10.join(runDir, "fleet.json");
   let manifestData = null;
   try {
     manifestData = await fsp4.readFile(manifestPath, "utf8");
@@ -12328,7 +12978,7 @@ Fleet Run: ${runId}
     deps.renderer.write(`  ${color.dim("\u25CB")} fleet.json \u2014 not found
 `);
   }
-  const checkpointPath = path9.join(runDir, "checkpoint.json");
+  const checkpointPath = path10.join(runDir, "checkpoint.json");
   let checkpointData = null;
   try {
     checkpointData = await fsp4.readFile(checkpointPath, "utf8");
@@ -12375,7 +13025,7 @@ Fleet Run: ${runId}
     } catch {
     }
   }
-  const subagentsDir = path9.join(runDir, "subagents");
+  const subagentsDir = path10.join(runDir, "subagents");
   let subagentFiles = [];
   try {
     subagentFiles = await fsp4.readdir(subagentsDir);
@@ -12387,7 +13037,7 @@ Fleet Run: ${runId}
   Subagent transcripts (${subagentFiles.length}):
 `);
     for (const f of subagentFiles.sort()) {
-      const filePath = path9.join(subagentsDir, f);
+      const filePath = path10.join(subagentsDir, f);
       let size;
       try {
         const s = await fsp4.stat(filePath);
@@ -12404,7 +13054,7 @@ Fleet Run: ${runId}
   ${color.dim("\u25CB")} No subagent transcripts
 `);
   }
-  const sharedDir = path9.join(runDir, "shared");
+  const sharedDir = path10.join(runDir, "shared");
   try {
     const files = await fsp4.readdir(sharedDir);
     deps.renderer.write(`
@@ -12571,7 +13221,7 @@ function findSessionId(args) {
 var rewindCmd = async (args, deps) => {
   const flags = parseRewindFlags(args);
   const wpaths = resolveWstackPaths({ projectRoot: deps.projectRoot });
-  const sessionsDir = path9.join(wpaths.globalRoot, "sessions");
+  const sessionsDir = path10.join(wpaths.globalRoot, "sessions");
   const rewind = new DefaultSessionRewinder(sessionsDir, deps.projectRoot);
   let sessionId = findSessionId(args);
   if (!sessionId) {
@@ -12811,10 +13461,10 @@ var auditCmd = async (args, deps) => {
   return verify.ok ? 0 : 1;
 };
 async function listAudits(log, dir, deps) {
-  const fs29 = await import('fs/promises');
+  const fs30 = await import('fs/promises');
   let entries;
   try {
-    entries = await fs29.readdir(dir);
+    entries = await fs30.readdir(dir);
   } catch {
     deps.renderer.write(
       color.dim(`No sessions dir found at ${dir}. Run a session first.`) + "\n"
@@ -13083,7 +13733,7 @@ Output ONLY a ranked list, one per line:
     const text = resp.content[0] && "text" in resp.content[0] ? resp.content[0].text : "";
     const rankings = [];
     for (const line of text.split("\n")) {
-      const m = line.match(/^\s*(\d+)[\.\)]\s*Response\s+([A-Z])/i);
+      const m = line.match(/^\s*(\d+)[.)]\s*Response\s+([A-Z])/i);
       if (m) {
         const label = m[2].toUpperCase();
         const idx = labelToIdx.get(label);
@@ -13714,22 +14364,22 @@ function fmtDuration(ms) {
   const remMin = m - h * 60;
   return `${h}h${remMin}m`;
 }
-function fmtTaskResultLine(r, color58) {
+function fmtTaskResultLine(r, color62) {
   const stats = `${r.iterations}it ${r.toolCalls}tc ${fmtDuration(r.durationMs)}`;
   const errMsg = typeof r.error === "string" ? r.error : r.error?.message;
   const errKind = typeof r.error === "object" ? r.error?.kind : void 0;
   const errTail = errMsg ? ` \u2014 ${errMsg.replace(/\s+/g, " ").slice(0, 80)}${errMsg.length > 80 ? "\u2026" : ""}` : "";
-  const errKindChip = errKind ? color58.dim(` [${errKind}]`) : "";
-  const errSnip = errMsg || errKind ? `${errKindChip}${color58.dim(errTail)}` : "";
+  const errKindChip = errKind ? color62.dim(` [${errKind}]`) : "";
+  const errSnip = errMsg || errKind ? `${errKindChip}${color62.dim(errTail)}` : "";
   switch (r.status) {
     case "success":
-      return { mark: color58.green("\u2713"), stats, tail: "" };
+      return { mark: color62.green("\u2713"), stats, tail: "" };
     case "timeout":
-      return { mark: color58.yellow("\u23F1"), stats: `${color58.yellow("timeout")} ${stats}`, tail: errSnip };
+      return { mark: color62.yellow("\u23F1"), stats: `${color62.yellow("timeout")} ${stats}`, tail: errSnip };
     case "stopped":
-      return { mark: color58.dim("\u2298"), stats: `${color58.dim("stopped")} ${stats}`, tail: errSnip };
+      return { mark: color62.dim("\u2298"), stats: `${color62.dim("stopped")} ${stats}`, tail: errSnip };
     case "failed":
-      return { mark: color58.red("\u2717"), stats: `${color58.red("failed")} ${stats}`, tail: errSnip };
+      return { mark: color62.red("\u2717"), stats: `${color62.red("failed")} ${stats}`, tail: errSnip };
   }
 }
 
@@ -13747,7 +14397,7 @@ function resolveBundledSkillsDir() {
   try {
     const req2 = createRequire(import.meta.url);
     const corePkg = req2.resolve("@wrongstack/core/package.json");
-    return path9.join(path9.dirname(corePkg), "skills");
+    return path10.join(path10.dirname(corePkg), "skills");
   } catch {
     return void 0;
   }
@@ -13997,7 +14647,7 @@ async function boot(argv) {
     } catch {
     }
     printLaunchHints(renderer, flags, {
-      cursorFile: path9.join(wpaths.cacheDir, "hint-cursor")
+      cursorFile: path10.join(wpaths.cacheDir, "hint-cursor")
     });
   }
   return {
@@ -14018,7 +14668,7 @@ async function boot(argv) {
 }
 async function checkGitInCwd(opts) {
   const { cwd, renderer, reader } = opts;
-  const cwdGit = path9.join(cwd, ".git");
+  const cwdGit = path10.join(cwd, ".git");
   let hasCwdGit = false;
   try {
     await fsp4.access(cwdGit);
@@ -14059,10 +14709,10 @@ async function checkGitInCwd(opts) {
       }
     }
   }
-  const parentDir = path9.dirname(cwd);
+  const parentDir = path10.dirname(cwd);
   if (parentDir !== cwd) {
     try {
-      await fsp4.access(path9.join(parentDir, ".git"));
+      await fsp4.access(path10.join(parentDir, ".git"));
       renderer.write(
         `  ${color.dim("\u2139")} A ${color.bold(".git")} repo exists in the parent directory: ${color.dim(parentDir)}
 `
@@ -14379,11 +15029,29 @@ async function predictNextTasks(input, opts) {
   }
 }
 init_sdd();
+function parseSuggestionsFromOutput(finalText) {
+  const patterns = [
+    /💡\s*Next\s+steps?\s*\n((?:\d+\.\s+.+\n?)+)/i,
+    /##?\s*Next\s+steps?\s*\n((?:\d+\.\s+.+\n?)+)/i,
+    /Next\s+steps?\s*\n((?:\d+\.\s+.+\n?)+)/i
+  ];
+  for (const pat of patterns) {
+    const m = pat.exec(finalText);
+    if (m && m[1]) {
+      const block = m[1].trim();
+      const lines = block.split("\n").filter(Boolean);
+      const suggestions = lines.map((l) => l.replace(/^\d+\.\s*/, "").trim()).filter((s) => s.length > 3);
+      if (suggestions.length > 0) return suggestions.slice(0, 5);
+    }
+  }
+  return null;
+}
 async function runRepl(opts) {
   if (opts.banner !== false) printBanner(opts.renderer, opts.projectName);
   await renderGoalBanner(opts);
   let activeCtrl;
   let interrupts = 0;
+  let autoIterCount = 0;
   let exiting = false;
   const onSigint = () => {
     interrupts++;
@@ -14538,6 +15206,96 @@ async function runRepl(opts) {
           continue;
         }
       }
+      {
+        const mode = opts.getAutonomy?.() ?? "off";
+        const suggestions = opts.getSuggestions?.() ?? [];
+        if (mode === "suggest" && suggestions.length > 0) {
+          const lines = suggestions.map(
+            (s, i) => `  ${color.bold(`${i + 1}.`)} ${color.dim(s)}`
+          );
+          opts.renderer.write(
+            `
+${color.cyan("  \u{1F4A1} Suggested next steps")}  ${color.dim("(use /next 1, /next 2, or /next 1 2 3)")}
+${lines.join("\n")}
+
+`
+          );
+        }
+        if (mode === "auto" && suggestions.length > 0) {
+          const maxIter = opts.autoProceedMaxIterations ?? 50;
+          if (maxIter > 0 && autoIterCount >= maxIter) {
+            console.log(JSON.stringify({
+              level: "info",
+              event: "auto_proceed_limit_reached",
+              iterations: autoIterCount,
+              maxIterations: maxIter
+            }));
+            opts.renderer.write(
+              `
+${color.amber("  \u26A0 Auto-proceed limit reached")} \u2014 ${color.dim(`${autoIterCount} iterations. Waiting for input.`)}
+
+`
+            );
+            autoIterCount = 0;
+          } else {
+            const top = suggestions[0] ?? "";
+            const delay = opts.autoProceedDelayMs ?? 45e3;
+            if (opts.onValidateAutoProceed) {
+              try {
+                const lastOutput = (
+                  /* last known agent output — use the stored suggestions
+                  and any recent context the host can provide */
+                  ""
+                );
+                const ok = await opts.onValidateAutoProceed(top, lastOutput);
+                if (!ok) {
+                  opts.renderer.write(
+                    `
+${color.amber("  \u26A0 Auto-proceed held")} \u2014 ${color.dim("suggestions need review. Waiting for input.")}
+
+`
+                  );
+                  const lines = suggestions.map(
+                    (s, i) => `  ${color.bold(`${i + 1}.`)} ${color.dim(s)}`
+                  );
+                  opts.renderer.write(
+                    `${color.dim("  Next steps:")}
+${lines.join("\n")}
+
+`
+                  );
+                  autoIterCount = 0;
+                } else {
+                  const ctrl = new AbortController();
+                  activeCtrl = ctrl;
+                  try {
+                    autoIterCount++;
+                    await runAutoProceed(opts, top, delay, ctrl);
+                  } finally {
+                    activeCtrl = void 0;
+                  }
+                  continue;
+                }
+              } catch {
+                opts.renderer.write(
+                  color.dim("  Auto-proceed validation unavailable \u2014 waiting for input.\n")
+                );
+                autoIterCount = 0;
+              }
+            } else {
+              const ctrl = new AbortController();
+              activeCtrl = ctrl;
+              try {
+                autoIterCount++;
+                await runAutoProceed(opts, top, delay, ctrl);
+              } finally {
+                activeCtrl = void 0;
+              }
+              continue;
+            }
+          }
+        }
+      }
       let raw;
       try {
         raw = await readPossiblyMultiline(opts);
@@ -14631,6 +15389,10 @@ ${color.dim(taskList2)}
                     }
                   }
                 }
+                if (opts.onSuggestionsParsed) {
+                  const parsed = parseSuggestionsFromOutput(runResult.finalText);
+                  opts.onSuggestionsParsed(parsed);
+                }
               }
             } catch (_runErr) {
               opts.renderer.writeWarning("AI auto-trigger failed. You can continue manually.");
@@ -14791,6 +15553,10 @@ ${color.dim(taskList2)}
             }
           }
         }
+        if (result.status === "done" && result.finalText && opts.onSuggestionsParsed) {
+          const parsed = parseSuggestionsFromOutput(result.finalText);
+          opts.onSuggestionsParsed(parsed);
+        }
         if (opts.tokenCounter && before) {
           const after = opts.tokenCounter.total();
           const costAfter = opts.tokenCounter.estimateCost().total;
@@ -14853,6 +15619,10 @@ ${color.cyan("  Suggested next steps:")}
 ${suggestResult.finalText}
 `
                 );
+                if (opts.onSuggestionsParsed) {
+                  const parsed = parseSuggestionsFromOutput(suggestResult.finalText);
+                  opts.onSuggestionsParsed(parsed);
+                }
               }
             } catch {
             } finally {
@@ -14983,6 +15753,79 @@ async function renderGoalBanner(opts) {
   }
   opts.renderer.write("\n");
 }
+async function runAutoProceed(opts, suggestion, delayMs, ctrl) {
+  const truncated = suggestion.length > 80 ? `${suggestion.slice(0, 77)}\u2026` : suggestion;
+  console.log(JSON.stringify({
+    level: "info",
+    event: "auto_proceed_started",
+    suggestion: truncated,
+    delayMs
+  }));
+  try {
+    await autoProceedCountdown(opts, delayMs, suggestion, ctrl.signal);
+    const runBlocks = [{ type: "text", text: suggestion }];
+    const runResult = await opts.agent.run(runBlocks, { signal: ctrl.signal });
+    console.log(JSON.stringify({
+      level: "info",
+      event: "auto_proceed_completed",
+      suggestion: truncated,
+      status: runResult.status,
+      iterations: runResult.iterations
+    }));
+    opts.onAgentIterationComplete?.(
+      estimateRequestTokensCalibrated(
+        opts.agent.ctx.messages,
+        opts.agent.ctx.systemPrompt,
+        opts.agent.ctx.tools ?? []
+      ).total
+    );
+    if (runResult.status === "done" && runResult.finalText && opts.onSuggestionsParsed) {
+      const parsed = parseSuggestionsFromOutput(runResult.finalText);
+      opts.onSuggestionsParsed(parsed);
+    }
+  } finally {
+  }
+}
+async function autoProceedCountdown(opts, delayMs, suggestion, signal) {
+  const sec = Math.ceil(delayMs / 1e3);
+  const truncated = suggestion.length > 100 ? `${suggestion.slice(0, 97)}\u2026` : suggestion;
+  opts.renderer.write(
+    `
+${color.cyan("\u23F3 Auto-proceeding")} in ${sec}s\u2026 ${color.dim("(Ctrl+C to cancel)")}
+`
+  );
+  opts.renderer.write(`${color.dim("  \u25B8")} ${color.dim(truncated)}
+`);
+  const start = Date.now();
+  let lastSec = sec;
+  return new Promise((resolve5, reject) => {
+    const onAbort = () => {
+      clearInterval(interval);
+      reject(new DOMException("Aborted", "AbortError"));
+    };
+    signal.addEventListener("abort", onAbort, { once: true });
+    const interval = setInterval(() => {
+      if (signal.aborted) return;
+      const elapsed = Date.now() - start;
+      const remaining = Math.max(0, Math.ceil((delayMs - elapsed) / 1e3));
+      if (remaining <= 0) {
+        clearInterval(interval);
+        signal.removeEventListener("abort", onAbort);
+        opts.renderer.write(color.dim(`  \u21B3 Proceeding with: ${truncated}
+`));
+        resolve5();
+        return;
+      }
+      if (remaining !== lastSec) {
+        lastSec = remaining;
+        opts.renderer.write(
+          color.dim(`  \u23F3 ${remaining}s remaining\u2026  (Ctrl+C to cancel)
+`)
+        );
+      }
+    }, 500);
+  });
+}
 async function readPossiblyMultiline(opts) {
   const firstPrompt = theme2.primary("\u203A ");
   const contPrompt = color.dim("\xB7 ");
@@ -15075,6 +15918,11 @@ async function execute(deps) {
     getAutonomy,
     onAutonomy,
     getNextPredict,
+    onSuggestionsParsed,
+    getSuggestions,
+    autoProceedDelayMs,
+    autoProceedMaxIterations,
+    onValidateAutoProceed,
     getEternalEngine,
     getParallelEngine,
     subscribeEternalIteration,
@@ -15303,6 +16151,7 @@ async function execute(deps) {
               auditLevel: cfg.session?.auditLevel ?? "standard",
               indexOnStart: cfg.indexing?.onSessionStart !== false,
               maxIterations: cfg.tools?.maxIterations ?? 500,
+              autoProceedMaxIterations: cfg.autonomy?.autoProceedMaxIterations ?? 50,
               debugStream: cfg.debugStream ?? false,
               configScope: cfg.configScope ?? "global",
               enhanceDelayMs: cfg.autonomy?.enhanceDelayMs ?? 6e4
@@ -15386,10 +16235,15 @@ async function execute(deps) {
                   autonomy.enhanceDelayMs = s.enhanceDelayMs;
                   decrypted.autonomy = autonomy;
                 }
+                if (s.autoProceedMaxIterations !== void 0) {
+                  const autonomy = decrypted.autonomy ?? {};
+                  autonomy.autoProceedMaxIterations = s.autoProceedMaxIterations;
+                  decrypted.autonomy = autonomy;
+                }
                 const toWrite = targetPath === wpaths.globalConfig ? decrypted : filterSafeForProject(decrypted);
                 const encrypted = encryptConfigSecrets$1(toWrite, vault);
                 if (targetPath !== wpaths.globalConfig) {
-                  await fsp4.mkdir(path9.dirname(targetPath), { recursive: true }).catch((err) => console.debug(`[execution] mkdir failed: ${err}`));
+                  await fsp4.mkdir(path10.dirname(targetPath), { recursive: true }).catch((err) => console.debug(`[execution] mkdir failed: ${err}`));
                 }
                 await atomicWrite(targetPath, JSON.stringify(encrypted, null, 2), { mode: 384 });
                 configStore.update({
@@ -15519,11 +16373,16 @@ async function execute(deps) {
           supportsVision,
           attachments,
           effectiveMaxContext,
-          projectName: path9.basename(projectRoot) || void 0,
+          projectName: path10.basename(projectRoot) || void 0,
           projectRoot,
           getAutonomy,
           onAutonomy,
           getNextPredict,
+          onSuggestionsParsed,
+          getSuggestions,
+          autoProceedDelayMs,
+          autoProceedMaxIterations,
+          onValidateAutoProceed,
           getEternalEngine,
           getParallelEngine,
           skillLoader,
@@ -15547,10 +16406,15 @@ async function execute(deps) {
         supportsVision,
         attachments,
         effectiveMaxContext,
-        projectName: path9.basename(projectRoot) || void 0,
+        projectName: path10.basename(projectRoot) || void 0,
         getAutonomy,
         onAutonomy,
         getNextPredict,
+        onSuggestionsParsed,
+        getSuggestions,
+        autoProceedDelayMs,
+        onValidateAutoProceed,
+        autoProceedMaxIterations,
         getEternalEngine,
         getParallelEngine,
         skillLoader,
@@ -15679,7 +16543,7 @@ var MultiAgentHost = class {
       doneCondition: { type: "all_tasks_done" },
       maxConcurrent: this.opts.maxConcurrent ?? 4
     };
-    const defaultScratchpad = this.opts.sharedScratchpadPath || (this.opts.sessionsRoot && this.opts.directorRunId ? path9.join(this.opts.sessionsRoot, this.opts.directorRunId, "shared") : void 0);
+    const defaultScratchpad = this.opts.sharedScratchpadPath || (this.opts.sessionsRoot && this.opts.directorRunId ? path10.join(this.opts.sessionsRoot, this.opts.directorRunId, "shared") : void 0);
     this.director = new Director({
       config: coordinatorConfig,
       manifestPath: this.opts.manifestPath,
@@ -16014,10 +16878,30 @@ var MultiAgentHost = class {
       model: opts?.model,
       tools: opts?.tools
     };
-    const { subagentId, taskId } = await this._spawnAndAssign(subagentConfig);
+    const { subagentId, taskId } = await this._spawnAndAssign(subagentConfig, description);
     this.fleetManager?.addPendingTask(taskId, subagentId, description);
     return { subagentId, taskId };
   }
+  /**
+   * Spawn a fresh subagent, assign a task, and **await** its completion.
+   *
+   * Unlike `spawn()`, which returns immediately with spawn metadata, this
+   * method blocks until the subagent finishes (success, failure, or timeout)
+   * and returns the full `TaskResult`. Use this when the caller needs the
+   * subagent's actual output — e.g. `/techstack` displaying the generated report
+   * in chat, or `/spawn` showing the result inline.
+   *
+   * Optional `opts` lets the caller override the subagent's provider, model,
+   * and tool slice per spawn.
+   */
+  async spawnAndWait(description, opts) {
+    const { taskId } = await this.spawn(description, opts);
+    if (!this.director) throw new Error("Director is not initialized");
+    const results = await this.director.awaitTasks([taskId]);
+    const result = results[0];
+    if (!result) throw new Error(`Task ${taskId} completed but no result returned`);
+    return result;
+  }
   /**
    * Common spawn + assign logic shared by both director mode and raw
    * coordinator mode. Extracts the identical body from the two branches
@@ -16027,11 +16911,11 @@ var MultiAgentHost = class {
    * Returns `{ subagentId, taskId }`. Caller holds `pending` tracking
    * and event emission — the helper only talks to the coordinator.
    */
-  async _spawnAndAssign(subagentConfig) {
+  async _spawnAndAssign(subagentConfig, description = "") {
     const taskId = randomUUID();
     if (!this.director) throw new Error("Director is not initialized");
     const subagentId = await this.director.spawn(subagentConfig);
-    await this.director.assign({ id: taskId, description: "", subagentId });
+    await this.director.assign({ id: taskId, description, subagentId });
     return { subagentId, taskId };
   }
   /**
@@ -16148,16 +17032,16 @@ var MultiAgentHost = class {
     if (this.director) return this.director;
     this.opts.directorMode = true;
     if (this.opts.fleetRoot && !this.opts.manifestPath) {
-      this.opts.manifestPath = path9.join(this.opts.fleetRoot, "fleet.json");
+      this.opts.manifestPath = path10.join(this.opts.fleetRoot, "fleet.json");
     }
     if (this.opts.fleetRoot && !this.opts.sharedScratchpadPath) {
-      this.opts.sharedScratchpadPath = path9.join(this.opts.fleetRoot, "shared");
+      this.opts.sharedScratchpadPath = path10.join(this.opts.fleetRoot, "shared");
     }
     if (this.opts.fleetRoot && !this.opts.sessionsRoot) {
-      this.opts.sessionsRoot = path9.join(this.opts.fleetRoot, "subagents");
+      this.opts.sessionsRoot = path10.join(this.opts.fleetRoot, "subagents");
     }
     if (this.opts.fleetRoot && !this.opts.stateCheckpointPath) {
-      this.opts.stateCheckpointPath = path9.join(this.opts.fleetRoot, "director-state.json");
+      this.opts.stateCheckpointPath = path10.join(this.opts.fleetRoot, "director-state.json");
     }
     await this.ensureDirector();
     return this.director ?? null;
@@ -16329,11 +17213,11 @@ var SessionStats = class {
       if (e.name === "bash") this.bashCommands++;
       else if (e.name === "fetch") this.fetches++;
       if (!e.ok) return;
-      const path27 = typeof input?.path === "string" ? input.path : void 0;
-      if (e.name === "read" && path27) this.readPaths.add(path27);
-      else if (e.name === "edit" && path27) this.editedPaths.add(path27);
-      else if (e.name === "write" && path27) {
-        this.writtenPaths.add(path27);
+      const path28 = typeof input?.path === "string" ? input.path : void 0;
+      if (e.name === "read" && path28) this.readPaths.add(path28);
+      else if (e.name === "edit" && path28) this.editedPaths.add(path28);
+      else if (e.name === "write" && path28) {
+        this.writtenPaths.add(path28);
         const content = typeof input?.content === "string" ? input.content : "";
         this.bytesWritten += Buffer.byteLength(content, "utf8");
       }
@@ -17160,7 +18044,7 @@ function setupMetrics(params) {
   const dumpMetrics = () => {
     if (!metricsSink) return;
     try {
-      const out = path9.join(wpaths.projectSessions, "metrics.json");
+      const out = path10.join(wpaths.projectSessions, "metrics.json");
       const snap = metricsSink.snapshot();
       writeFileSync(out, JSON.stringify(snap, null, 2));
     } catch {
@@ -17235,7 +18119,7 @@ async function setupCodebaseIndexing(deps) {
           if (tool?.mutating && FILE_EDIT_TOOLS.has(tool.name)) {
             const fp = payload.toolUse.input?.file_path;
             if (typeof fp === "string" && fp.length > 0) {
-              const abs = path9.resolve(payload.ctx.cwd, fp);
+              const abs = path10.resolve(payload.ctx.cwd, fp);
               if (isIndexableFile(abs)) {
                 enqueueReindex({ projectRoot, files: [abs], debounceMs, onError });
               }
@@ -17250,11 +18134,11 @@ async function setupCodebaseIndexing(deps) {
   let watcher;
   if (idx.watchExternal) {
     try {
-      watcher = fs14.watch(projectRoot, { recursive: true }, (_event, filename) => {
+      watcher = fs15.watch(projectRoot, { recursive: true }, (_event, filename) => {
         if (!filename) return;
         const rel = filename.toString();
         if (isIgnored(rel)) return;
-        const abs = path9.resolve(projectRoot, rel);
+        const abs = path10.resolve(projectRoot, rel);
         if (!isIndexableFile(abs)) return;
         enqueueReindex({ projectRoot, files: [abs], debounceMs, onError });
       });
@@ -17543,9 +18427,9 @@ async function setupSession(params) {
   const sessionRef = { current: session };
   await recoveryLock.write(session?.id).catch(() => void 0);
   const attachments = new DefaultAttachmentStore({
-    spoolDir: path9.join(wpaths.projectSessions, session?.id, "attachments")
+    spoolDir: path10.join(wpaths.projectSessions, session?.id, "attachments")
   });
-  const queueStore = new QueueStore({ dir: path9.join(wpaths.projectSessions, session?.id) });
+  const queueStore = new QueueStore({ dir: path10.join(wpaths.projectSessions, session?.id) });
   const ctxSignal = new AbortController().signal;
   const context = new Context({
     systemPrompt,
@@ -17558,7 +18442,7 @@ async function setupSession(params) {
     model: config.model
   });
   if (restoredMessages.length > 0) context.state.replaceMessages(restoredMessages);
-  const todosCheckpointPath = path9.join(wpaths.projectSessions, `${session?.id}.todos.json`);
+  const todosCheckpointPath = path10.join(wpaths.projectSessions, `${session?.id}.todos.json`);
   if (resumeId) {
     try {
       const restoredTodos = await loadTodosCheckpoint(todosCheckpointPath);
@@ -17576,15 +18460,15 @@ async function setupSession(params) {
     todosCheckpointPath,
     session?.id
   );
-  const planPath = path9.join(wpaths.projectSessions, `${session?.id}.plan.json`);
+  const planPath = path10.join(wpaths.projectSessions, `${session?.id}.plan.json`);
   context.state.setMeta("plan.path", planPath);
-  const taskPath = path9.join(wpaths.projectSessions, `${session?.id}.tasks.json`);
+  const taskPath = path10.join(wpaths.projectSessions, `${session?.id}.tasks.json`);
   context.state.setMeta("task.path", taskPath);
   let dirState;
   if (resumeId) {
     try {
-      const fleetRoot = path9.join(wpaths.projectSessions, session?.id);
-      dirState = await loadDirectorState(path9.join(fleetRoot, "director-state.json"));
+      const fleetRoot = path10.join(wpaths.projectSessions, session?.id);
+      dirState = await loadDirectorState(path10.join(fleetRoot, "director-state.json"));
       if (dirState) {
         const tCounts = {};
         for (const t of dirState.tasks) tCounts[t.status] = (tCounts[t.status] ?? 0) + 1;
@@ -17624,7 +18508,7 @@ function resolveBundledSkillsDir2() {
   try {
     const req2 = createRequire(import.meta.url);
     const corePkg = req2.resolve("@wrongstack/core/package.json");
-    return path9.join(path9.dirname(corePkg), "skills");
+    return path10.join(path10.dirname(corePkg), "skills");
   } catch {
     return void 0;
   }
@@ -17735,9 +18619,8 @@ async function main(argv) {
     updateInfo
   } = ctx;
   updateInfo = await printUpdateNotice(updateInfo);
-  const { setDebugStreamEnabled, setDebugStreamCallback, defaultDebugStreamCallback } = await import('@wrongstack/providers');
+  const { setDebugStreamEnabled } = await import('@wrongstack/providers');
   if (config.debugStream) setDebugStreamEnabled(true);
-  setDebugStreamCallback(defaultDebugStreamCallback);
   const pathResolver = new DefaultPathResolver(cwd);
   const events = new EventBus();
   events.setLogger(logger);
@@ -17824,7 +18707,7 @@ async function main(argv) {
       modeId,
       modePrompt,
       modelCapabilities,
-      planPath: () => sessionRef.current ? path9.join(wpaths.projectSessions, `${sessionRef.current.id}.plan.json`) : void 0,
+      planPath: () => sessionRef.current ? path10.join(wpaths.projectSessions, `${sessionRef.current.id}.plan.json`) : void 0,
       contributors: [
         // Injects the ETERNAL AUTONOMY block when the user has activated
         // a long-running autonomy engine. Without this, the per-iteration
@@ -18194,6 +19077,7 @@ async function main(argv) {
   })();
   autonomyModeRef.current = autonomyMode;
   let nextPredictEnabled = config.nextPrediction === true;
+  let currentSuggestions = [];
   let eternalEngine = null;
   let parallelEngine = null;
   const eternalListeners = /* @__PURE__ */ new Set();
@@ -18214,12 +19098,12 @@ async function main(argv) {
       }
     }
   };
-  const fleetRoot = directorMode ? path9.join(wpaths.projectSessions, session.id) : void 0;
-  const manifestPath = directorMode ? typeof process.env["WRONGSTACK_FLEET_MANIFEST"] === "string" ? process.env["WRONGSTACK_FLEET_MANIFEST"] : path9.join(expectDefined(fleetRoot), "fleet.json") : void 0;
-  const sharedScratchpadPath = directorMode ? path9.join(expectDefined(fleetRoot), "shared") : void 0;
-  const subagentSessionsRoot = directorMode ? path9.join(expectDefined(fleetRoot), "subagents") : void 0;
-  const stateCheckpointPath = directorMode ? path9.join(expectDefined(fleetRoot), "director-state.json") : void 0;
-  const fleetRootForPromotion = path9.join(wpaths.projectSessions, session.id);
+  const fleetRoot = directorMode ? path10.join(wpaths.projectSessions, session.id) : void 0;
+  const manifestPath = directorMode ? typeof process.env["WRONGSTACK_FLEET_MANIFEST"] === "string" ? process.env["WRONGSTACK_FLEET_MANIFEST"] : path10.join(expectDefined(fleetRoot), "fleet.json") : void 0;
+  const sharedScratchpadPath = directorMode ? path10.join(expectDefined(fleetRoot), "shared") : void 0;
+  const subagentSessionsRoot = directorMode ? path10.join(expectDefined(fleetRoot), "subagents") : void 0;
+  const stateCheckpointPath = directorMode ? path10.join(expectDefined(fleetRoot), "director-state.json") : void 0;
+  const fleetRootForPromotion = path10.join(wpaths.projectSessions, session.id);
   const brainQueue = new BrainDecisionQueue(events);
   const brain = new ObservableBrainArbiter(
     new HumanEscalatingBrainArbiter(new DefaultBrainArbiter(), brainQueue),
@@ -18392,6 +19276,25 @@ async function main(argv) {
       const tag = tags.length > 0 ? ` (${tags.join(" / ")})` : "";
       return `Spawned subagent ${subagentId}${tag} for task ${taskId}. Use /agents to track progress.`;
     },
+    onSpawnAndWait: async (description, spawnOpts) => {
+      const result = await multiAgentHost.spawnAndWait(description, spawnOpts);
+      const tags = [];
+      if (spawnOpts?.provider) tags.push(spawnOpts.provider);
+      if (spawnOpts?.model) tags.push(spawnOpts.model);
+      if (spawnOpts?.name) tags.push(spawnOpts.name);
+      const tag = tags.length > 0 ? ` (${tags.join(" / ")})` : "";
+      const secs = (result.durationMs / 1e3).toFixed(result.durationMs < 1e4 ? 1 : 0);
+      const icon = result.status === "success" ? "\u2713" : result.status === "timeout" ? "\u23F1" : result.status === "stopped" ? "\u2298" : "\u2717";
+      const resultPreview = typeof result.result === "string" && result.result.trim() ? `
+${color.dim("\u2500".repeat(40))}
+${result.result.trim().slice(0, 600)}${result.result.trim().length > 600 ? "\n\u2026" : ""}
+${color.dim("\u2500".repeat(40))}` : "";
+      return [
+        `${icon} ${color.bold(tag ? tag.slice(1) : "subagent")} ${result.status} (${result.iterations} iter \xB7 ${result.toolCalls} tools \xB7 ${secs}s)`,
+        resultPreview,
+        result.error ? `  ${color.amber(`error: ${result.error.message}`)}` : ""
+      ].filter(Boolean).join("\n");
+    },
     onAgents: (subagentId) => {
       const s = multiAgentHost.status();
       if (subagentId) {
@@ -18584,7 +19487,7 @@ async function main(argv) {
       return director.spawn(cfg);
     },
     onFleetLog: async (subagentId, mode) => {
-      const subagentsRoot = path9.join(fleetRootForPromotion, "subagents");
+      const subagentsRoot = path10.join(fleetRootForPromotion, "subagents");
       let runDirs;
       try {
         runDirs = await fsp4.readdir(subagentsRoot);
@@ -18593,7 +19496,7 @@ async function main(argv) {
       }
       const found = [];
       for (const runId of runDirs) {
-        const runDir = path9.join(subagentsRoot, runId);
+        const runDir = path10.join(subagentsRoot, runId);
         let files;
         try {
           files = await fsp4.readdir(runDir);
@@ -18602,7 +19505,7 @@ async function main(argv) {
         }
         for (const f of files) {
           if (!f.endsWith(".jsonl")) continue;
-          const full = path9.join(runDir, f);
+          const full = path10.join(runDir, f);
           try {
             const stat4 = await fsp4.stat(full);
             found.push({
@@ -18703,7 +19606,7 @@ async function main(argv) {
       }
       const dir = await multiAgentHost.ensureDirector();
       if (!dir) return "Director is not available.";
-      const dirStatePath = path9.join(fleetRootForPromotion, "director-state.json");
+      const dirStatePath = path10.join(fleetRootForPromotion, "director-state.json");
       const prior = await loadDirectorState(dirStatePath);
       if (!prior) {
         return "No prior director-state.json found \u2014 nothing to retry.";
@@ -18772,9 +19675,9 @@ async function main(argv) {
       for (const tool of director2.tools(FLEET_ROSTER)) {
         toolRegistry.register(tool);
       }
-      const mp = path9.join(fleetRootForPromotion, "fleet.json");
-      const sp = path9.join(fleetRootForPromotion, "shared");
-      const ss = path9.join(fleetRootForPromotion, "subagents");
+      const mp = path10.join(fleetRootForPromotion, "fleet.json");
+      const sp = path10.join(fleetRootForPromotion, "shared");
+      const ss = path10.join(fleetRootForPromotion, "subagents");
       const lines = [
         `${color.green("\u2713")} Promoted to director mode.`,
         `  Roster: ${Object.keys(FLEET_ROSTER).join(", ")}`,
@@ -18848,6 +19751,12 @@ Restart WrongStack to load or unload plugin code in this session.`;
       }
       return nextPredictEnabled;
     },
+    onSuggestions: (suggestions) => {
+      if (suggestions !== void 0) {
+        currentSuggestions = suggestions;
+      }
+      return currentSuggestions;
+    },
     onAutonomy: (setTo) => {
       if (setTo !== void 0) {
         autonomyMode = setTo;
@@ -19094,6 +20003,54 @@ Restart WrongStack to load or unload plugin code in this session.`;
       return autonomyMode;
     },
     getNextPredict: () => nextPredictEnabled,
+    onSuggestionsParsed: (suggestions) => {
+      currentSuggestions = suggestions ?? [];
+    },
+    getSuggestions: () => currentSuggestions,
+    autoProceedDelayMs: config.autonomy?.autoProceedDelayMs ?? 45e3,
+    autoProceedMaxIterations: config.autonomy?.autoProceedMaxIterations ?? 50,
+    onValidateAutoProceed: async (suggestion, lastOutput) => {
+      try {
+        const resp = await context.provider.complete(
+          {
+            model: context.model,
+            system: [
+              {
+                type: "text",
+                text: "You are a safety validator for an autonomous coding agent. Your ONLY job is to decide whether the agent should auto-proceed with a suggested next step, or whether a human should review first. Reply with exactly one word: YES or NO."
+              }
+            ],
+            messages: [
+              {
+                role: "user",
+                content: [
+                  {
+                    type: "text",
+                    text: `The autonomous agent just completed a turn and generated this top-ranked next-step suggestion:
+
+"${suggestion}"
+
+${lastOutput ? `Recent agent output:
+${lastOutput.slice(0, 500)}
+
+` : ""}Should the agent auto-proceed with this suggestion, or should a human review first?
+
+Reply YES to auto-proceed, NO to wait for human input.`
+                  }
+                ]
+              }
+            ],
+            maxTokens: 5,
+            temperature: 0
+          },
+          { signal: AbortSignal.timeout(1e4) }
+        );
+        const text = resp.content.filter((b) => b.type === "text").map((b) => "text" in b ? b.text : "").join("").trim().toUpperCase();
+        return text.startsWith("YES");
+      } catch {
+        return false;
+      }
+    },
     getEternalEngine: () => eternalEngine,
     getParallelEngine: () => parallelEngine,
     subscribeEternalIteration: (fn) => {