@wrongstack/tui 0.5.7 → 0.6.1

package/dist/index.d.ts

@@ -1,4 +1,6 @@
+import * as _wrongstack_core from '@wrongstack/core';
 import { Agent, SlashCommandRegistry, AttachmentStore, EventBus, TokenCounter, QueueStore, Director } from '@wrongstack/core';
+export { buildGoalPreamble } from '@wrongstack/core';
 import { VisionAdapters } from '@wrongstack/runtime/vision';
 import React from 'react';
 
@@ -29,7 +31,19 @@ interface RunTuiOptions {
     /** Query live YOLO state from the permission policy. */
     getYolo?: () => boolean;
     /** Query the live autonomy mode. */
-    getAutonomy?: () => 'off' | 'suggest' | 'auto';
+    getAutonomy?: () => 'off' | 'suggest' | 'auto' | 'eternal';
+    /**
+     * 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;
+    /**
+     * 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;
     /** Renders in the startup banner. Read from the CLI's package.json. */
     appVersion?: string;
     /** Provider id for the startup banner ("openai", "anthropic", ...). */
@@ -88,6 +102,12 @@ interface RunTuiOptions {
     fleetRoster?: Record<string, {
         name: string;
     }>;
+    /**
+     * Shared controller for the `/fleet stream on|off` toggle. The slash
+     * command runs in the CLI process and needs to flip TUI reducer state;
+     * the App installs a dispatch-backed `setEnabled` here on mount so
+     * both sides stay synchronized.
+     */
     /**
      * Shared controller for the `/fleet stream on|off` toggle. The slash
      * command runs in the CLI process and needs to flip TUI reducer state;
@@ -98,6 +118,14 @@ interface RunTuiOptions {
         enabled: boolean;
         setEnabled: (enabled: boolean) => void;
     };
+    /**
+     * Controller for status bar hidden items. App installs a dispatch-backed
+     * setter on mount so the /statusline slash command can update the TUI's
+     * visible bar without a round-trip. The initial value is loaded from
+     * the config file before App mounts.
+     */
+    statuslineHiddenItems: Array<'todos' | 'plan' | 'fleet' | 'git' | 'elapsed' | 'context' | 'cost'>;
+    setStatuslineHiddenItems: (items: Array<'todos' | 'plan' | 'fleet' | 'git' | 'elapsed' | 'context' | 'cost'>) => void;
     /**
      * If set, the App boots straight into goal mode — the text is wrapped
      * in the GOAL preamble and submitted as the first turn. Lets users

package/dist/index.js

@@ -1,8 +1,9 @@
 import { render, useApp, Box, useStdout, Static, Text, useInput, useStdin } from 'ink';
-import React2, { useState, useReducer, useRef, useEffect, useMemo } from 'react';
+import React2, { useState, useEffect, useReducer, useRef, useMemo } from 'react';
 import * as fs2 from 'fs/promises';
 import * as path2 from 'path';
-import { InputBuilder, DefaultSessionRewinder, formatTodosList, buildChildEnv } from '@wrongstack/core';
+import { InputBuilder, DefaultSessionRewinder, formatTodosList, buildGoalPreamble, buildChildEnv } from '@wrongstack/core';
+export { buildGoalPreamble } from '@wrongstack/core';
 import { routeImagesForModel } from '@wrongstack/runtime/vision';
 import { getProcessRegistry } from '@wrongstack/tools';
 import { readClipboardImage } from '@wrongstack/runtime/clipboard';
@@ -1632,8 +1633,10 @@ function StatusBar({
   subagentCount = 0,
   context,
   projectName,
-  processCount
+  processCount,
+  hiddenItems
 }) {
+  const hiddenSet = new Set(hiddenItems);
   const usage = tokenCounter?.total();
   const cost = tokenCounter?.estimateCost();
   const cache2 = tokenCounter?.cacheStats();
@@ -1715,12 +1718,19 @@ function StatusBar({
           yolo ? /* @__PURE__ */ jsx(Text, { color: "red", bold: true, children: "\u26A0 YOLO" }) : null,
           autonomy && autonomy !== "off" ? /* @__PURE__ */ jsxs(Fragment, { children: [
             yolo ? /* @__PURE__ */ jsx(Text, { dimColor: true, children: "\u2502" }) : null,
-            /* @__PURE__ */ jsxs(Text, { color: autonomy === "auto" ? "yellow" : "cyan", bold: true, children: [
-              "\u221E ",
-              autonomy.toUpperCase()
-            ] })
+            /* @__PURE__ */ jsxs(
+              Text,
+              {
+                color: autonomy === "eternal" ? "red" : autonomy === "auto" ? "yellow" : "cyan",
+                bold: true,
+                children: [
+                  "\u221E ",
+                  autonomy.toUpperCase()
+                ]
+              }
+            )
           ] }) : null,
-          elapsedMs !== void 0 ? /* @__PURE__ */ jsxs(Fragment, { children: [
+          elapsedMs !== void 0 && !hiddenSet.has("elapsed") ? /* @__PURE__ */ jsxs(Fragment, { children: [
             yolo ? /* @__PURE__ */ jsx(Text, { dimColor: true, children: "\u2502" }) : null,
             /* @__PURE__ */ jsxs(Text, { dimColor: true, children: [
               "\u23F1 ",
@@ -2693,75 +2703,6 @@ function buildSteeringPreamble(snapshot, newDirection) {
   lines.push("]");
   return lines.join("\n");
 }
-function buildGoalPreamble(goal) {
-  return [
-    "[GOAL \u2014 LOCKED IN. You will work on this until it is verifiably done.",
-    "The user granted you full autonomy. Read these constraints once, then act.",
-    "",
-    "YOUR GOAL:",
-    "---",
-    goal,
-    "---",
-    "",
-    "AUTHORITY YOU HAVE:",
-    "- Spawn as many subagents as the work needs (delegate / spawn_subagent).",
-    "  Parallel + recursive fan-out are both fine. There is no spawn budget.",
-    "- Use any provider/model per subagent \u2014 pick the right tool for each",
-    "  piece of work. Heavy reasoning model for planning, fast model for",
-    "  batch work, specialist model for domain code.",
-    "- Run unlimited tool calls and iterations. There is NO hidden budget.",
-    "  The Agent loop auto-extends every 100 iterations forever.",
-    "- Retry failed tools with different inputs, alternative paths, fresh",
-    "  subagents. Switch providers mid-run if one is rate-limited.",
-    "- Re-plan freely when an approach hits a dead end. You are not obliged",
-    "  to stick with the first plan you proposed.",
-    "",
-    'WHAT "DONE" MEANS \u2014 non-negotiable:',
-    "- You can name a concrete artifact (a passing test, a written file at",
-    "  a specific path, a fixed bug verified by re-running the failing case,",
-    "  a clean grep that previously had matches).",
-    "- You can tell the user HOW to verify it themselves in 10 seconds.",
-    '- You have NOT hedged. None of: "looks like it should work", "I',
-    '  believe this fixes it", "the changes appear correct".',
-    "",
-    "WHAT IS NOT DONE \u2014 never report any of these as completion:",
-    "- An error message you didn't recover from.",
-    '- An empty result, a 0-line file, a "no matches found" you accepted',
-    "  without questioning the search.",
-    '- "Should I continue?" / "Want me to also...?" / "Let me know if you',
-    '  want X." Those are hedges. The user already told you to finish the',
-    "  goal \u2014 just do it.",
-    "- Partial progress dressed up as success. Fixed 3 of 5 bugs = 60%",
-    "  done, not done.",
-    "- A subagent's failed/timeout/stopped TaskResult that you didn't",
-    "  respond to with a fresh attempt (different role, different model,",
-    "  tighter prompt).",
-    "",
-    "PERSISTENCE PROTOCOL:",
-    "- If blocked, try at least 3 different angles before reporting the",
-    "  problem to the user. Different tool inputs, different subagent",
-    "  roles, different providers, different decomposition of the task.",
-    "- If a tool fails, read its error, alter the input, try again. Do",
-    "  not just report the failure back.",
-    "- If a subagent returns useless output, respawn with a tighter prompt",
-    '  or a different role. Do not accept "I could not determine\u2026" as the',
-    "  final answer.",
-    "- Use `ask_subagent` for one-shot questions when you don't need a",
-    "  full delegated task.",
-    "",
-    "REPORTING:",
-    "- Stream short progress notes between major actions so the user can",
-    "  monitor. Do not go silent for 50 tool calls then dump a wall of",
-    "  text \u2014 but also do not narrate every tool call.",
-    "- Use the shared scratchpad (if available) to leave breadcrumbs",
-    "  subagents can read.",
-    "- Final response must include: (a) what was accomplished, (b) how",
-    "  to verify, (c) any caveats (residual TODOs, things the user",
-    "  should know about).",
-    "",
-    "BEGIN.]"
-  ].join("\n");
-}
 function App({
   agent,
   slashRegistry,
@@ -2776,6 +2717,8 @@ function App({
   yolo = false,
   getYolo,
   getAutonomy,
+  getEternalEngine,
+  subscribeEternalIteration,
   getSDDContext,
   onSDDOutput,
   appVersion,
@@ -2790,6 +2733,8 @@ function App({
   fleetRoster,
   onClearHistory,
   fleetStreamController,
+  statuslineHiddenItems,
+  setStatuslineHiddenItems,
   initialGoal,
   initialAsk,
   sessionsDir
@@ -2799,6 +2744,13 @@ function App({
   const [liveProvider, setLiveProvider] = useState(provider ?? "agent");
   const [yoloLive, setYoloLive] = useState(yolo);
   const [autonomyLive, setAutonomyLive] = useState(getAutonomy?.() ?? "off");
+  const [hiddenItems, setHiddenItems] = useState(statuslineHiddenItems);
+  useEffect(() => {
+    setHiddenItems(statuslineHiddenItems);
+  }, [statuslineHiddenItems]);
+  useEffect(() => {
+    setStatuslineHiddenItems(hiddenItems);
+  }, [setStatuslineHiddenItems]);
   const [state, dispatch] = useReducer(reducer, {
     entries: banner ? [
       {
@@ -3313,39 +3265,6 @@ function App({
       slashRegistry.unregister("rewind");
     };
   }, [slashRegistry, handleRewindTo]);
-  useEffect(() => {
-    const cmd = {
-      name: "goal",
-      description: "Lock in a goal \u2014 no budgets, no hedging, no premature done. /goal <description>",
-      help: [
-        "Usage: /goal <description>",
-        "",
-        "Hands the agent a task it must drive to a verifiable finish.",
-        "Adds a preamble to the next turn that grants full autonomy",
-        "(unlimited subagents, any provider/model, retry-until-it-works),",
-        'spells out what "done" actually means, and forbids hedge-style',
-        'completions ("I believe this works", "should I continue?").',
-        "",
-        "Combine with /steer to redirect mid-goal, or Ctrl+C / /fleet kill",
-        "to bail out \u2014 only the user can stop a /goal."
-      ].join("\n"),
-      async run(args) {
-        const goal = args.trim();
-        if (!goal) return { message: "Usage: /goal <description>" };
-        const preamble = buildGoalPreamble(goal);
-        const shortGoal = goal.length > 80 ? `${goal.slice(0, 80)}\u2026` : goal;
-        return {
-          message: `\u{1F3AF} Goal locked: ${shortGoal}
-   Agent will work until verifiably complete. Esc / /steer to redirect, Ctrl+C to stop.`,
-          runText: preamble
-        };
-      }
-    };
-    slashRegistry.register(cmd);
-    return () => {
-      slashRegistry.unregister("goal");
-    };
-  }, [slashRegistry]);
   useEffect(() => {
     if (!getPickableProviders || !switchProviderAndModel) return;
     const cmd = {
@@ -4224,6 +4143,46 @@ function App({
   };
   const runBlocksRef = useRef(runBlocks);
   runBlocksRef.current = runBlocks;
+  const runEternalLoop = async () => {
+    const engine = getEternalEngine?.();
+    if (!engine) return;
+    if (eternalLoopRunningRef.current) return;
+    eternalLoopRunningRef.current = true;
+    try {
+      while (true) {
+        const liveMode = getAutonomy?.() ?? "off";
+        if (liveMode !== "eternal") break;
+        if (engine.currentState === "stopped") break;
+        dispatch({ type: "status", status: "running" });
+        try {
+          await engine.runOneIteration();
+        } catch (err) {
+          dispatch({
+            type: "addEntry",
+            entry: { kind: "error", text: `[eternal] ${err instanceof Error ? err.message : String(err)}` }
+          });
+        }
+        dispatch({ type: "status", status: "idle" });
+        await new Promise((r) => setTimeout(r, 200));
+      }
+    } finally {
+      eternalLoopRunningRef.current = false;
+    }
+  };
+  const eternalLoopRunningRef = useRef(false);
+  const runEternalLoopRef = useRef(runEternalLoop);
+  runEternalLoopRef.current = runEternalLoop;
+  useEffect(() => {
+    if (!subscribeEternalIteration) return;
+    const unsub = subscribeEternalIteration((entry) => {
+      const mark = entry.status === "success" ? "\u2713" : entry.status === "failure" ? "\u2717" : entry.status === "aborted" ? "\u2298" : "\xB7";
+      const cost = typeof entry.costUsd === "number" ? ` ($${entry.costUsd.toFixed(4)})` : "";
+      const note = entry.note ? ` \u2014 ${entry.note.slice(0, 80)}` : "";
+      const text = `#${entry.iteration} ${mark} [${entry.source}] ${entry.task}${cost}${note}`;
+      dispatch({ type: "addEntry", entry: { kind: "info", text } });
+    });
+    return unsub;
+  }, [subscribeEternalIteration]);
   const submit = async (overrideRaw) => {
     const raw = overrideRaw ?? draftRef.current.buffer;
     const trimmed = raw.trim();
@@ -4258,6 +4217,9 @@ function App({
         if (getAutonomy) {
           const currentAutonomy = getAutonomy();
           if (currentAutonomy !== autonomyLive) setAutonomyLive(currentAutonomy);
+          if (currentAutonomy === "eternal" && getEternalEngine) {
+            void runEternalLoopRef.current();
+          }
         }
         if (res?.exit) {
           exit();
@@ -4450,7 +4412,8 @@ User message:
         context: contextWindow,
         projectName,
         subagentCount: Object.keys(state.fleet).length,
-        processCount: getProcessRegistry().activeCount
+        processCount: getProcessRegistry().activeCount,
+        hiddenItems
       }
     ),
     director ? /* @__PURE__ */ jsx(FleetPanel, { entries: state.fleet, totalCost: state.fleetCost, roster: fleetRoster }) : null
@@ -4578,6 +4541,8 @@ async function runTui(opts) {
           yolo: opts.yolo,
           getYolo: opts.getYolo,
           getAutonomy: opts.getAutonomy,
+          getEternalEngine: opts.getEternalEngine,
+          subscribeEternalIteration: opts.subscribeEternalIteration,
           appVersion: opts.appVersion,
           provider: opts.provider,
           family: opts.family,
@@ -4590,6 +4555,8 @@ async function runTui(opts) {
           fleetRoster: opts.fleetRoster,
           onClearHistory: opts.onClearHistory ? (dispatch) => opts.onClearHistory(dispatch) : void 0,
           fleetStreamController: opts.fleetStreamController,
+          statuslineHiddenItems: opts.statuslineHiddenItems,
+          setStatuslineHiddenItems: opts.setStatuslineHiddenItems,
           initialGoal: opts.initialGoal,
           initialAsk: opts.initialAsk,
           getSDDContext: opts.getSDDContext,