wotann 0.5.86 → 0.5.87

package/dist/core/runtime-agent-loop.d.ts

@@ -36,8 +36,48 @@ export interface ToolResultEvent {
     readonly toolName: string;
     readonly result: string;
 }
-export type RunAgentControlEvent = IterationStartEvent | ToolResultEvent;
+/**
+ * Emitted at an iteration boundary after the loop drained one or more
+ * user-side redirects (Hermes Gap 2 — interrupt-and-redirect). UI
+ * consumers can render a system bubble showing the redirected text so
+ * the user has visual confirmation the directive landed. The redirect
+ * is ALREADY appended to context by the loop before this event fires;
+ * receivers MUST NOT re-append it themselves.
+ */
+export interface RedirectReceivedEvent {
+    readonly kind: "redirect_received";
+    readonly count: number;
+    readonly messages: readonly string[];
+}
+export type RunAgentControlEvent = IterationStartEvent | ToolResultEvent | RedirectReceivedEvent;
 export type AgentEvent = StreamChunk | RunAgentControlEvent;
+/**
+ * Channel for user-side redirects (Hermes Gap 2). The TUI / RPC client
+ * pushes messages when the user sends a new directive WHILE the agent
+ * is streaming. The runAgent loop drains at each iteration boundary
+ * and appends them to context as new user turns, so the model absorbs
+ * the directive on the next turn — no context loss, no abort needed.
+ *
+ * Implementations MUST be safe to call concurrently (push from the
+ * UI thread, drain from the loop's async generator).
+ */
+export interface RedirectChannel {
+    /** Drain all pending redirects. Returns empty array when none queued. */
+    drain(): readonly string[];
+}
+/**
+ * Default in-memory channel. Pushes are appended to a queue; drain
+ * empties the queue atomically. The queue ignores empty-string pushes
+ * so an accidental Ctrl+R on an empty composer doesn't inject a blank
+ * user turn into the model context.
+ */
+export declare class InMemoryRedirectChannel implements RedirectChannel {
+    private queue;
+    push(message: string): void;
+    drain(): readonly string[];
+    /** Snapshot of pending count — for status-bar indicators. Read-only. */
+    get pending(): number;
+}
 export interface RunAgentOptions {
     readonly prompt: string;
     readonly images?: readonly string[];
@@ -49,6 +89,14 @@ export interface RunAgentOptions {
     readonly signal?: AbortSignal;
     readonly guardrails?: readonly GuardrailCheck[];
     readonly guardrailContext?: GuardrailContext;
+    /**
+     * Optional user-redirect channel. When provided, the loop drains
+     * pending messages BEFORE each iteration's query and appends them
+     * to context as new user turns. Lets the user redirect a streaming
+     * agent without losing context (Hermes Gap 2). See
+     * {@link InMemoryRedirectChannel} for the default implementation.
+     */
+    readonly redirectChannel?: RedirectChannel;
     readonly query: (o: WotannQueryOptions) => AsyncGenerator<StreamChunk>;
     readonly executeTool: (name: string, input: Record<string, unknown>) => Promise<string>;
 }

package/dist/core/runtime-agent-loop.js

@@ -1,5 +1,31 @@
 import { evaluateGuardrails, } from "../guardrails/tripwire.js";
-import { IntelligenceAmplifier, updateDoomLoopState } from "../intelligence/amplifier.js";
+import { IntelligenceAmplifier, updateDoomLoopState, } from "../intelligence/amplifier.js";
+/**
+ * Default in-memory channel. Pushes are appended to a queue; drain
+ * empties the queue atomically. The queue ignores empty-string pushes
+ * so an accidental Ctrl+R on an empty composer doesn't inject a blank
+ * user turn into the model context.
+ */
+export class InMemoryRedirectChannel {
+    queue = [];
+    push(message) {
+        const trimmed = message.trim();
+        if (trimmed.length === 0)
+            return;
+        this.queue.push(trimmed);
+    }
+    drain() {
+        if (this.queue.length === 0)
+            return [];
+        const out = this.queue;
+        this.queue = [];
+        return out;
+    }
+    /** Snapshot of pending count — for status-bar indicators. Read-only. */
+    get pending() {
+        return this.queue.length;
+    }
+}
 export async function* runAgent(opts) {
     const maxIterations = opts.maxIterations ?? 8;
     const guardrails = opts.guardrails ?? [];
@@ -20,6 +46,22 @@ export async function* runAgent(opts) {
     while (iteration < maxIterations) {
         iteration++;
         yield { kind: "iteration_start", iteration };
+        // Hermes Gap 2 — drain user-side redirects BEFORE this iteration's
+        // query. Each pending message becomes a new user turn appended to
+        // context, so the model sees the directive on its next turn. No
+        // abort, no context loss. We emit a `redirect_received` control
+        // event so UI consumers can render a system breadcrumb.
+        if (opts.redirectChannel !== undefined) {
+            const pending = opts.redirectChannel.drain();
+            if (pending.length > 0) {
+                const next = [...context];
+                for (const msg of pending) {
+                    next.push({ role: "user", content: msg });
+                }
+                context = next;
+                yield { kind: "redirect_received", count: pending.length, messages: pending };
+            }
+        }
         let fullContent = "";
         let model;
         let provider;

package/dist/ui/components/v3/AppV3.js

@@ -41,7 +41,7 @@ import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "#wotann-jsx/j
  */
 import { useCallback, useEffect, useMemo, useRef, useState } from "react";
 import { Box, Text, useInput } from "ink";
-import { runAgent } from "../../../core/runtime-agent-loop.js";
+import { InMemoryRedirectChannel, runAgent } from "../../../core/runtime-agent-loop.js";
 import { buildAgentToolContext } from "../../../core/agent-tool-context.js";
 import { AGENT_TOOL_DEFINITIONS, executeAgentTool } from "../../../tools/agent-tools.js";
 import { ThemeProvider, useThemeTone } from "../../theme/context.js";
@@ -217,6 +217,13 @@ function AppV3Inner({ providers, initialModel, initialProvider, messages, isStre
     const [transcriptScrollOffset, setTranscriptScrollOffset] = useState(0);
     const activeRunRef = useRef(null);
     const sideActiveRunRef = useRef(null);
+    // Hermes Gap 2 — interrupt-and-redirect: persistent channel for the
+    // host composer's mid-stream redirects. Ctrl+R captures the current
+    // draft and pushes it here; runAgent's iteration loop drains pending
+    // redirects at the next iteration boundary and appends them to
+    // context as new user turns. One channel per AppV3Inner instance so
+    // pending redirects survive within a session.
+    const redirectChannelRef = useRef(new InMemoryRedirectChannel());
     const [sidePaneDraft, setSidePaneDraft] = useState("");
     const [nowMs, setNowMs] = useState(() => Date.now());
     useEffect(() => {
@@ -241,6 +248,16 @@ function AppV3Inner({ providers, initialModel, initialProvider, messages, isStre
     // composer is empty so we don't intercept the dot from a typed
     // slash-command argument or filename.
     useInput((input, key) => {
+        // Hermes Gap 2 — Ctrl+R: queue the composer draft as a mid-stream
+        // redirect. ONLY fires when the agent is currently streaming AND
+        // the draft has non-whitespace content. The channel's drain runs
+        // at the next iteration boundary, so the user sees a system
+        // "redirect queued" bubble within ~1 turn.
+        if (key.ctrl && input === "r" && isStreaming && draftValue.trim().length > 0) {
+            redirectChannelRef.current.push(draftValue);
+            setDraftValue("");
+            return;
+        }
         if (key.ctrl && (input === "k" || input === "p")) {
             overlay.open("palette");
             return;
@@ -342,6 +359,7 @@ function AppV3Inner({ providers, initialModel, initialProvider, messages, isStre
                     provider: initialProvider || undefined,
                     tools: AGENT_TOOL_DEFINITIONS,
                     signal: abortController.signal,
+                    redirectChannel: redirectChannelRef.current,
                     query: (o) => runtime.query(o),
                     executeTool: (name, input) => executeAgentTool(name, input, buildAgentToolContext(runtime, {
                         workingDir: runtime.getWorkingDir(),
@@ -362,6 +380,20 @@ function AppV3Inner({ providers, initialModel, initialProvider, messages, isStre
                                 },
                             ]);
                         }
+                        else if (ev.kind === "redirect_received") {
+                            // Hermes Gap 2 — UI breadcrumb so user sees the directive
+                            // landed. The loop already appended it to context; we
+                            // ONLY render here (do NOT push to context again).
+                            for (const message of ev.messages) {
+                                setMessages((prev) => [
+                                    ...prev,
+                                    {
+                                        role: "system",
+                                        content: `↳ redirect queued: ${message}`,
+                                    },
+                                ]);
+                            }
+                        }
                         continue;
                     }
                     if (ev.type === "text" && ev.content.length > 0) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "wotann",
-  "version": "0.5.86",
+  "version": "0.5.87",
   "description": "WOTANN — The All-Father of AI Agent Harnesses",
   "type": "module",
   "main": "dist/index.js",