@wrongstack/tui 0.6.4 → 0.6.6

package/dist/index.d.ts

@@ -31,19 +31,53 @@ interface RunTuiOptions {
     /** Query live YOLO state from the permission policy. */
     getYolo?: () => boolean;
     /** Query the live autonomy mode. */
-    getAutonomy?: () => 'off' | 'suggest' | 'auto' | 'eternal';
+    getAutonomy?: () => 'off' | 'suggest' | 'auto' | 'eternal' | 'eternal-parallel';
     /**
      * Access the eternal-autonomy engine. When autonomy mode flips to
      * 'eternal' the TUI drives `runOneIteration()` from the post-slash hook
      * so the engine and TUI never race for the shared Context.
      */
     getEternalEngine?: () => _wrongstack_core.EternalAutonomyEngine | null;
+    /**
+     * Access the parallel-eternal engine. When autonomy mode flips to
+     * 'eternal-parallel' the TUI drives `runOneIteration()` from the post-slash
+     * hook so the engine and TUI never race for the shared Context.
+     */
+    getParallelEngine?: () => _wrongstack_core.ParallelEternalEngine | null;
     /**
      * Subscribe to live per-iteration events from the eternal engine.
      * Returns an unsubscribe function. TUI uses this to render each
      * iteration as a live timeline entry as it lands.
      */
     subscribeEternalIteration?: (fn: (entry: _wrongstack_core.JournalEntry) => void) => () => void;
+    /**
+     * Subscribe to per-iteration stage transitions from the eternal engine.
+     * TUI uses this to render live status (decide → execute → reflect →
+     * sleep/paused/stopped) in the status bar.
+     */
+    subscribeEternalStage?: (fn: (stage: {
+        phase: 'idle';
+    } | {
+        phase: 'decide';
+        reason: string;
+    } | {
+        phase: 'execute';
+        task: string;
+    } | {
+        phase: 'reflect';
+        status: 'success' | 'failure' | 'aborted' | 'skipped';
+        note?: string;
+    } | {
+        phase: 'sleep';
+        ms: number;
+    } | {
+        phase: 'paused';
+    } | {
+        phase: 'stopped';
+    } | {
+        phase: 'error';
+        message: string;
+    }) => void) => () => void;
     /** Renders in the startup banner. Read from the CLI's package.json. */
     appVersion?: string;
     /** Provider id for the startup banner ("openai", "anthropic", ...). */
@@ -56,6 +90,8 @@ interface RunTuiOptions {
     getPickableProviders?: () => Promise<ProviderOption[]>;
     /** Apply a (provider, model) pair after the picker confirms. Returns an error string on failure. */
     switchProviderAndModel?: (providerId: string, modelId: string) => string | null;
+    /** Apply an autonomy mode after the picker confirms. Returns an error string on failure. */
+    switchAutonomy?: (mode: 'off' | 'suggest' | 'auto' | 'eternal' | 'eternal-parallel') => string | null;
     /**
      * Model-specific maxContext (tokens), resolved by the CLI via the
      * ModelsRegistry. When omitted, the TUI falls back to the provider

package/dist/index.js

@@ -1550,6 +1550,25 @@ function LiveActivityStrip({
     ] }) }) : null
   ] });
 }
+var AUTONOMY_OPTIONS = [
+  { mode: "off", label: "OFF", description: "Agent stops after each turn (normal interactive mode)", color: "green" },
+  { mode: "suggest", label: "SUGGEST", description: "Shows next-step suggestions after each turn", color: "cyan" },
+  { mode: "auto", label: "AUTO", description: "Self-driving \u2014 agent picks next step and continues", color: "yellow" },
+  { mode: "eternal", label: "ETERNAL", description: "Goal-driven loop \u2014 requires /goal set first", color: "red" },
+  { mode: "eternal-parallel", label: "PARALLEL", description: "Fan-out 4\u20138 subagents per tick \u2014 requires /goal", color: "magenta" }
+];
+function AutonomyPicker({ options, selected, hint }) {
+  return /* @__PURE__ */ jsxs(Box, { flexDirection: "column", paddingX: 1, children: [
+    /* @__PURE__ */ jsx(Text, { color: "cyan", bold: true, children: "\u2501\u2501 Autonomy Mode \u2501\u2501" }),
+    /* @__PURE__ */ jsx(Text, { dimColor: true, children: "\u2191/\u2193 navigate \xB7 Enter select \xB7 Esc cancel \xB7 Ctrl+C exit" }),
+    options.map((opt, i) => /* @__PURE__ */ jsxs(Text, { color: i === selected ? opt.color : void 0, inverse: i === selected, children: [
+      i === selected ? "\u203A " : "  ",
+      /* @__PURE__ */ jsx(Text, { bold: true, children: opt.label.padEnd(12) }),
+      /* @__PURE__ */ jsx(Text, { dimColor: true, children: opt.description })
+    ] }, opt.mode)),
+    hint ? /* @__PURE__ */ jsx(Text, { color: "yellow", children: hint }) : null
+  ] });
+}
 function ModelPicker({
   step,
   providerOptions,
@@ -1634,7 +1653,8 @@ function StatusBar({
   context,
   projectName,
   processCount,
-  hiddenItems
+  hiddenItems,
+  eternalStage
 }) {
   const hiddenSet = new Set(hiddenItems);
   const usage = tokenCounter?.total();
@@ -1730,8 +1750,12 @@ function StatusBar({
               }
             )
           ] }) : null,
+          eternalStage ? /* @__PURE__ */ jsxs(Fragment, { children: [
+            yolo || autonomy && autonomy !== "off" ? /* @__PURE__ */ jsx(Text, { dimColor: true, children: "\u2502" }) : null,
+            /* @__PURE__ */ jsx(EternalStageChip, { stage: eternalStage })
+          ] }) : null,
           elapsedMs !== void 0 && !hiddenSet.has("elapsed") ? /* @__PURE__ */ jsxs(Fragment, { children: [
-            yolo ? /* @__PURE__ */ jsx(Text, { dimColor: true, children: "\u2502" }) : null,
+            yolo || autonomy && autonomy !== "off" || eternalStage ? /* @__PURE__ */ jsx(Text, { dimColor: true, children: "\u2502" }) : null,
             /* @__PURE__ */ jsxs(Text, { dimColor: true, children: [
               "\u23F1 ",
               fmtElapsed2(elapsedMs)
@@ -1855,6 +1879,45 @@ function StatusBar({
     }
   );
 }
+function EternalStageChip({
+  stage
+}) {
+  switch (stage.phase) {
+    case "idle":
+      return /* @__PURE__ */ jsx(Text, { dimColor: true, children: "\u2B1C idle" });
+    case "decide":
+      return /* @__PURE__ */ jsxs(Text, { color: "cyan", children: [
+        "\u2B07 decide: ",
+        stage.reason
+      ] });
+    case "execute":
+      return /* @__PURE__ */ jsxs(Text, { color: "green", children: [
+        "\u25B6 ",
+        /* @__PURE__ */ jsx(Text, { bold: true, children: "execute" }),
+        stage.task ? `(${stage.task})` : ""
+      ] });
+    case "reflect":
+      return /* @__PURE__ */ jsxs(Text, { color: stage.status === "success" ? "green" : stage.status === "failure" ? "red" : "yellow", children: [
+        "\u21A9 reflect: ",
+        stage.status
+      ] });
+    case "sleep":
+      return /* @__PURE__ */ jsxs(Text, { dimColor: true, children: [
+        "\u{1F4A4} sleep ",
+        Math.round(stage.ms / 1e3),
+        "s"
+      ] });
+    case "paused":
+      return /* @__PURE__ */ jsx(Text, { color: "yellow", children: "\u23F8 paused" });
+    case "stopped":
+      return /* @__PURE__ */ jsx(Text, { dimColor: true, children: "\u25A0 stopped" });
+    case "error":
+      return /* @__PURE__ */ jsxs(Text, { color: "red", children: [
+        "\u26A0 error: ",
+        stage.message
+      ] });
+  }
+}
 function ContextChip({ ctx }) {
   const ratio = Math.max(0, Math.min(1, ctx.used / ctx.max));
   const pct = Math.round(ratio * 100);
@@ -2451,6 +2514,30 @@ function reducer(state, action) {
         ...state,
         modelPicker: { ...state.modelPicker, hint: action.text }
       };
+    case "autonomyPickerOpen":
+      return {
+        ...state,
+        autonomyPicker: { open: true, options: action.options, selected: 0, hint: void 0 }
+      };
+    case "autonomyPickerClose":
+      return {
+        ...state,
+        autonomyPicker: { open: false, options: [], selected: 0 }
+      };
+    case "autonomyPickerMove": {
+      const n = state.autonomyPicker.options.length;
+      if (n === 0) return state;
+      const next = (state.autonomyPicker.selected + action.delta + n) % n;
+      return {
+        ...state,
+        autonomyPicker: { ...state.autonomyPicker, selected: next }
+      };
+    }
+    case "autonomyPickerHint":
+      return {
+        ...state,
+        autonomyPicker: { ...state.autonomyPicker, hint: action.text }
+      };
     case "confirmOpen":
       return { ...state, confirmQueue: [...state.confirmQueue, action.info] };
     case "confirmClose":
@@ -2666,6 +2753,9 @@ function reducer(state, action) {
         rewindOverlay: null
       };
     }
+    case "eternalStage": {
+      return { ...state, eternalStage: action.stage };
+    }
   }
 }
 var PASTE_THRESHOLD_CHARS = 200;
@@ -2718,7 +2808,9 @@ function App({
   getYolo,
   getAutonomy,
   getEternalEngine,
+  getParallelEngine,
   subscribeEternalIteration,
+  subscribeEternalStage,
   getSDDContext,
   onSDDOutput,
   appVersion,
@@ -2727,6 +2819,7 @@ function App({
   keyTail,
   getPickableProviders,
   switchProviderAndModel,
+  switchAutonomy,
   effectiveMaxContext,
   onExit,
   director,
@@ -2789,13 +2882,15 @@ function App({
       modelOptions: [],
       selected: 0
     },
+    autonomyPicker: { open: false, options: [], selected: 0 },
     confirmQueue: [],
     contextChipVersion: 0,
     fleet: {},
     fleetCost: 0,
     streamFleet: true,
     checkpoints: [],
-    rewindOverlay: null
+    rewindOverlay: null,
+    eternalStage: null
   });
   const builderRef = useRef(null);
   if (builderRef.current === null) {
@@ -3282,6 +3377,22 @@ function App({
       slashRegistry.unregister("model");
     };
   }, [slashRegistry, getPickableProviders, switchProviderAndModel]);
+  useEffect(() => {
+    if (!switchAutonomy) return;
+    const cmd = {
+      name: "autonomy",
+      aliases: ["auto"],
+      description: "Pick an autonomy mode interactively (picker).",
+      async run() {
+        dispatch({ type: "autonomyPickerOpen", options: AUTONOMY_OPTIONS });
+        return { message: void 0 };
+      }
+    };
+    slashRegistry.register(cmd);
+    return () => {
+      slashRegistry.unregister("autonomy");
+    };
+  }, [slashRegistry, switchAutonomy]);
   useEffect(() => {
     const FLUSH_MS = 100;
     const flush = () => {
@@ -3471,6 +3582,7 @@ function App({
     const offBudgetWarning = events.on("subagent.budget_warning", (e) => {
       const lbl = labelFor(e.subagentId);
       dispatch({ type: "fleetBudgetWarning", id: e.subagentId, kind: e.kind, used: e.used, limit: e.limit });
+      const timeoutSuffix = e.kind === "timeout" ? " (subagent continues running)" : " \u2014 extending";
       dispatch({
         type: "addEntry",
         entry: {
@@ -3478,12 +3590,27 @@ function App({
           agentLabel: lbl.label,
           agentColor: lbl.color,
           icon: "\u26A1",
-          text: `hitting ${e.kind} limit (${e.used}/${e.limit}) \u2014 extending`
+          text: `hitting ${e.kind} limit (${e.used}/${e.limit})${timeoutSuffix}`
+        }
+      });
+    });
+    const offIterationSummary = events.on("subagent.iteration_summary", (e) => {
+      const lbl = labelFor(e.subagentId);
+      const costStr = e.costUsd > 0 ? ` \xB7 ${e.costUsd.toFixed(3)}` : "";
+      const toolStr = e.currentTool ? ` \xB7 doing ${e.currentTool}` : "";
+      const partial = e.partialText ? ` \xB7 "${e.partialText.slice(0, 60)}${e.partialText.length > 60 ? "\u2026" : ""}"` : "";
+      dispatch({
+        type: "addEntry",
+        entry: {
+          kind: "subagent",
+          agentLabel: lbl.label,
+          agentColor: lbl.color,
+          icon: "\u{1F4AC}",
+          text: `L${e.iteration} \xB7 ${e.toolCalls} tools${costStr}${toolStr}${partial}`
         }
       });
     });
     const offTool = events.on("subagent.tool_executed", (e) => {
-      if (director) return;
       dispatch({
         type: "fleetTool",
         id: e.subagentId,
@@ -3499,6 +3626,7 @@ function App({
       offStarted();
       offCompleted();
       offBudgetWarning();
+      offIterationSummary();
       offTool();
     };
   }, [events, director]);
@@ -3912,6 +4040,32 @@ function App({
       }
       return;
     }
+    if (state.autonomyPicker.open) {
+      if (key.escape) {
+        dispatch({ type: "autonomyPickerClose" });
+        return;
+      }
+      if (key.upArrow) {
+        dispatch({ type: "autonomyPickerMove", delta: -1 });
+        return;
+      }
+      if (key.downArrow) {
+        dispatch({ type: "autonomyPickerMove", delta: 1 });
+        return;
+      }
+      if (isEnter) {
+        const opt = state.autonomyPicker.options[state.autonomyPicker.selected];
+        if (!opt) return;
+        const err = switchAutonomy?.(opt.mode);
+        if (err) {
+          dispatch({ type: "autonomyPickerHint", text: err });
+          return;
+        }
+        dispatch({ type: "autonomyPickerClose" });
+        return;
+      }
+      return;
+    }
     if (state.slashPicker.open) {
       if (key.escape) {
         dispatch({ type: "slashPickerClose" });
@@ -4111,6 +4265,18 @@ function App({
       setDraft(next2, lastWordStart);
       return;
     }
+    if (key.delete || key.ctrl && input === "d") {
+      if (cursor >= buffer.length) return;
+      const next2 = buffer.slice(0, cursor) + buffer.slice(cursor + 1);
+      setDraft(next2, cursor);
+      return;
+    }
+    if (key.ctrl && input === "k") {
+      if (cursor >= buffer.length) return;
+      const next2 = buffer.slice(0, cursor);
+      setDraft(next2, cursor);
+      return;
+    }
     if (key.meta && input === "v") {
       await pasteClipboardImage();
       return;
@@ -4269,6 +4435,39 @@ function App({
   const eternalLoopRunningRef = useRef(false);
   const runEternalLoopRef = useRef(runEternalLoop);
   runEternalLoopRef.current = runEternalLoop;
+  const runParallelLoop = async () => {
+    const engine = getParallelEngine?.();
+    if (!engine) return;
+    if (parallelLoopRunningRef.current) return;
+    parallelLoopRunningRef.current = true;
+    try {
+      while (true) {
+        const liveMode = getAutonomy?.() ?? "off";
+        if (liveMode !== "eternal-parallel") break;
+        if (engine.currentState === "stopped") break;
+        dispatch({ type: "status", status: "running" });
+        try {
+          await engine.runOneIteration();
+        } catch (err) {
+          dispatch({
+            type: "addEntry",
+            entry: { kind: "error", text: `[parallel] ${err instanceof Error ? err.message : String(err)}` }
+          });
+        }
+        dispatch({ type: "status", status: "idle" });
+        await new Promise((r) => setTimeout(r, 200));
+      }
+    } finally {
+      parallelLoopRunningRef.current = false;
+      if (getAutonomy) {
+        const finalMode = getAutonomy();
+        if (finalMode !== autonomyLive) setAutonomyLive(finalMode);
+      }
+    }
+  };
+  const parallelLoopRunningRef = useRef(false);
+  const runParallelLoopRef = useRef(runParallelLoop);
+  runParallelLoopRef.current = runParallelLoop;
   useEffect(() => {
     if (!subscribeEternalIteration) return;
     const unsub = subscribeEternalIteration((entry) => {
@@ -4280,6 +4479,13 @@ function App({
     });
     return unsub;
   }, [subscribeEternalIteration]);
+  useEffect(() => {
+    if (!subscribeEternalStage) return;
+    const unsub = subscribeEternalStage((stage) => {
+      dispatch({ type: "eternalStage", stage });
+    });
+    return unsub;
+  }, [subscribeEternalStage]);
   const submit = async (overrideRaw) => {
     const raw = overrideRaw ?? draftRef.current.buffer;
     const trimmed = raw.trim();
@@ -4317,6 +4523,9 @@ function App({
           if (currentAutonomy === "eternal" && getEternalEngine) {
             void runEternalLoopRef.current();
           }
+          if (currentAutonomy === "eternal-parallel" && getParallelEngine) {
+            void runParallelLoopRef.current();
+          }
         }
         if (res?.exit) {
           exit();
@@ -4462,6 +4671,14 @@ User message:
         hint: state.modelPicker.hint
       }
     ) : null,
+    state.autonomyPicker.open ? /* @__PURE__ */ jsx(
+      AutonomyPicker,
+      {
+        options: state.autonomyPicker.options,
+        selected: state.autonomyPicker.selected,
+        hint: state.autonomyPicker.hint
+      }
+    ) : null,
     state.rewindOverlay ? /* @__PURE__ */ jsx(
       CheckpointTimeline,
       {
@@ -4510,7 +4727,8 @@ User message:
         projectName,
         subagentCount: Object.keys(state.fleet).length,
         processCount: getProcessRegistry().activeCount,
-        hiddenItems
+        hiddenItems,
+        eternalStage: state.eternalStage
       }
     ),
     director ? /* @__PURE__ */ jsx(FleetPanel, { entries: state.fleet, totalCost: state.fleetCost, roster: fleetRoster }) : null
@@ -4639,13 +4857,16 @@ async function runTui(opts) {
           getYolo: opts.getYolo,
           getAutonomy: opts.getAutonomy,
           getEternalEngine: opts.getEternalEngine,
+          getParallelEngine: opts.getParallelEngine,
           subscribeEternalIteration: opts.subscribeEternalIteration,
+          subscribeEternalStage: opts.subscribeEternalStage,
           appVersion: opts.appVersion,
           provider: opts.provider,
           family: opts.family,
           keyTail: opts.keyTail,
           getPickableProviders: opts.getPickableProviders,
           switchProviderAndModel: opts.switchProviderAndModel,
+          switchAutonomy: opts.switchAutonomy,
           effectiveMaxContext: opts.effectiveMaxContext,
           onExit,
           director: opts.director ?? null,