wotann 0.5.95 → 0.5.97

package/dist/verification/reproduction/index.js

@@ -0,0 +1,10 @@
+export { decideReproductionVerdict, } from "./verdict.js";
+export { checkDiff, DEFAULT_PROTECTED_PATTERNS, } from "./diff-checker.js";
+export { runReplay, } from "./replay-runner.js";
+export { buildProofArtifact } from "./proof-artifact.js";
+export { gateMutation, runMutationGate, DEFAULT_MUTATION_THRESHOLD, } from "./mutation-gate.js";
+export { enforceReproductionVerdict, } from "./enforcement.js";
+export { reproduceRun, } from "./reproduce.js";
+export { buildExecReplayRunner } from "./exec-runner.js";
+export { prepareVerifierCheckout, buildExecGitRunner, } from "./checkout-prep.js";
+export { reproduceAutonomousRun, runWorkspaceReproduction, } from "./autonomous-gate.js";

package/dist/verification/reproduction/mutation-gate.d.ts

@@ -0,0 +1,42 @@
+/**
+ * Mutation gate (BenchJack V6 defense): a green test run is worthless if the
+ * tests have no real assertions ("100% coverage, 0% mutation score"). Mutate
+ * the changed code; if the agent's OWN tests don't kill enough mutants,
+ * downgrade a "reproduced" verdict to "weak-tests".
+ *
+ * The gate DECISION is pure. Running the mutation tool (Stryker/mutmut) inside
+ * the verifier box is the injected `MutationRunner` (production wiring deferred,
+ * same DI pattern as replay-runner / vm-isolation).
+ */
+export interface MutationResult {
+    readonly killed: number;
+    readonly total: number;
+}
+export interface MutationGateResult {
+    readonly weakTests: boolean;
+    readonly score: number;
+    readonly threshold: number;
+    readonly reason?: string;
+}
+export declare const DEFAULT_MUTATION_THRESHOLD = 0.6;
+/**
+ * Pure. `total <= 0` means no mutants were generated — the tests do not
+ * exercise the changed code at all — which is the worst case, so it is `weak`.
+ */
+export declare function gateMutation(result: MutationResult, threshold?: number): MutationGateResult;
+/** Injected runner (DI like replay-runner). Production wires Stryker/mutmut; tests stub. */
+export interface MutationRunner {
+    readonly probe: () => Promise<{
+        ok: boolean;
+        reason?: string;
+    }>;
+    readonly run: (dir: string, changedFiles: readonly string[]) => Promise<MutationResult>;
+}
+/**
+ * Honest stub: a failed probe means the mutation tool is unavailable. Mutation
+ * testing is a BONUS downgrade (the reproduction channel carries enforcement),
+ * so "unavailable" does NOT set `weakTests` — it just records why it was skipped.
+ */
+export declare function runMutationGate(dir: string, changedFiles: readonly string[], runner: MutationRunner, threshold?: number): Promise<MutationGateResult & {
+    readonly unavailable?: string;
+}>;

package/dist/verification/reproduction/mutation-gate.js

@@ -0,0 +1,43 @@
+export const DEFAULT_MUTATION_THRESHOLD = 0.6;
+/**
+ * Pure. `total <= 0` means no mutants were generated — the tests do not
+ * exercise the changed code at all — which is the worst case, so it is `weak`.
+ */
+export function gateMutation(result, threshold = DEFAULT_MUTATION_THRESHOLD) {
+    if (result.total <= 0) {
+        return {
+            weakTests: true,
+            score: 0,
+            threshold,
+            reason: "no mutants generated — tests do not exercise the changed code",
+        };
+    }
+    const score = result.killed / result.total;
+    if (score < threshold) {
+        return {
+            weakTests: true,
+            score,
+            threshold,
+            reason: `mutation score ${score.toFixed(2)} < threshold ${threshold}`,
+        };
+    }
+    return { weakTests: false, score, threshold };
+}
+/**
+ * Honest stub: a failed probe means the mutation tool is unavailable. Mutation
+ * testing is a BONUS downgrade (the reproduction channel carries enforcement),
+ * so "unavailable" does NOT set `weakTests` — it just records why it was skipped.
+ */
+export async function runMutationGate(dir, changedFiles, runner, threshold = DEFAULT_MUTATION_THRESHOLD) {
+    const probe = await runner.probe();
+    if (!probe.ok) {
+        return {
+            weakTests: false,
+            score: 0,
+            threshold,
+            unavailable: `mutation:unavailable${probe.reason ? `:${probe.reason}` : ""}`,
+        };
+    }
+    const result = await runner.run(dir, changedFiles);
+    return gateMutation(result, threshold);
+}

package/dist/verification/reproduction/proof-artifact.d.ts

@@ -0,0 +1,16 @@
+import { type ChainExport } from "../../security/hash-audit-chain.js";
+import type { ReproductionResult, ReproductionVerdict, ClaimedChecks, ObservedChecks } from "./verdict.js";
+/**
+ * The verdict is a first-class, hash-chained, harness-signed PROOF ARTIFACT —
+ * not a bare boolean. `chainExport` is tamper-evident (SHA-256 linked); any
+ * post-hoc edit to the recorded verdict/observed breaks `HashAuditChain.verify()`.
+ */
+export interface ProofArtifact {
+    readonly verdict: ReproductionVerdict;
+    readonly diffCid: string;
+    readonly claimed: ClaimedChecks;
+    readonly observed: ObservedChecks;
+    readonly contradictions: readonly string[];
+    readonly chainExport: ChainExport;
+}
+export declare function buildProofArtifact(result: ReproductionResult, diffText: string, actor?: string): ProofArtifact;

package/dist/verification/reproduction/proof-artifact.js

@@ -0,0 +1,22 @@
+import { HashAuditChain } from "../../security/hash-audit-chain.js";
+import { cidOf } from "../../core/content-cid.js";
+export function buildProofArtifact(result, diffText, actor = "wotann-verifier") {
+    const diffCid = cidOf(diffText);
+    const chain = new HashAuditChain();
+    chain.append("reproduction.verdict", actor, {
+        verdict: result.verdict,
+        diffCid,
+        claimed: result.claimed,
+        observed: result.observed,
+        contradictions: result.contradictions,
+        ...(result.infraError ? { infraError: result.infraError } : {}),
+    });
+    return {
+        verdict: result.verdict,
+        diffCid,
+        claimed: result.claimed,
+        observed: result.observed,
+        contradictions: result.contradictions,
+        chainExport: chain.exportChain(),
+    };
+}

package/dist/verification/reproduction/replay-runner.d.ts

@@ -0,0 +1,37 @@
+import type { ObservedChecks } from "./verdict.js";
+/**
+ * Structural runner (mirrors VmRunner in computer-use/vm-isolation.ts). Tests
+ * inject an in-memory stub; production wires this to run argv INSIDE the
+ * verifier box (container/sandbox = the separate trust boundary). Argv-only,
+ * never a shell string — no interpolation.
+ */
+export interface ReplayRunner {
+    readonly probe: () => Promise<{
+        ok: boolean;
+        reason?: string;
+    }>;
+    readonly runInDir: (dir: string, argv: readonly string[]) => Promise<{
+        exitCode: number;
+        stdout: string;
+        stderr: string;
+    }>;
+}
+export interface ReplayCommands {
+    readonly test?: readonly string[];
+    readonly typecheck?: readonly string[];
+    readonly lint?: readonly string[];
+}
+export interface ReplayInput {
+    /** The clean, applied-diff checkout in the verifier box (separate trust boundary). */
+    readonly checkoutDir: string;
+    readonly commands: ReplayCommands;
+}
+/**
+ * Re-run the claimed commands in the verifier box and report the HARNESS's own
+ * pass/fail (exit code 0 = pass). NEVER reads the agent's self-reported result.
+ * Honest stub: a failed probe yields all-null observed + infraError, so the
+ * verdict logic emits `infra-error` and never auto-passes.
+ */
+export declare function runReplay(input: ReplayInput, runner: ReplayRunner): Promise<ObservedChecks & {
+    readonly infraError?: string;
+}>;

package/dist/verification/reproduction/replay-runner.js

@@ -0,0 +1,28 @@
+/**
+ * Re-run the claimed commands in the verifier box and report the HARNESS's own
+ * pass/fail (exit code 0 = pass). NEVER reads the agent's self-reported result.
+ * Honest stub: a failed probe yields all-null observed + infraError, so the
+ * verdict logic emits `infra-error` and never auto-passes.
+ */
+export async function runReplay(input, runner) {
+    const probe = await runner.probe();
+    if (!probe.ok) {
+        return {
+            testsPass: null,
+            typecheckPass: null,
+            lintPass: null,
+            infraError: `replay:unavailable${probe.reason ? `:${probe.reason}` : ""}`,
+        };
+    }
+    const observe = async (argv) => {
+        if (!argv || argv.length === 0)
+            return null;
+        const r = await runner.runInDir(input.checkoutDir, argv);
+        return r.exitCode === 0;
+    };
+    return {
+        testsPass: await observe(input.commands.test),
+        typecheckPass: await observe(input.commands.typecheck),
+        lintPass: await observe(input.commands.lint),
+    };
+}

package/dist/verification/reproduction/reproduce.d.ts

@@ -0,0 +1,34 @@
+import { type TestAuthorship } from "./diff-checker.js";
+import { type ReplayRunner, type ReplayCommands } from "./replay-runner.js";
+import { type MutationRunner } from "./mutation-gate.js";
+import { type ClaimedChecks, type ReproductionResult } from "./verdict.js";
+import { type ProofArtifact } from "./proof-artifact.js";
+export interface ReproduceInput {
+    readonly claimed: ClaimedChecks;
+    /** Repo-relative POSIX paths the agent's diff touched. */
+    readonly changedPaths: readonly string[];
+    /** The clean, applied-diff checkout in the verifier box (separate trust boundary). */
+    readonly checkoutDir: string;
+    readonly commands: ReplayCommands;
+    /** The diff text (for the proof artifact's content identity). */
+    readonly diffText: string;
+    readonly authorship?: TestAuthorship;
+    /** Changed source files to mutation-test (Phase-B bonus gate). */
+    readonly mutationFiles?: readonly string[];
+}
+export interface ReproduceRunners {
+    readonly replay: ReplayRunner;
+    /** Optional — when present and the reproduction is clean, gates weak-tests. */
+    readonly mutation?: MutationRunner;
+}
+export interface ReproduceOutput {
+    readonly result: ReproductionResult;
+    readonly proof: ProofArtifact;
+}
+/**
+ * Compose the reproduction library into one call: tamper-check the diff, replay
+ * the claimed commands in the verifier box (capturing the harness's OWN result),
+ * optionally mutation-gate a clean reproduction, decide the verdict, and emit
+ * the hash-chained proof artifact. Pure orchestration over injected runners.
+ */
+export declare function reproduceRun(input: ReproduceInput, runners: ReproduceRunners): Promise<ReproduceOutput>;

package/dist/verification/reproduction/reproduce.js

@@ -0,0 +1,31 @@
+import { checkDiff } from "./diff-checker.js";
+import { runReplay } from "./replay-runner.js";
+import { runMutationGate } from "./mutation-gate.js";
+import { decideReproductionVerdict, } from "./verdict.js";
+import { buildProofArtifact } from "./proof-artifact.js";
+/**
+ * Compose the reproduction library into one call: tamper-check the diff, replay
+ * the claimed commands in the verifier box (capturing the harness's OWN result),
+ * optionally mutation-gate a clean reproduction, decide the verdict, and emit
+ * the hash-chained proof artifact. Pure orchestration over injected runners.
+ */
+export async function reproduceRun(input, runners) {
+    const diff = checkDiff(input.changedPaths, undefined, input.authorship);
+    const observed = await runReplay({ checkoutDir: input.checkoutDir, commands: input.commands }, runners.replay);
+    // The mutation gate is a BONUS downgrade — only meaningful on an otherwise
+    // clean reproduction (skip it when we already have tamper or infra-error).
+    let weakTests = false;
+    if (runners.mutation && !diff.tampered && !observed.infraError) {
+        const gate = await runMutationGate(input.checkoutDir, input.mutationFiles ?? [], runners.mutation);
+        weakTests = gate.weakTests;
+    }
+    const result = decideReproductionVerdict({
+        claimed: input.claimed,
+        observed,
+        tampered: diff.tampered,
+        weakTests,
+        infraError: observed.infraError,
+    });
+    const proof = buildProofArtifact(result, input.diffText);
+    return { result, proof };
+}

package/dist/verification/reproduction/verdict.d.ts

@@ -0,0 +1,39 @@
+/**
+ * Reproduction verdict — the harness's OWN judgment, produced by re-running
+ * the claimed work in a separate trust boundary. NEVER the agent's self-report
+ * (that is the V7 violation this whole module exists to defeat).
+ */
+export type ReproductionVerdict = "reproduced" | "contradicted" | "weak-tests" | "tamper" | "infra-error";
+export interface ClaimedChecks {
+    readonly testsPass: boolean;
+    readonly typecheckPass: boolean;
+    readonly lintPass: boolean;
+}
+/** `null` = the check was not run / unavailable, so it cannot contradict a claim. */
+export interface ObservedChecks {
+    readonly testsPass: boolean | null;
+    readonly typecheckPass: boolean | null;
+    readonly lintPass: boolean | null;
+}
+export interface ReproductionInput {
+    readonly claimed: ClaimedChecks;
+    readonly observed: ObservedChecks;
+    readonly tampered: boolean;
+    /** Set by the Phase-B mutation gate; Phase A never sets it. */
+    readonly weakTests?: boolean;
+    /** Set when the replay could not run at all. */
+    readonly infraError?: string;
+}
+export interface ReproductionResult {
+    readonly verdict: ReproductionVerdict;
+    readonly claimed: ClaimedChecks;
+    readonly observed: ObservedChecks;
+    readonly contradictions: readonly string[];
+    readonly infraError?: string;
+}
+/**
+ * Pure decision. Precedence (a false PASS is the moat-killer; a false BLOCK is
+ * recoverable, so we bias toward blocking): tamper > infra-error > contradicted
+ * > weak-tests > reproduced.
+ */
+export declare function decideReproductionVerdict(input: ReproductionInput): ReproductionResult;

package/dist/verification/reproduction/verdict.js

@@ -0,0 +1,40 @@
+const CHECKS = [
+    { name: "tests", claimedKey: "testsPass", observedKey: "testsPass" },
+    { name: "typecheck", claimedKey: "typecheckPass", observedKey: "typecheckPass" },
+    { name: "lint", claimedKey: "lintPass", observedKey: "lintPass" },
+];
+/**
+ * Pure decision. Precedence (a false PASS is the moat-killer; a false BLOCK is
+ * recoverable, so we bias toward blocking): tamper > infra-error > contradicted
+ * > weak-tests > reproduced.
+ */
+export function decideReproductionVerdict(input) {
+    const contradictions = [];
+    for (const c of CHECKS) {
+        const claimed = input.claimed[c.claimedKey];
+        const observed = input.observed[c.observedKey];
+        // Only a claimed-PASS that the harness observed as FAIL is a contradiction.
+        // observed === null means "not run", which cannot contradict anything.
+        if (claimed === true && observed === false) {
+            contradictions.push(`${c.name}: agent claimed pass, harness observed fail`);
+        }
+    }
+    let verdict;
+    if (input.tampered)
+        verdict = "tamper";
+    else if (input.infraError)
+        verdict = "infra-error";
+    else if (contradictions.length > 0)
+        verdict = "contradicted";
+    else if (input.weakTests)
+        verdict = "weak-tests";
+    else
+        verdict = "reproduced";
+    return {
+        verdict,
+        claimed: input.claimed,
+        observed: input.observed,
+        contradictions,
+        ...(input.infraError ? { infraError: input.infraError } : {}),
+    };
+}

package/package.json

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

package/dist/ui/opentui-chat.d.ts

@@ -1,19 +0,0 @@
-import { type CliRenderer } from "@opentui/core";
-import { type Root } from "@opentui/react";
-import type { ProviderName, ProviderStatus } from "../core/types.js";
-import type { WotannRuntime } from "../core/runtime.js";
-export interface OpenTuiChatOptions {
-    readonly version: string;
-    readonly providers: readonly ProviderStatus[];
-    readonly initialProvider?: ProviderName;
-    readonly initialModel?: string;
-    readonly runtime: WotannRuntime;
-    readonly fullscreen?: boolean;
-}
-export interface OpenTuiChatHandle {
-    readonly renderer: CliRenderer;
-    readonly root: Root;
-    readonly waitUntilExit: Promise<void>;
-    stop(): Promise<void>;
-}
-export declare function mountOpenTuiChat(options: OpenTuiChatOptions): Promise<OpenTuiChatHandle>;

package/dist/ui/opentui-chat.js

@@ -1,285 +0,0 @@
-import React, { useCallback, useEffect, useMemo, useRef, useState } from "react";
-import { createCliRenderer } from "@opentui/core";
-import { createRoot, useKeyboard } from "@opentui/react";
-import { 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";
-export async function mountOpenTuiChat(options) {
-    const screenMode = options.fullscreen === false ? "main-screen" : "alternate-screen";
-    const renderer = await createCliRenderer({
-        screenMode,
-        exitOnCtrlC: false,
-        useMouse: true,
-        enableMouseMovement: true,
-        targetFps: 30,
-        maxFps: 60,
-        clearOnShutdown: options.fullscreen !== false,
-        useKittyKeyboard: {
-            disambiguate: true,
-            alternateKeys: true,
-            events: false,
-            allKeysAsEscapes: false,
-            reportText: true,
-        },
-    });
-    const root = createRoot(renderer);
-    let done = false;
-    let resolveExit;
-    const waitUntilExit = new Promise((resolve) => {
-        resolveExit = resolve;
-    });
-    const stop = async () => {
-        if (done)
-            return;
-        done = true;
-        root.unmount();
-        renderer.destroy();
-        resolveExit?.();
-    };
-    root.render(React.createElement(OpenTuiChatApp, { ...options, onExit: () => void stop() }));
-    return { renderer, root, waitUntilExit, stop };
-}
-function OpenTuiChatApp(props) {
-    const providerSummary = useMemo(() => summarizeProviders(props.providers), [props.providers]);
-    const [draft, setDraft] = useState("");
-    const [isStreaming, setIsStreaming] = useState(false);
-    const [messages, setMessages] = useState(() => [
-        {
-            id: "system-welcome",
-            role: "system",
-            content: `WOTANN ${props.version} native OpenTUI renderer ready. ` +
-                "Type a prompt, /help, /clear, or /quit.",
-        },
-    ]);
-    const messagesRef = useRef(messages);
-    const queueRef = useRef([]);
-    const abortRef = useRef(null);
-    const submitPromptRef = useRef(async () => { });
-    useEffect(() => {
-        messagesRef.current = messages;
-    }, [messages]);
-    const appendMessage = useCallback((message) => {
-        setMessages((prev) => [...prev, message]);
-    }, []);
-    const appendAssistantDelta = useCallback((id, content, model, provider) => {
-        setMessages((prev) => {
-            const existing = prev.find((message) => message.id === id);
-            if (!existing) {
-                return [...prev, { id, role: "assistant", content, model, provider }];
-            }
-            return prev.map((message) => message.id === id
-                ? {
-                    ...message,
-                    content: `${message.content}${content}`,
-                    ...(model ? { model } : {}),
-                    ...(provider ? { provider } : {}),
-                }
-                : message);
-        });
-    }, []);
-    const runQueued = useCallback(() => {
-        const [next, ...rest] = queueRef.current;
-        queueRef.current = rest;
-        if (next) {
-            void submitPromptRef.current(next);
-        }
-    }, []);
-    const submitPrompt = useCallback(async (rawPrompt) => {
-        const prompt = rawPrompt.trim();
-        if (!prompt)
-            return;
-        if (prompt === "/quit" || prompt === "/exit") {
-            props.onExit();
-            return;
-        }
-        if (prompt === "/clear") {
-            setMessages([]);
-            return;
-        }
-        if (prompt === "/help") {
-            appendMessage({
-                id: `system-${Date.now()}`,
-                role: "system",
-                content: "Commands: /help, /clear, /quit. Enter submits. Esc aborts an active turn. " +
-                    "OpenTUI provides native scroll, mouse, keyboard, and alternate-screen rendering.",
-            });
-            return;
-        }
-        if (isStreaming) {
-            queueRef.current = [...queueRef.current, prompt];
-            appendMessage({
-                id: `queued-${Date.now()}`,
-                role: "system",
-                content: `Queued next turn: ${prompt}`,
-            });
-            return;
-        }
-        const userMessage = {
-            id: `user-${Date.now()}`,
-            role: "user",
-            content: prompt,
-        };
-        const turnContext = messagesRef.current;
-        const abortController = new AbortController();
-        abortRef.current = abortController;
-        setIsStreaming(true);
-        appendMessage(userMessage);
-        const assistantId = `assistant-${Date.now()}`;
-        let failed = false;
-        try {
-            for await (const event of runAgent({
-                prompt,
-                context: turnContext,
-                model: props.initialModel || undefined,
-                provider: props.initialProvider || undefined,
-                tools: AGENT_TOOL_DEFINITIONS,
-                signal: abortController.signal,
-                query: (queryOptions) => props.runtime.query(queryOptions),
-                executeTool: (name, input) => executeAgentTool(name, input, buildAgentToolContext(props.runtime, {
-                    workingDir: props.runtime.getWorkingDir(),
-                    permissionMode: props.runtime.getPermissionMode(),
-                })),
-            })) {
-                if (abortController.signal.aborted)
-                    break;
-                if ("kind" in event) {
-                    if (event.kind === "tool_result") {
-                        appendMessage({
-                            id: `tool-${Date.now()}`,
-                            role: "tool",
-                            toolName: event.toolName,
-                            toolCallId: event.toolCallId,
-                            content: `${event.toolName}: ${previewToolResult(event.result)}`,
-                        });
-                    }
-                    continue;
-                }
-                if (event.type === "text" && event.content.length > 0) {
-                    appendAssistantDelta(assistantId, event.content, event.model, event.provider);
-                }
-                else if (event.type === "error") {
-                    failed = true;
-                    appendMessage({
-                        id: `error-${Date.now()}`,
-                        role: "system",
-                        content: `Runtime error: ${event.content || "query failed"}`,
-                    });
-                }
-            }
-        }
-        catch (err) {
-            failed = true;
-            appendMessage({
-                id: `error-${Date.now()}`,
-                role: "system",
-                content: `Runtime error: ${err instanceof Error ? err.message : String(err)}`,
-            });
-        }
-        finally {
-            abortRef.current = null;
-            setIsStreaming(false);
-            if (!failed && abortController.signal.aborted) {
-                appendMessage({
-                    id: `abort-${Date.now()}`,
-                    role: "system",
-                    content: "Turn aborted.",
-                });
-            }
-            runQueued();
-        }
-    }, [
-        appendAssistantDelta,
-        appendMessage,
-        isStreaming,
-        props,
-        runQueued,
-    ]);
-    useEffect(() => {
-        submitPromptRef.current = submitPrompt;
-    }, [submitPrompt]);
-    useKeyboard((key) => {
-        if (key.name === "escape" && abortRef.current) {
-            abortRef.current.abort();
-            return;
-        }
-        if ((key.name === "c" && key.ctrl) || key.name === "q") {
-            props.onExit();
-        }
-    });
-    const transcript = messages.map(formatMessage).join("\n\n");
-    const status = isStreaming
-        ? "streaming - Esc aborts"
-        : queueRef.current.length > 0
-            ? `${queueRef.current.length} queued`
-            : "ready";
-    return React.createElement("box", {
-        id: "wotann-opentui-root",
-        flexDirection: "column",
-        width: "100%",
-        height: "100%",
-        padding: 1,
-        backgroundColor: "#05070d",
-        gap: 1,
-    }, React.createElement("box", {
-        id: "wotann-opentui-header",
-        border: true,
-        borderColor: "#6ee7f9",
-        paddingX: 1,
-        height: 5,
-        flexDirection: "column",
-    }, React.createElement("text", {
-        content: `WOTANN ${props.version}  |  OpenTUI native renderer  |  ${status}`,
-        fg: "#67e8f9",
-    }), React.createElement("text", {
-        content: providerSummary,
-        fg: "#a7f3d0",
-    })), React.createElement("scrollbox", {
-        id: "wotann-opentui-transcript",
-        flexGrow: 1,
-        border: true,
-        borderColor: "#334155",
-        paddingX: 1,
-        scrollY: true,
-        stickyScroll: true,
-        stickyStart: "bottom",
-    }, React.createElement("text", {
-        content: transcript || "No messages yet.",
-        fg: "#e5e7eb",
-    })), React.createElement("box", {
-        id: "wotann-opentui-composer",
-        border: true,
-        borderColor: isStreaming ? "#f59e0b" : "#22c55e",
-        paddingX: 1,
-        height: 4,
-    }, React.createElement("input", {
-        id: "wotann-opentui-input",
-        value: draft,
-        placeholder: isStreaming ? "Streaming... type to queue next prompt" : "Ask WOTANN...",
-        focused: true,
-        onInput: setDraft,
-        onChange: setDraft,
-        onSubmit: (value) => {
-            setDraft("");
-            void submitPrompt(value);
-        },
-    })));
-}
-function summarizeProviders(providers) {
-    const available = providers.filter((provider) => provider.available);
-    if (available.length === 0) {
-        return "No provider configured. Run wotann init or set a provider API key.";
-    }
-    return `Providers: ${available.map((provider) => provider.label || provider.provider).join(", ")}`;
-}
-function formatMessage(message) {
-    const label = message.role === "assistant" && message.provider
-        ? `assistant:${message.provider}${message.model ? `/${message.model}` : ""}`
-        : message.toolName
-            ? `tool:${message.toolName}`
-            : message.role;
-    return `${label}> ${message.content}`;
-}
-function previewToolResult(result) {
-    const oneLine = result.replace(/\s+/g, " ").trim();
-    return oneLine.length > 240 ? `${oneLine.slice(0, 237)}...` : oneLine;
-}