@wrongstack/tui 0.6.4 → 0.6.5

package/dist/index.d.ts

@@ -31,13 +31,19 @@ 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

package/dist/index.js

@@ -2718,6 +2718,7 @@ function App({
   getYolo,
   getAutonomy,
   getEternalEngine,
+  getParallelEngine,
   subscribeEternalIteration,
   getSDDContext,
   onSDDOutput,
@@ -3471,6 +3472,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 +3480,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 +3516,7 @@ function App({
       offStarted();
       offCompleted();
       offBudgetWarning();
+      offIterationSummary();
       offTool();
     };
   }, [events, director]);
@@ -4111,6 +4129,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 +4299,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) => {
@@ -4317,6 +4380,9 @@ function App({
           if (currentAutonomy === "eternal" && getEternalEngine) {
             void runEternalLoopRef.current();
           }
+          if (currentAutonomy === "eternal-parallel" && getParallelEngine) {
+            void runParallelLoopRef.current();
+          }
         }
         if (res?.exit) {
           exit();
@@ -4639,6 +4705,7 @@ async function runTui(opts) {
           getYolo: opts.getYolo,
           getAutonomy: opts.getAutonomy,
           getEternalEngine: opts.getEternalEngine,
+          getParallelEngine: opts.getParallelEngine,
           subscribeEternalIteration: opts.subscribeEternalIteration,
           appVersion: opts.appVersion,
           provider: opts.provider,