@wrongstack/cli 0.10.2 → 0.24.0

package/dist/index.js

@@ -3007,8 +3007,12 @@ function buildFleetCommand(opts) {
       }
       if (cmd === "kill" || cmd === "stop-all") {
         const targetId = subargs[0];
-        if (!targetId) {
-          const msg3 = `Usage: /fleet kill <subagent-id>`;
+        if (targetId) {
+          if (opts.onFleet) {
+            const msg4 = await opts.onFleet("kill", targetId);
+            return { message: msg4 };
+          }
+          const msg3 = `${color.amber("\u26A0 /fleet kill is not wired in this session.")}`;
           opts.renderer.writeWarning(msg3);
           return { message: msg3 };
         }
@@ -3018,10 +3022,6 @@ function buildFleetCommand(opts) {
           opts.renderer.write(msg3);
           return { message: msg3 };
         }
-        if (opts.onFleet) {
-          const msg3 = await opts.onFleet("kill", targetId);
-          return { message: msg3 };
-        }
         const msg2 = `${color.amber("\u26A0 /fleet kill is not wired in this session.")}`;
         opts.renderer.writeWarning(msg2);
         return { message: msg2 };
@@ -4127,6 +4127,55 @@ function buildBtwCommand(opts) {
     }
   };
 }
+function buildNextCommand(opts) {
+  return {
+    name: "next",
+    description: "Toggle next-task prediction \u2014 show likely next steps after each turn.",
+    argsHint: "[on|off|toggle]",
+    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",
+      "",
+      "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."
+    ].join("\n"),
+    async run(args) {
+      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)}`;
+        opts.renderer.write(msg2);
+        return { message: msg2 };
+      }
+      let target;
+      if (arg === "on" || arg === "enable" || arg === "true") {
+        target = true;
+      } else if (arg === "off" || arg === "disable" || arg === "false") {
+        target = false;
+      } else if (arg === "toggle" || arg === "cycle") {
+        target = !current;
+      } else {
+        const msg2 = `Unknown argument: ${arg}. Use /next on, off, or toggle.`;
+        opts.renderer.writeWarning(msg2);
+        return { message: msg2 };
+      }
+      const now = opts.onNextPredict(target);
+      const msg = `Next-task prediction: ${label(now)}`;
+      opts.renderer.write(msg);
+      return { message: msg };
+    }
+  };
+}
 var KNOWN_VERBS = /* @__PURE__ */ new Set([
   "",
   "show",
@@ -5876,6 +5925,7 @@ function buildBuiltinSlashCommands(opts) {
     buildAutonomyCommand(opts),
     buildGoalCommand(opts),
     buildBtwCommand(opts),
+    buildNextCommand(opts),
     buildModeCommand(opts),
     buildExitCommand(opts),
     buildFixCommand(opts),
@@ -9708,22 +9758,22 @@ function fmtDuration(ms) {
   const remMin = m - h * 60;
   return `${h}h${remMin}m`;
 }
-function fmtTaskResultLine(r, color41) {
+function fmtTaskResultLine(r, color42) {
   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 ? color41.dim(` [${errKind}]`) : "";
-  const errSnip = errMsg || errKind ? `${errKindChip}${color41.dim(errTail)}` : "";
+  const errKindChip = errKind ? color42.dim(` [${errKind}]`) : "";
+  const errSnip = errMsg || errKind ? `${errKindChip}${color42.dim(errTail)}` : "";
   switch (r.status) {
     case "success":
-      return { mark: color41.green("\u2713"), stats, tail: "" };
+      return { mark: color42.green("\u2713"), stats, tail: "" };
     case "timeout":
-      return { mark: color41.yellow("\u23F1"), stats: `${color41.yellow("timeout")} ${stats}`, tail: errSnip };
+      return { mark: color42.yellow("\u23F1"), stats: `${color42.yellow("timeout")} ${stats}`, tail: errSnip };
     case "stopped":
-      return { mark: color41.dim("\u2298"), stats: `${color41.dim("stopped")} ${stats}`, tail: errSnip };
+      return { mark: color42.dim("\u2298"), stats: `${color42.dim("stopped")} ${stats}`, tail: errSnip };
     case "failed":
-      return { mark: color41.red("\u2717"), stats: `${color41.red("failed")} ${stats}`, tail: errSnip };
+      return { mark: color42.red("\u2717"), stats: `${color42.red("failed")} ${stats}`, tail: errSnip };
   }
 }
 
@@ -10140,7 +10190,88 @@ var FleetStatusLine = class {
   }
 };
 
-// src/repl.ts
+// src/next-task-predictor.ts
+var SYSTEM_PROMPT = `You predict the developer's most likely NEXT actions in a coding session. Given what they just asked and what the assistant just did, output the 1-3 most probable next steps. Each must be a concrete, actionable task phrased as an imperative the user could hand back to the assistant (e.g. "Add tests for the new parser", "Wire the command into the CLI"). Output ONLY a numbered list, one step per line, no preamble, no explanation. Prefer steps that follow naturally from unfinished todos or obvious gaps. If there is genuinely nothing meaningful left to do, output exactly: NONE`;
+var MAX_REQUEST_CHARS = 1200;
+var MAX_SUMMARY_CHARS = 1200;
+function clamp(text, n) {
+  const t = text.trim();
+  return t.length <= n ? t : `${t.slice(0, n)}\u2026`;
+}
+function buildPredictionPrompt(input) {
+  const parts = [];
+  parts.push(`The user asked:
+${clamp(input.userRequest, MAX_REQUEST_CHARS) || "(no text)"}`);
+  if (input.assistantSummary.trim()) {
+    parts.push(
+      `The assistant just finished and reported:
+${clamp(input.assistantSummary, MAX_SUMMARY_CHARS)}`
+    );
+  }
+  const pending = input.todos.filter((t) => t.status !== "completed");
+  if (pending.length > 0) {
+    const list = pending.slice(0, 8).map((t) => `- [${t.status}] ${t.content}`).join("\n");
+    parts.push(`Open todo items:
+${list}`);
+  }
+  parts.push("Predict the 1-3 most likely next steps.");
+  return parts.join("\n\n");
+}
+function parsePredictions(raw, max = 3) {
+  const text = raw.trim();
+  if (!text) return [];
+  if (/^none\b/i.test(text) || /no further steps/i.test(text)) return [];
+  const out = [];
+  for (const lineRaw of text.split("\n")) {
+    const line = lineRaw.trim();
+    if (!line) continue;
+    const stripped = line.replace(/^\s*(?:\d+[.)]|[-*•])\s+/, "").trim();
+    const candidate = stripped || line;
+    if (/^none$/i.test(candidate)) continue;
+    if (candidate) out.push(candidate);
+    if (out.length >= max) break;
+  }
+  return out;
+}
+function extractText(content) {
+  if (Array.isArray(content)) {
+    return content[0]?.text ?? "";
+  }
+  if (content && typeof content === "object") {
+    return content.text ?? "";
+  }
+  return typeof content === "string" ? content : "";
+}
+async function predictNextTasks(input, opts) {
+  const max = opts.maxPredictions ?? 3;
+  const internal = new AbortController();
+  const timeout = setTimeout(() => internal.abort(), 12e3);
+  const onParentAbort = () => internal.abort();
+  if (opts.signal) {
+    if (opts.signal.aborted) internal.abort();
+    else opts.signal.addEventListener("abort", onParentAbort, { once: true });
+  }
+  try {
+    const resp = await opts.provider.complete(
+      {
+        model: opts.model,
+        system: [{ type: "text", text: SYSTEM_PROMPT }],
+        messages: [
+          { role: "user", content: [{ type: "text", text: buildPredictionPrompt(input) }] }
+        ],
+        maxTokens: 160,
+        temperature: 0.3
+      },
+      { signal: internal.signal }
+    );
+    return parsePredictions(extractText(resp.content), max);
+  } catch {
+    return [];
+  } finally {
+    clearTimeout(timeout);
+    if (opts.signal) opts.signal.removeEventListener("abort", onParentAbort);
+  }
+}
 init_sdd();
 async function runRepl(opts) {
   if (opts.banner !== false) printBanner(opts.renderer, opts.projectName);
@@ -10549,6 +10680,37 @@ ${suggestResult.finalText}
             }
           }
         }
+        if (result.status === "done" && opts.getNextPredict?.()) {
+          const autonomy = opts.getAutonomy?.() ?? "off";
+          if (autonomy === "off") {
+            const predictCtrl = new AbortController();
+            activeCtrl = predictCtrl;
+            try {
+              const predictions = await predictNextTasks(
+                {
+                  userRequest: trimmed,
+                  assistantSummary: result.finalText ?? "",
+                  todos: opts.agent.ctx.todos
+                },
+                {
+                  provider: opts.agent.ctx.provider,
+                  model: opts.agent.ctx.model,
+                  signal: predictCtrl.signal
+                }
+              );
+              if (predictions.length > 0) {
+                const lines = predictions.map((p, i) => `    ${i + 1}. ${p}`).join("\n");
+                opts.renderer.write(`
+${color.dim("  \u21B3 likely next:")}
+${color.dim(lines)}
+`);
+              }
+            } catch {
+            } finally {
+              activeCtrl = void 0;
+            }
+          }
+        }
       } catch (err) {
         opts.renderer.writeError(err instanceof Error ? err.message : String(err));
       } finally {
@@ -10731,6 +10893,7 @@ async function execute(deps) {
     getYolo,
     getAutonomy,
     onAutonomy,
+    getNextPredict,
     getEternalEngine,
     getParallelEngine,
     subscribeEternalIteration,
@@ -10888,6 +11051,20 @@ async function execute(deps) {
           yolo: !!config.yolo,
           getYolo,
           getAutonomy,
+          // Next-task prediction (/next). Host owns the gating: returns [] when
+          // the toggle is off or autonomy is self-driving, so the TUI can call
+          // this unconditionally after a done turn. Display-only.
+          predictNext: async (input) => {
+            if (!getNextPredict?.()) return [];
+            if ((getAutonomy?.() ?? "off") !== "off") return [];
+            return predictNextTasks(
+              { ...input, todos: context.todos },
+              {
+                provider: context.provider,
+                model: context.model
+              }
+            );
+          },
           getEternalEngine,
           subscribeEternalIteration,
           subscribeEternalStage,
@@ -10932,13 +11109,11 @@ async function execute(deps) {
           // resize/overlay-leak artifacts can opt back into alt-screen with
           // `--alt-screen`. `--no-alt-screen` still wins when both are passed.
           altScreen: flags["alt-screen"] === true && flags["no-alt-screen"] !== true,
-          // Full mouse mode: clickable pickers + in-app wheel scroll. Opt-in
-          // via --mouse. The TUI combines altScreen || mouse to determine
-          // whether to use the managed viewport (ScrollableHistory + in-app
-          // scroll); --mouse alone enables that without requiring --alt-screen.
-          // Mouse mode takes ownership of the terminal's mouse, suspending
-          // native scroll/copy until `/mouse off`.
-          mouse: flags.mouse === true,
+          // Mouse mode is DISABLED. It was unreliable on Windows consoles
+          // (freezes / constant repaint in the managed viewport) and is not
+          // wanted, so `--mouse` is intentionally ignored and never engages —
+          // the TUI stays keyboard-only. Do not re-wire `flags.mouse` here.
+          mouse: false,
           director,
           fleetRoster,
           onAfterExit: () => {
@@ -11016,6 +11191,7 @@ async function execute(deps) {
           projectRoot,
           getAutonomy,
           onAutonomy,
+          getNextPredict,
           getEternalEngine,
           getParallelEngine,
           skillLoader,
@@ -11039,6 +11215,7 @@ async function execute(deps) {
         projectName: path24.basename(projectRoot) || void 0,
         getAutonomy,
         onAutonomy,
+        getNextPredict,
         getEternalEngine,
         getParallelEngine,
         skillLoader,
@@ -13017,6 +13194,7 @@ async function main(argv) {
     return "off";
   })();
   autonomyModeRef.current = autonomyMode;
+  let nextPredictEnabled = config.nextPrediction === true;
   let eternalEngine = null;
   let parallelEngine = null;
   const eternalListeners = /* @__PURE__ */ new Set();
@@ -13341,7 +13519,7 @@ async function main(argv) {
       for (const sa of s.subagents) {
         if (sa.status === "running" || sa.status === "idle") {
           try {
-            director.terminate(sa.id);
+            director.remove(sa.id);
             killed++;
           } catch {
           }
@@ -13608,6 +13786,14 @@ Restart WrongStack to load or unload plugin code in this session.`;
       }
       return policy.getYolo();
     },
+    onNextPredict: (setTo) => {
+      if (setTo !== void 0) {
+        nextPredictEnabled = setTo;
+        config = patchConfig(config, { nextPrediction: setTo });
+        return setTo;
+      }
+      return nextPredictEnabled;
+    },
     onAutonomy: (setTo) => {
       if (setTo !== void 0) {
         autonomyMode = setTo;
@@ -13838,6 +14024,7 @@ Restart WrongStack to load or unload plugin code in this session.`;
       }
       return autonomyMode;
     },
+    getNextPredict: () => nextPredictEnabled,
     getEternalEngine: () => eternalEngine,
     getParallelEngine: () => parallelEngine,
     subscribeEternalIteration: (fn) => {