@wrongstack/tui 0.6.0 → 0.6.3

package/dist/index.d.ts

@@ -1,5 +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';
 
@@ -160,32 +161,4 @@ interface RunTuiOptions {
 }
 declare function runTui(opts: RunTuiOptions): Promise<number>;
 
-/**
- * `/goal <description>` preamble — the "no force can stop this" mode.
- *
- * Unlike STEERING (which redirects mid-flight), GOAL is a contract:
- * the user hands over a problem, the agent commits to verifiably
- * finishing it, and every iteration re-reads this preamble from the
- * conversation history. The hardening is entirely prompt-level —
- * the system has already removed implicit budget caps, so this
- * preamble's job is to remove the MODEL's tendency to hedge, ask
- * permission, or declare premature success.
- *
- * The four sections are intentional:
- *   1. AUTHORITY — explicit grant of unbounded fan-out + model
- *      switching. Without this the model self-throttles ("I shouldn't
- *      spawn too many…") even when budgets are unlimited.
- *   2. DONE — concrete bar for completion. Forces a verifiable
- *      artifact (test passing, file written, bug re-run clean).
- *      Without this the model returns "I believe it's fixed" and
- *      counts that as done.
- *   3. NOT DONE — explicit anti-patterns. Each item is something we
- *      saw real agents do as a "completion" that wasn't.
- *   4. PERSISTENCE — three-angle rule for blockers. Stops the model
- *      from giving up on the first tool failure.
- *
- * Exported for the test that pins the structural guarantees.
- */
-declare function buildGoalPreamble(goal: string): string;
-
-export { type RunTuiOptions, buildGoalPreamble, runTui };
+export { type RunTuiOptions, runTui };

package/dist/index.js

@@ -2,7 +2,8 @@ import { render, useApp, Box, useStdout, Static, Text, useInput, useStdin } from
 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';
@@ -2702,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,
@@ -3594,6 +3526,34 @@ function App({
       offRewound();
     };
   }, [events, onClearHistory]);
+  useEffect(() => {
+    const offFired = events.on("compaction.fired", (e) => {
+      const { level, tokens, load, maxContext: maxContext2, report, aggressive } = e;
+      const pct = (load * 100).toFixed(0);
+      const before = report.before;
+      const after = report.after;
+      const saved = before - after;
+      const table = [
+        `\u25B8 context compacted at ${level} (${pct}% of ${maxContext2.toLocaleString()} tok)`,
+        `  tokens before  ${before.toLocaleString().padStart(8)}`,
+        `  tokens after   ${after.toLocaleString().padStart(8)}`,
+        `  saved         ${saved.toLocaleString().padStart(8)}  (${(saved / before * 100).toFixed(1)}%)`
+      ];
+      for (const line of table) {
+        dispatch({ type: "addEntry", entry: { kind: "info", text: line } });
+      }
+    });
+    const offFailed = events.on("compaction.failed", (e) => {
+      const { level, load, maxContext: maxContext2, fatal } = e;
+      const pct = (load * 100).toFixed(0);
+      const text = fatal ? `\u2717 compaction failed at ${level} (${pct}% of ${maxContext2.toLocaleString()} tok) \u2014 FATAL` : `\u26A0 compaction failed at ${level} (${pct}% of ${maxContext2.toLocaleString()} tok) \u2014 continuing`;
+      dispatch({ type: "addEntry", entry: { kind: fatal ? "error" : "warn", text } });
+    });
+    return () => {
+      offFired();
+      offFailed();
+    };
+  }, [events]);
   useEffect(() => {
     if (!fleetStreamController) return;
     fleetStreamController.enabled = state.streamFleet;
@@ -3691,6 +3651,9 @@ function App({
         case "iteration.started":
           dispatch({ type: "fleetStart", id: e.subagentId });
           break;
+        case "session.started":
+          dispatch({ type: "fleetStart", id: e.subagentId });
+          break;
         case "provider.text_delta": {
           const p = e.payload;
           if (p?.text) {
@@ -3703,6 +3666,37 @@ function App({
           }
           break;
         }
+        case "provider.thinking_delta": {
+          const p = e.payload;
+          if (p?.text) {
+            streamBuf.set(e.subagentId, (streamBuf.get(e.subagentId) ?? "") + p.text);
+            if (streamFlushTimer) clearTimeout(streamFlushTimer);
+            streamFlushTimer = setTimeout(flushStreamBufs, FLUSH_MS * 4);
+          }
+          break;
+        }
+        case "provider.retry": {
+          const p = e.payload;
+          dispatch({
+            type: "addEntry",
+            entry: {
+              kind: "warn",
+              text: `subagent retry ${p?.attempt ?? "?"}${p?.delayMs ? ` (${p.delayMs}ms)` : ""}`
+            }
+          });
+          break;
+        }
+        case "provider.error": {
+          const p = e.payload;
+          dispatch({
+            type: "addEntry",
+            entry: {
+              kind: "error",
+              text: `subagent error${p?.description ? `: ${p.description}` : ""}`
+            }
+          });
+          break;
+        }
         case "tool.started": {
           const p = e.payload;
           if (p?.name) {
@@ -3728,6 +3722,37 @@ function App({
           dispatch({ type: "fleetCost", cost: d.snapshot().total.cost });
           break;
         }
+        case "session.ended":
+          break;
+        case "compaction.fired":
+          dispatch({
+            type: "addEntry",
+            entry: { kind: "info", text: "subagent compaction triggered" }
+          });
+          break;
+        case "compaction.failed":
+          dispatch({
+            type: "addEntry",
+            entry: { kind: "warn", text: "subagent compaction failed" }
+          });
+          break;
+        case "token.threshold":
+          dispatch({
+            type: "addEntry",
+            entry: { kind: "info", text: "subagent token threshold reached" }
+          });
+          break;
+        case "budget.threshold_reached": {
+          const p = e.payload;
+          dispatch({
+            type: "fleetBudgetWarning",
+            id: e.subagentId,
+            kind: p?.kind ?? "unknown",
+            used: p?.used ?? 0,
+            limit: p?.limit ?? 0
+          });
+          break;
+        }
       }
     });
     const offDone = d.on("task.completed", (payload) => {
@@ -4662,6 +4687,6 @@ async function runTui(opts) {
   });
 }
 
-export { buildGoalPreamble, runTui };
+export { runTui };
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map