@personaxis/tui 0.11.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Personaxis
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/dist/bin.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/bin.js

@@ -0,0 +1,13 @@
+#!/usr/bin/env node
+/**
+ * Dedicated `personaxis-dash` bin entry. This file is the ONLY place the
+ * dashboard auto-runs — the library barrel (index.ts) must never carry a
+ * main-module guard: inside a bun-compiled binary every bundled module
+ * shares the virtual root, so `import.meta.url === argv[1]` guards fire
+ * spuriously on every invocation (found in FR.V verification).
+ */
+import { dashMain } from "./index.js";
+dashMain().catch((err) => {
+    console.error("personaxis-dash fatal:", err);
+    process.exit(1);
+});

package/dist/components.d.ts

@@ -0,0 +1,47 @@
+/**
+ * Ink 7 components (FR.3). `visual.ts` stays the single source of the brand
+ * identity — its functions are pure `(theme, values, frame) → string`, so each
+ * component is a thin wrapper: ZERO visual change from the pre-Ink dashboard.
+ */
+import React from "react";
+import { type PersonaTheme } from "@personaxis/core";
+import { envelopeBars } from "./visual.js";
+export declare function Sigil(props: {
+    theme: PersonaTheme;
+    values: Record<string, number>;
+    frame?: number;
+}): React.JSX.Element;
+export declare function AuraBar(props: {
+    theme: PersonaTheme;
+    values: Record<string, number>;
+    frame?: number;
+}): React.JSX.Element;
+export declare function EnvelopeBars(props: {
+    theme: PersonaTheme;
+    values: Record<string, number>;
+    envelopes: Parameters<typeof envelopeBars>[2];
+}): React.JSX.Element;
+export interface TranscriptProps {
+    /** Committed lines — rendered ONCE into native scrollback via <Static>. */
+    committed: string[];
+    /** The bounded live region (in-flight tokens, spinner line, dials). */
+    live?: string;
+}
+/**
+ * `<Static>` for the terminated transcript (never re-rendered — the Ink-
+ * documented mitigation for long histories) + a bounded live region below.
+ * The CommitQueue decides WHEN a line moves from live to committed.
+ */
+export declare function Transcript(props: TranscriptProps): React.JSX.Element;
+export interface DashboardProps {
+    personaPath: string;
+    intervalMs?: number;
+    /** Stop after N frames (tests/demos); omit to run until unmount. */
+    maxFrames?: number;
+}
+/**
+ * The live dashboard as an Ink app. Reads state.json each frame (same contract
+ * as the pre-Ink loop), so evolution in ANOTHER process (REPL, MCP, HTTP)
+ * shows up live.
+ */
+export declare function Dashboard(props: DashboardProps): React.JSX.Element;

package/dist/components.js

@@ -0,0 +1,65 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+/**
+ * Ink 7 components (FR.3). `visual.ts` stays the single source of the brand
+ * identity — its functions are pure `(theme, values, frame) → string`, so each
+ * component is a thin wrapper: ZERO visual change from the pre-Ink dashboard.
+ */
+import { useEffect, useState } from "react";
+import { Box, Text, Static } from "ink";
+import { loadPersona, readState, extractEnvelopes, verifyMemoryChain, readMemory, personaTheme, displayName, } from "@personaxis/core";
+import { sigilLines, auraBar, envelopeBars } from "./visual.js";
+// ── brand components (pure wrappers over visual.ts) ─────────────────────────
+export function Sigil(props) {
+    return _jsx(Text, { children: sigilLines(props.theme, props.values, props.frame ?? 0).join("\n") });
+}
+export function AuraBar(props) {
+    return _jsx(Text, { children: auraBar(props.theme, props.values, props.frame ?? 0) });
+}
+export function EnvelopeBars(props) {
+    return _jsx(Text, { children: envelopeBars(props.theme, props.values, props.envelopes) });
+}
+/**
+ * `<Static>` for the terminated transcript (never re-rendered — the Ink-
+ * documented mitigation for long histories) + a bounded live region below.
+ * The CommitQueue decides WHEN a line moves from live to committed.
+ */
+export function Transcript(props) {
+    return (_jsxs(Box, { flexDirection: "column", children: [_jsx(Static, { items: props.committed, children: (line, i) => _jsx(Text, { children: line }, i) }), props.live ? _jsx(Text, { children: props.live }) : null] }));
+}
+function readFrame(personaPath) {
+    const handle = loadPersona(personaPath);
+    const state = readState(handle.statePath);
+    return {
+        name: displayName(handle.frontmatter),
+        theme: personaTheme(handle.frontmatter),
+        values: state.values,
+        envelopes: extractEnvelopes(handle.frontmatter).envelopes,
+        mutations: state.mutation_log.length,
+        memories: readMemory(handle.personaPath).length,
+        chainOk: verifyMemoryChain(handle.personaPath).ok,
+    };
+}
+/**
+ * The live dashboard as an Ink app. Reads state.json each frame (same contract
+ * as the pre-Ink loop), so evolution in ANOTHER process (REPL, MCP, HTTP)
+ * shows up live.
+ */
+export function Dashboard(props) {
+    const [frame, setFrame] = useState(0);
+    const [data, setData] = useState(() => readFrame(props.personaPath));
+    useEffect(() => {
+        if (props.maxFrames !== undefined && frame >= props.maxFrames)
+            return;
+        const t = setTimeout(() => {
+            setFrame((f) => f + 1);
+            try {
+                setData(readFrame(props.personaPath));
+            }
+            catch {
+                /* a mid-write read races with another process — keep the last frame */
+            }
+        }, props.intervalMs ?? 500);
+        return () => clearTimeout(t);
+    }, [frame, props.personaPath, props.intervalMs, props.maxFrames]);
+    return (_jsxs(Box, { flexDirection: "column", paddingLeft: 2, paddingTop: 1, children: [_jsxs(Box, { children: [_jsx(Text, { bold: true, color: "cyanBright", children: data.name }), _jsxs(Text, { dimColor: true, children: ["  ·  sigil #", data.theme.seed.toString(16), "  ·  "] }), _jsx(AuraBar, { theme: data.theme, values: data.values, frame: frame })] }), _jsx(Text, { children: " " }), _jsx(Sigil, { theme: data.theme, values: data.values, frame: frame }), _jsx(Text, { children: " " }), _jsx(EnvelopeBars, { theme: data.theme, values: data.values, envelopes: data.envelopes }), _jsx(Text, { children: " " }), _jsxs(Text, { dimColor: true, children: [`mutations ${data.mutations}  ·  memory ${data.memories}  ·  chain `, data.chainOk ? _jsx(Text, { color: "green", children: "intact" }) : _jsx(Text, { color: "red", children: "BROKEN" }), `  ·  frame ${frame}`] })] }));
+}

package/dist/index.d.ts

@@ -0,0 +1,31 @@
+/**
+ * @personaxis/tui — the living dashboard (`personaxis-dash`).
+ *
+ * A breathing, per-persona ASCII view: the persona's own sigil (seeded from its
+ * personaxis.md identity) animating with its live state, envelope bars, mutation
+ * count, and memory-chain integrity. It reads state.json each frame, so it reflects
+ * evolution happening in another process (REPL, MCP host, HTTP) in real time.
+ *
+ *   personaxis-dash --persona <path> [--once] [--frames N] [--interval ms]
+ */
+export interface DashOpts {
+    persona: string;
+    once: boolean;
+    frames: number;
+    interval: number;
+}
+export declare function renderFrame(personaPath: string, frame: number): string;
+/**
+ * Run the live dashboard for a persona. Shared by the `personaxis-dash` bin and the
+ * `personaxis dash` CLI subcommand, so both entry points behave identically.
+ * Returns when finished (once/non-TTY); in interactive mode it runs until SIGINT.
+ */
+export declare function runDashboard(opts: DashOpts): Promise<void>;
+/**
+ * `personaxis-dash` standalone entry — used by bin.ts ONLY. The old
+ * `import.meta.url === argv[1]` main-module guard lived here and evaluated
+ * TRUE for every module inside a bun-compiled binary (all modules share the
+ * virtual root), spuriously launching the dashboard on EVERY CLI invocation.
+ * Bun-compile rule: a bin gets a dedicated entry file, never a barrel guard.
+ */
+export declare function dashMain(): Promise<void>;

package/dist/index.js

@@ -0,0 +1,94 @@
+/**
+ * @personaxis/tui — the living dashboard (`personaxis-dash`).
+ *
+ * A breathing, per-persona ASCII view: the persona's own sigil (seeded from its
+ * personaxis.md identity) animating with its live state, envelope bars, mutation
+ * count, and memory-chain integrity. It reads state.json each frame, so it reflects
+ * evolution happening in another process (REPL, MCP host, HTTP) in real time.
+ *
+ *   personaxis-dash --persona <path> [--once] [--frames N] [--interval ms]
+ */
+import { existsSync } from "node:fs";
+import { resolve } from "node:path";
+import chalk from "chalk";
+import { loadPersona, ensureState, readState, extractEnvelopes, verifyMemoryChain, readMemory, personaTheme, displayName, } from "@personaxis/core";
+import { sigilLines, auraBar, envelopeBars } from "./visual.js";
+function parseArgs(argv) {
+    const o = { persona: ".personaxis/personaxis.md", once: false, frames: 30, interval: 500 };
+    for (let i = 0; i < argv.length; i++) {
+        const a = argv[i];
+        if (a === "--persona" || a === "-p")
+            o.persona = argv[++i];
+        else if (a === "--once")
+            o.once = true;
+        else if (a === "--frames")
+            o.frames = Number(argv[++i]) || o.frames;
+        else if (a === "--interval")
+            o.interval = Number(argv[++i]) || o.interval;
+    }
+    return o;
+}
+export function renderFrame(personaPath, frame) {
+    const handle = loadPersona(personaPath);
+    const state = readState(handle.statePath);
+    const env = extractEnvelopes(handle.frontmatter);
+    const theme = personaTheme(handle.frontmatter);
+    const chain = verifyMemoryChain(handle.personaPath);
+    const mem = readMemory(handle.personaPath);
+    const lines = [];
+    lines.push("");
+    lines.push("  " + chalk.bold.ansi256(theme.palette.accent)(displayName(handle.frontmatter)) +
+        chalk.dim(`  ·  sigil #${theme.seed.toString(16)}  ·  ${auraBar(theme, state.values, frame)}`));
+    lines.push("");
+    lines.push(...sigilLines(theme, state.values, frame));
+    lines.push("");
+    lines.push(envelopeBars(theme, state.values, env.envelopes));
+    lines.push("");
+    lines.push(chalk.dim(`  mutations ${state.mutation_log.length}  ·  memory ${mem.length}  ·  chain ` +
+        (chain.ok ? chalk.green("intact") : chalk.red("BROKEN")) +
+        `  ·  frame ${frame}`));
+    lines.push("");
+    return lines.join("\n");
+}
+/**
+ * Run the live dashboard for a persona. Shared by the `personaxis-dash` bin and the
+ * `personaxis dash` CLI subcommand, so both entry points behave identically.
+ * Returns when finished (once/non-TTY); in interactive mode it runs until SIGINT.
+ */
+export async function runDashboard(opts) {
+    const personaPath = resolve(opts.persona);
+    if (!existsSync(personaPath)) {
+        console.error(chalk.red("Error:"), `persona not found at ${personaPath}`);
+        process.exitCode = 1;
+        return;
+    }
+    ensureState(loadPersona(personaPath));
+    // Non-interactive (pipe/CI/--once): print static frames, no screen takeover.
+    if (opts.once || !process.stdout.isTTY) {
+        const n = opts.once ? opts.frames : 1;
+        for (let i = 0; i < n; i++)
+            process.stdout.write(renderFrame(personaPath, i) + "\n");
+        return;
+    }
+    // Interactive: Ink 7 render (FR.3). Ink owns the diffing/redraw; the
+    // Dashboard component re-reads state.json each frame — same live contract
+    // as the pre-Ink loop, same visuals (components wrap visual.ts verbatim).
+    const [{ render }, React, { Dashboard }] = await Promise.all([
+        import("ink"),
+        import("react"),
+        import("./components.js"),
+    ]);
+    const app = render(React.createElement(Dashboard, { personaPath, intervalMs: opts.interval }), { exitOnCtrlC: true });
+    await app.waitUntilExit();
+    console.log(chalk.dim("  dashboard closed.\n"));
+}
+/**
+ * `personaxis-dash` standalone entry — used by bin.ts ONLY. The old
+ * `import.meta.url === argv[1]` main-module guard lived here and evaluated
+ * TRUE for every module inside a bun-compiled binary (all modules share the
+ * virtual root), spuriously launching the dashboard on EVERY CLI invocation.
+ * Bun-compile rule: a bin gets a dedicated entry file, never a barrel guard.
+ */
+export async function dashMain() {
+    await runDashboard(parseArgs(process.argv.slice(2)));
+}

package/dist/ink.d.ts

@@ -0,0 +1,13 @@
+/**
+ * @personaxis/tui/ink — the Ink 7 surface (FR.3).
+ *
+ * Brand components wrap visual.ts verbatim (zero visual change); Transcript
+ * implements the streaming architecture (<Static> + live region + CommitQueue);
+ * the store adapts protocol events for React. `screen.ts` (the pre-Ink REPL
+ * line editor) remains exported until F3.6 rewires the REPL behind the seam.
+ */
+export { Sigil, AuraBar, EnvelopeBars, Transcript, Dashboard } from "./components.js";
+export type { TranscriptProps, DashboardProps } from "./components.js";
+export { CommitQueue } from "./streaming/commit-queue.js";
+export { renderMarkdown, highlightCode, renderDiff } from "./markdown.js";
+export { createEngineStore, type EngineStore, type EngineUiState } from "./store.js";

package/dist/ink.js

@@ -0,0 +1,12 @@
+/**
+ * @personaxis/tui/ink — the Ink 7 surface (FR.3).
+ *
+ * Brand components wrap visual.ts verbatim (zero visual change); Transcript
+ * implements the streaming architecture (<Static> + live region + CommitQueue);
+ * the store adapts protocol events for React. `screen.ts` (the pre-Ink REPL
+ * line editor) remains exported until F3.6 rewires the REPL behind the seam.
+ */
+export { Sigil, AuraBar, EnvelopeBars, Transcript, Dashboard } from "./components.js";
+export { CommitQueue } from "./streaming/commit-queue.js";
+export { renderMarkdown, highlightCode, renderDiff } from "./markdown.js";
+export { createEngineStore } from "./store.js";

package/dist/markdown.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Terminal markdown / syntax / diff rendering (FR.3 decision table):
+ *   markdown → marked + marked-terminal
+ *   syntax   → shiki, LAZY-loaded (heavy; first highlight pays the import)
+ *   diff     → jsdiff + chalk
+ */
+/** Render markdown for the terminal (synchronous, no syntax highlight). */
+export declare function renderMarkdown(md: string): string;
+/** Highlight code with shiki when available; plain text otherwise. */
+export declare function highlightCode(code: string, lang: string): Promise<string>;
+/** Line diff, colored for the terminal. */
+export declare function renderDiff(before: string, after: string): string;

package/dist/markdown.js

@@ -0,0 +1,56 @@
+/**
+ * Terminal markdown / syntax / diff rendering (FR.3 decision table):
+ *   markdown → marked + marked-terminal
+ *   syntax   → shiki, LAZY-loaded (heavy; first highlight pays the import)
+ *   diff     → jsdiff + chalk
+ */
+import chalk from "chalk";
+import { Marked } from "marked";
+import { markedTerminal } from "marked-terminal";
+import { diffLines } from "diff";
+const marked = new Marked(markedTerminal({
+    reflowText: false,
+    tab: 2,
+}));
+/** Render markdown for the terminal (synchronous, no syntax highlight). */
+export function renderMarkdown(md) {
+    const out = marked.parse(md, { async: false });
+    return out.replace(/\n+$/, "");
+}
+let shikiPromise = null;
+async function shiki() {
+    if (!shikiPromise) {
+        // Optional at runtime: highlighting degrades to plain text when shiki is
+        // not installed (it is a heavy optional enhancement, not a core need).
+        shikiPromise = import(/* @vite-ignore */ "shiki")
+            .then((m) => m)
+            .catch(() => null);
+    }
+    return shikiPromise;
+}
+/** Highlight code with shiki when available; plain text otherwise. */
+export async function highlightCode(code, lang) {
+    const m = (await shiki());
+    if (!m?.codeToAnsi)
+        return code;
+    try {
+        return await m.codeToAnsi(code, { lang, theme: "github-dark" });
+    }
+    catch {
+        return code;
+    }
+}
+// ── diffs ─────────────────────────────────────────────────────────────────────
+/** Line diff, colored for the terminal. */
+export function renderDiff(before, after) {
+    return diffLines(before, after)
+        .map((part) => {
+        const lines = part.value.replace(/\n$/, "").split("\n");
+        if (part.added)
+            return lines.map((l) => chalk.green(`+ ${l}`)).join("\n");
+        if (part.removed)
+            return lines.map((l) => chalk.red(`- ${l}`)).join("\n");
+        return lines.map((l) => chalk.dim(`  ${l}`)).join("\n");
+    })
+        .join("\n");
+}

package/dist/screen.d.ts

@@ -0,0 +1,60 @@
+/**
+ * Repl — a NORMAL-buffer, minimalist interactive line editor.
+ *
+ * Deliberately NOT an alternate-screen app: taking over the screen (and capturing
+ * the mouse) breaks the things a terminal already does well — native scrollback,
+ * text selection, click. So this stays in the normal buffer: output is printed
+ * normally (the terminal owns scrollback / wheel / selection), and only a small
+ * prompt block is kept pinned at the bottom, redrawn in place. Raw mode is used
+ * for key handling ONLY (no mouse reporting), so wheel/selection still work.
+ *
+ * Provides: a live `/` command palette navigable with ↑/↓ + Tab, an inline busy
+ * spinner, and an approval prompt — all without leaving the normal buffer.
+ */
+export type LineRole = "user" | "persona" | "activity" | "system" | "divider";
+export interface SlashItem {
+    name: string;
+    desc: string;
+}
+export interface ReplHooks {
+    /** The prompt prefix, e.g. "❯ ". */
+    prompt(): string;
+    /** A status line shown BELOW the input (tokens · time · mode). */
+    status(): string;
+    commands: SlashItem[];
+    onSubmit(line: string): Promise<void> | void;
+    onCycleMode?(): void;
+    onExit?(): void;
+}
+export declare class Screen {
+    private readonly hooks;
+    private readonly out;
+    private readonly inp;
+    private input;
+    private menuOpen;
+    private menuIndex;
+    private busy;
+    private phase;
+    private closed;
+    private renderedRows;
+    private spinnerFrame;
+    private spinnerTimer;
+    private pendingAsk;
+    constructor(hooks: ReplHooks);
+    start(): void;
+    stop(): void;
+    /** Print a line of OUTPUT above the prompt (stays in native scrollback). */
+    print(text: string, _role?: LineRole): void;
+    setBusy(busy: boolean, phase?: string): void;
+    setPhase(phase: string): void;
+    /** Prompt for a one-line answer (e.g. an approval). The next Enter resolves it. */
+    ask(prompt: string): Promise<string>;
+    private cols;
+    private matches;
+    private rule;
+    private promptBlock;
+    private renderPrompt;
+    private clearPrompt;
+    private onKey;
+    private submit;
+}

package/dist/screen.js

@@ -0,0 +1,243 @@
+/**
+ * Repl — a NORMAL-buffer, minimalist interactive line editor.
+ *
+ * Deliberately NOT an alternate-screen app: taking over the screen (and capturing
+ * the mouse) breaks the things a terminal already does well — native scrollback,
+ * text selection, click. So this stays in the normal buffer: output is printed
+ * normally (the terminal owns scrollback / wheel / selection), and only a small
+ * prompt block is kept pinned at the bottom, redrawn in place. Raw mode is used
+ * for key handling ONLY (no mouse reporting), so wheel/selection still work.
+ *
+ * Provides: a live `/` command palette navigable with ↑/↓ + Tab, an inline busy
+ * spinner, and an approval prompt — all without leaving the normal buffer.
+ */
+import readline from "node:readline";
+import chalk from "chalk";
+const SPINNER = ["⠋", "⠙", "⠹", "⠸", "⠼", "⠴", "⠦", "⠧", "⠇", "⠏"];
+export class Screen {
+    hooks;
+    out = process.stdout;
+    inp = process.stdin;
+    input = "";
+    menuOpen = false;
+    menuIndex = 0;
+    busy = false;
+    phase = "";
+    closed = false;
+    renderedRows = 0; // terminal rows the prompt block currently occupies
+    spinnerFrame = 0;
+    spinnerTimer = null;
+    pendingAsk = null;
+    constructor(hooks) {
+        this.hooks = hooks;
+    }
+    start() {
+        readline.emitKeypressEvents(this.inp);
+        if (this.inp.isTTY)
+            this.inp.setRawMode(true);
+        this.inp.on("keypress", this.onKey);
+        this.out.write(chalk.dim("\x1b[?25h")); // ensure cursor visible (no alt-screen, no mouse)
+        this.renderPrompt();
+    }
+    stop() {
+        if (this.closed)
+            return;
+        this.closed = true;
+        if (this.spinnerTimer)
+            clearInterval(this.spinnerTimer);
+        this.clearPrompt();
+        this.inp.off("keypress", this.onKey);
+        if (this.inp.isTTY)
+            this.inp.setRawMode(false);
+        this.inp.pause();
+    }
+    /** Print a line of OUTPUT above the prompt (stays in native scrollback). */
+    print(text, _role = "system") {
+        this.clearPrompt();
+        this.out.write(text + "\n");
+        this.renderPrompt();
+    }
+    setBusy(busy, phase = "") {
+        this.busy = busy;
+        this.phase = phase;
+        if (busy && !this.spinnerTimer) {
+            this.spinnerTimer = setInterval(() => {
+                this.spinnerFrame = (this.spinnerFrame + 1) % SPINNER.length;
+                this.renderPrompt();
+            }, 90);
+        }
+        else if (!busy && this.spinnerTimer) {
+            clearInterval(this.spinnerTimer);
+            this.spinnerTimer = null;
+        }
+        this.renderPrompt();
+    }
+    setPhase(phase) {
+        this.phase = phase;
+        if (this.busy)
+            this.renderPrompt();
+    }
+    /** Prompt for a one-line answer (e.g. an approval). The next Enter resolves it. */
+    ask(prompt) {
+        this.print(chalk.yellow(prompt));
+        return new Promise((res) => {
+            this.pendingAsk = res;
+            this.renderPrompt();
+        });
+    }
+    // ── prompt rendering (pinned at the bottom of the normal buffer) ────────────
+    cols() {
+        return this.out.columns ?? 80;
+    }
+    matches() {
+        const q = this.input.slice(1).toLowerCase();
+        return this.hooks.commands.filter((c) => c.name.startsWith(q));
+    }
+    rule() {
+        return chalk.dim("─".repeat(Math.min(this.cols(), 72)));
+    }
+    promptBlock() {
+        if (this.busy) {
+            return [this.rule(), `${chalk.cyan(SPINNER[this.spinnerFrame])} ${chalk.dim(this.phase || "working…")}`];
+        }
+        if (this.pendingAsk)
+            return [chalk.yellow("? ") + this.input];
+        // The input line: a subtle background marks the area the USER is typing in.
+        const typed = this.input.length ? chalk.bgAnsi256(236).whiteBright(` ${this.input} `) : chalk.dim(" type a message… ");
+        const promptLine = this.hooks.prompt() + typed;
+        if (this.menuOpen) {
+            const items = this.matches();
+            // Windowed + scrollable: the visible slice follows the cursor, and its height
+            // adapts to the terminal so the menu never overruns small windows.
+            const rows = this.out.rows ?? 24;
+            const maxVisible = Math.max(3, Math.min(items.length, rows - 7));
+            let start = 0;
+            if (items.length > maxVisible) {
+                start = Math.min(Math.max(0, this.menuIndex - Math.floor(maxVisible / 2)), items.length - maxVisible);
+            }
+            const visible = items.slice(start, start + maxVisible);
+            const up = start > 0 ? "↑" : " ";
+            const down = start + maxVisible < items.length ? "↓" : " ";
+            const head = items.length > maxVisible
+                ? chalk.dim(`  ┄ ${up}${down} ${this.menuIndex + 1}/${items.length} · Tab fill · Enter run · Esc close ┄`)
+                : chalk.dim("  ┄ ↑↓ select · Tab fill · Enter run · Esc close ┄");
+            const menu = visible.map((c, i) => {
+                const idx = start + i;
+                const sel = idx === this.menuIndex;
+                const label = sel ? chalk.black.bgCyan(` /${c.name} `) : chalk.cyan(` /${c.name} `);
+                const pad = " ".repeat(Math.max(0, (sel ? 26 : 20) - (c.name.length + 3)));
+                return "  " + label + pad + chalk.dim(c.desc.slice(0, Math.max(8, this.cols() - 30)));
+            });
+            return [promptLine, head, ...menu];
+        }
+        // Status line BELOW the input, separated by a rule.
+        return [promptLine, this.rule(), this.hooks.status()];
+    }
+    renderPrompt() {
+        if (this.closed)
+            return;
+        this.clearPrompt();
+        const block = this.promptBlock();
+        this.out.write(block.join("\n"));
+        this.renderedRows = block.length;
+    }
+    clearPrompt() {
+        if (this.renderedRows <= 0) {
+            this.out.write("\r\x1b[K");
+            return;
+        }
+        // Move to column 0, up to the first prompt row, then clear everything below.
+        this.out.write("\r");
+        if (this.renderedRows > 1)
+            this.out.write(`\x1b[${this.renderedRows - 1}A`);
+        this.out.write("\x1b[J");
+        this.renderedRows = 0;
+    }
+    // ── input ───────────────────────────────────────────────────────────────────
+    onKey = (str, key) => {
+        if (this.closed)
+            return;
+        if (key.ctrl && key.name === "c") {
+            this.hooks.onExit?.();
+            this.stop();
+            this.out.write("\n");
+            process.exit(0);
+        }
+        // Command-palette navigation.
+        if (this.menuOpen) {
+            const items = this.matches();
+            if (key.name === "up") {
+                this.menuIndex = (this.menuIndex - 1 + Math.max(1, items.length)) % Math.max(1, items.length);
+                return this.renderPrompt();
+            }
+            if (key.name === "down") {
+                this.menuIndex = (this.menuIndex + 1) % Math.max(1, items.length);
+                return this.renderPrompt();
+            }
+            if (key.name === "tab") {
+                if (items[this.menuIndex])
+                    this.input = "/" + items[this.menuIndex].name + " ";
+                this.menuOpen = false;
+                return this.renderPrompt();
+            }
+            if (key.name === "escape") {
+                this.menuOpen = false;
+                return this.renderPrompt();
+            }
+        }
+        if (key.name === "return") {
+            // If the palette is open with a highlighted command and the user only typed
+            // the partial, run that command; otherwise submit the typed line.
+            if (this.menuOpen) {
+                const items = this.matches();
+                if (items[this.menuIndex] && this.input.slice(1) !== items[this.menuIndex].name) {
+                    this.input = "/" + items[this.menuIndex].name;
+                }
+                this.menuOpen = false;
+            }
+            if (this.pendingAsk) {
+                const ans = this.input;
+                this.input = "";
+                const r = this.pendingAsk;
+                this.pendingAsk = null;
+                r(ans);
+                return this.renderPrompt();
+            }
+            void this.submit();
+            return;
+        }
+        if (key.name === "backspace") {
+            this.input = this.input.slice(0, -1);
+            this.menuOpen = this.input.startsWith("/");
+            this.menuIndex = 0;
+            return this.renderPrompt();
+        }
+        if (key.name === "tab" && key.shift) {
+            this.hooks.onCycleMode?.();
+            return this.renderPrompt();
+        }
+        if (str && !key.ctrl && !key.meta && str.length === 1 && str >= " ") {
+            this.input += str;
+            this.menuOpen = this.input.startsWith("/");
+            this.menuIndex = 0;
+            return this.renderPrompt();
+        }
+    };
+    async submit() {
+        const line = this.input.trim();
+        this.input = "";
+        this.menuOpen = false;
+        this.clearPrompt();
+        if (!line) {
+            this.renderPrompt();
+            return;
+        }
+        try {
+            await this.hooks.onSubmit(line);
+        }
+        catch (e) {
+            this.print(chalk.red(`error: ${e.message}`));
+        }
+        this.renderPrompt();
+    }
+}

package/dist/store.d.ts

@@ -0,0 +1,26 @@
+/**
+ * Engine store (FR.3): the core EventBus — via the protocol seam — stays the
+ * SOURCE OF TRUTH; this thin zustand store only adapts events for React
+ * consumption (frame-batched token deltas, committed transcript, dials).
+ */
+import type { EventMsg } from "@personaxis/protocol";
+export interface EngineUiState {
+    connected: boolean;
+    personaName: string;
+    mode: string;
+    /** Committed transcript lines (render via <Static>). */
+    committed: string[];
+    /** Live region: pending stream tail. */
+    live: string;
+    /** Latest state snapshot (dials). */
+    values: Record<string, number>;
+    mutationCount: number;
+    busy: boolean;
+    lastError: string | null;
+}
+export declare function createEngineStore(): {
+    store: import("zustand/vanilla").StoreApi<EngineUiState>;
+    onEvent: (e: EventMsg) => void;
+    flushTokens: () => void;
+};
+export type EngineStore = ReturnType<typeof createEngineStore>;

package/dist/store.js

@@ -0,0 +1,79 @@
+/**
+ * Engine store (FR.3): the core EventBus — via the protocol seam — stays the
+ * SOURCE OF TRUTH; this thin zustand store only adapts events for React
+ * consumption (frame-batched token deltas, committed transcript, dials).
+ */
+import { createStore } from "zustand/vanilla";
+import { CommitQueue } from "./streaming/commit-queue.js";
+const initial = {
+    connected: false,
+    personaName: "",
+    mode: "locked",
+    committed: [],
+    live: "",
+    values: {},
+    mutationCount: 0,
+    busy: false,
+    lastError: null,
+};
+export function createEngineStore() {
+    const queue = new CommitQueue();
+    // Frame-batching: token deltas accumulate here and land in the store at most
+    // once per animation frame — a per-token setState would thrash the renderer.
+    let pendingTokens = "";
+    let scheduled = false;
+    const store = createStore(() => ({ ...initial }));
+    const flushTokens = () => {
+        scheduled = false;
+        if (!pendingTokens)
+            return;
+        const text = pendingTokens;
+        pendingTokens = "";
+        const newlyCommitted = queue.push(text);
+        store.setState((s) => ({
+            committed: newlyCommitted.length > 0 ? [...s.committed, ...newlyCommitted] : s.committed,
+            live: queue.pending(),
+        }));
+    };
+    const schedule = () => {
+        if (scheduled)
+            return;
+        scheduled = true;
+        setTimeout(flushTokens, 16); // ~one frame
+    };
+    const onEvent = (e) => {
+        switch (e.event) {
+            case "session.configured":
+                store.setState({ connected: true, personaName: e.persona.name, mode: e.mode });
+                return;
+            case "turn.started":
+                store.setState({ busy: true, lastError: null });
+                return;
+            case "token.delta":
+                pendingTokens += e.text;
+                schedule();
+                return;
+            case "turn.completed": {
+                flushTokens();
+                const rest = queue.flush();
+                store.setState((s) => ({
+                    busy: false,
+                    committed: rest.length > 0 ? [...s.committed, ...rest] : s.committed,
+                    live: "",
+                }));
+                return;
+            }
+            case "state.snapshot":
+                store.setState({ values: e.values, mutationCount: e.mutationCount });
+                return;
+            case "error":
+                store.setState({ lastError: e.message, busy: false });
+                return;
+            case "engine.event":
+            case "approval.requested":
+                // Rendered by dedicated consumers (activity feed, approval FSM — FR.10).
+                return;
+        }
+    };
+    return { store, onEvent, flushTokens };
+}

package/dist/streaming/commit-queue.d.ts

@@ -0,0 +1,29 @@
+/**
+ * Newline-gated markdown commit queue (Codex tui/src/streaming pattern).
+ *
+ * Streaming tokens land in a live region; a line is COMMITTED (moved to the
+ * <Static> transcript, i.e. native scrollback, never re-rendered) only when it
+ * can no longer change visually:
+ *   - the line is complete (a newline followed it), AND
+ *   - it is not inside an open ``` fence (the fence renders as one block), AND
+ *   - it is not part of a markdown table that may still be growing
+ *     (TABLE-HOLDBACK: a table is committed only when a non-table line — or
+ *     flush() — proves it is finished; committing row-by-row breaks alignment).
+ *
+ * Pure logic, no Ink dependency — unit-testable and reusable by any front-end.
+ */
+export declare class CommitQueue {
+    private buffer;
+    /** Complete lines that are held back (open fence or growing table). */
+    private held;
+    private inFence;
+    /** Feed streamed text. Returns the lines that became committable NOW. */
+    push(text: string): string[];
+    /** The not-yet-committed tail (held lines + partial line) for the live region. */
+    pending(): string;
+    /** End of stream: everything pending commits as-is (fence closed implicitly). */
+    flush(): string[];
+    private acceptLine;
+    private isFenceDelimiter;
+    private isTableLine;
+}

package/dist/streaming/commit-queue.js

@@ -0,0 +1,86 @@
+/**
+ * Newline-gated markdown commit queue (Codex tui/src/streaming pattern).
+ *
+ * Streaming tokens land in a live region; a line is COMMITTED (moved to the
+ * <Static> transcript, i.e. native scrollback, never re-rendered) only when it
+ * can no longer change visually:
+ *   - the line is complete (a newline followed it), AND
+ *   - it is not inside an open ``` fence (the fence renders as one block), AND
+ *   - it is not part of a markdown table that may still be growing
+ *     (TABLE-HOLDBACK: a table is committed only when a non-table line — or
+ *     flush() — proves it is finished; committing row-by-row breaks alignment).
+ *
+ * Pure logic, no Ink dependency — unit-testable and reusable by any front-end.
+ */
+export class CommitQueue {
+    buffer = "";
+    /** Complete lines that are held back (open fence or growing table). */
+    held = [];
+    inFence = false;
+    /** Feed streamed text. Returns the lines that became committable NOW. */
+    push(text) {
+        this.buffer += text;
+        const committed = [];
+        let nl;
+        while ((nl = this.buffer.indexOf("\n")) !== -1) {
+            const line = this.buffer.slice(0, nl);
+            this.buffer = this.buffer.slice(nl + 1);
+            committed.push(...this.acceptLine(line));
+        }
+        return committed;
+    }
+    /** The not-yet-committed tail (held lines + partial line) for the live region. */
+    pending() {
+        const parts = [...this.held];
+        if (this.buffer.length > 0)
+            parts.push(this.buffer);
+        return parts.join("\n");
+    }
+    /** End of stream: everything pending commits as-is (fence closed implicitly). */
+    flush() {
+        const out = [...this.held];
+        if (this.buffer.length > 0)
+            out.push(this.buffer);
+        this.held = [];
+        this.buffer = "";
+        this.inFence = false;
+        return out;
+    }
+    // ── internals ───────────────────────────────────────────────────────────────
+    acceptLine(line) {
+        if (this.isFenceDelimiter(line)) {
+            if (!this.inFence) {
+                // Fence OPENS: hold from here — the block renders atomically.
+                this.inFence = true;
+                this.held.push(line);
+                return [];
+            }
+            // Fence CLOSES: the whole block is final.
+            this.inFence = false;
+            this.held.push(line);
+            const block = this.held;
+            this.held = [];
+            return block;
+        }
+        if (this.inFence) {
+            this.held.push(line);
+            return [];
+        }
+        if (this.isTableLine(line)) {
+            // Table row: hold — the next line may be another row.
+            this.held.push(line);
+            return [];
+        }
+        // A non-table, non-fence line: any held table is now provably complete.
+        const out = this.held.length > 0 ? [...this.held, line] : [line];
+        this.held = [];
+        return out;
+    }
+    isFenceDelimiter(line) {
+        return /^\s*(```|~~~)/.test(line);
+    }
+    isTableLine(line) {
+        const t = line.trimEnd();
+        return t.startsWith("|") && t.endsWith("|") && t.length >= 2;
+    }
+}

package/dist/visual.d.ts

@@ -0,0 +1,37 @@
+/**
+ * The single visual engine for personaxis (plan/09-ascii-ux).
+ *
+ * One place for ALL terminal visuals — the animated wordmark, a persona's
+ * "awakening", its themed + animated sigil, the live aura, per-event flourishes,
+ * and voice-styled output. Everything is driven by the persona's PersonaTheme, so
+ * each persona looks AND behaves differently in the terminal. Reused by both the
+ * REPL (@personaxis/cli) and the dashboard (this package).
+ *
+ * Animations only play on a real TTY; piped/CI output prints the final frame once.
+ */
+import { type PersonaTheme, type PersonaFrontmatter, type StateFile, type LoopEvent } from "@personaxis/core";
+export declare const supportsAnim: () => boolean;
+/** Compose a word from FONT, row by row. Letters it doesn't know become spaces. */
+export declare function renderWordmark(word: string): string[];
+export declare const LOGO: string[];
+/** A quiet, premium reveal: the emblem settles, the wordmark wipes in once. Monochrome.
+ *  Responsive: falls back to a one-line mark when the terminal is narrower than the block. */
+export declare function animateLogo(): Promise<void>;
+/** Colored, themed sigil for one frame. */
+export declare function sigilLines(theme: PersonaTheme, values: Record<string, number>, frame?: number): string[];
+/** The persona materializing — sparse → full over a few frames. */
+export declare function awaken(fm: PersonaFrontmatter, state: StateFile): Promise<void>;
+/** A colored aura/mood gauge for the prompt + dashboard. */
+export declare function auraBar(theme: PersonaTheme, values: Record<string, number>, frame?: number): string;
+/** Envelope bars colored in the persona's palette. */
+export declare function envelopeBars(theme: PersonaTheme, values: Record<string, number>, envelopes: Record<string, {
+    min: number;
+    max: number;
+}>, width?: number): string;
+/** Per-event flourish — themed glyphs + color, distinct per event kind. */
+export declare function eventLine(theme: PersonaTheme, e: LoopEvent): string | null;
+/** Style a line of output to the persona's voice. */
+export declare function voiceWrap(theme: PersonaTheme, text: string): string;
+export declare function farewell(fm: PersonaFrontmatter): Promise<void>;
+/** Loop a renderer for `frames` at `interval`ms (TTY only), clearing each frame. */
+export declare function play(render: (frame: number) => string, frames: number, interval: number): Promise<void>;

package/dist/visual.js

@@ -0,0 +1,236 @@
+/**
+ * The single visual engine for personaxis (plan/09-ascii-ux).
+ *
+ * One place for ALL terminal visuals — the animated wordmark, a persona's
+ * "awakening", its themed + animated sigil, the live aura, per-event flourishes,
+ * and voice-styled output. Everything is driven by the persona's PersonaTheme, so
+ * each persona looks AND behaves differently in the terminal. Reused by both the
+ * REPL (@personaxis/cli) and the dashboard (this package).
+ *
+ * Animations only play on a real TTY; piped/CI output prints the final frame once.
+ */
+import chalk from "chalk";
+import { personaTheme, renderThemedSigil, themeIntensity, barIndex, displayName, } from "@personaxis/core";
+export const supportsAnim = () => Boolean(process.stdout.isTTY) && !process.env.NO_COLOR && process.env.PERSONAXIS_NO_ANIM !== "1";
+const sleep = (ms) => new Promise((r) => setTimeout(r, ms));
+const write = (s) => void process.stdout.write(s);
+// A robust 5-row block font (only █ and space → renders identically in every
+// monospace terminal; no slant/underscore tricks that collapsed into "eersonaxis").
+const FONT = {
+    p: ["█████", "█   █", "█████", "█    ", "█    "],
+    e: ["█████", "█    ", "███  ", "█    ", "█████"],
+    r: ["█████", "█   █", "█████", "█  █ ", "█   █"],
+    s: ["█████", "█    ", "█████", "    █", "█████"],
+    o: ["█████", "█   █", "█   █", "█   █", "█████"],
+    n: ["█   █", "██  █", "█ █ █", "█  ██", "█   █"],
+    a: ["█████", "█   █", "█████", "█   █", "█   █"],
+    x: ["█   █", " █ █ ", "  █  ", " █ █ ", "█   █"],
+    i: ["█████", "  █  ", "  █  ", "  █  ", "█████"],
+};
+/** Compose a word from FONT, row by row. Letters it doesn't know become spaces. */
+export function renderWordmark(word) {
+    const rows = ["", "", "", "", ""];
+    for (const ch of word.toLowerCase()) {
+        const g = FONT[ch] ?? ["     ", "     ", "     ", "     ", "     "];
+        for (let r = 0; r < 5; r++)
+            rows[r] += g[r] + " ";
+    }
+    return rows;
+}
+// The brand mark from logo.svg: a radiating sun/sigil with a bright core.
+const EMBLEM = [
+    "      ·  ✶  ·      ",
+    "    ╲   ╲│╱   ╱    ",
+    "   ✶ ──  ◉  ── ✶   ",
+    "    ╱   ╱│╲   ╲    ",
+    "      ·  ✶  ·      ",
+];
+export const LOGO = renderWordmark("personaxis");
+// Monochrome: the terminal's DEFAULT foreground (bold) adapts to light/dark themes
+// automatically — dark on a light terminal, light on a dark one. No color.
+const TAGLINE = chalk.dim("  the home of living, governed AI personas · ") + chalk.bold("/help");
+const word = (l) => chalk.bold(l);
+/** Paint the emblem; `bright` controls the core (used for a single subtle pulse). */
+function paintEmblem(bright) {
+    const core = "◉";
+    return EMBLEM.map((line) => {
+        let out = "";
+        for (const ch of line) {
+            if (ch === core)
+                out += bright ? chalk.bold(ch) : chalk.dim(ch);
+            else if (ch === " ")
+                out += " ";
+            else
+                out += chalk.dim(ch);
+        }
+        return out;
+    }).join("\n");
+}
+/** Compact single-line logo for narrow terminals (the block wordmark would wrap + break). */
+function compactLogo() {
+    return chalk.bold("◉ personaxis") + chalk.dim("  ·  living, governed AI personas");
+}
+/** A quiet, premium reveal: the emblem settles, the wordmark wipes in once. Monochrome.
+ *  Responsive: falls back to a one-line mark when the terminal is narrower than the block. */
+export async function animateLogo() {
+    const cols = process.stdout.columns ?? 80;
+    if (cols < LOGO[0].length + 2) {
+        write("\n" + compactLogo() + "\n\n");
+        return;
+    }
+    if (!supportsAnim()) {
+        write("\n" + paintEmblem(true) + "\n\n" + LOGO.map(word).join("\n") + "\n" + TAGLINE + "\n\n");
+        return;
+    }
+    write("\n");
+    // Emblem: a single gentle pulse on the core (dim → bright), not a loop.
+    for (const bright of [false, true]) {
+        write("\x1b[s" + paintEmblem(bright) + "\x1b[u");
+        await sleep(120);
+    }
+    write(paintEmblem(true) + "\n\n");
+    // Wordmark: left-to-right wipe, revealed once, then static.
+    const width = LOGO[0].length;
+    for (let w = 4; w <= width; w += 4) {
+        write(`\x1b[s`);
+        for (const line of LOGO)
+            write("\x1b[2K" + word(line.slice(0, w)) + "\n");
+        write("\x1b[u");
+        await sleep(28);
+    }
+    for (const line of LOGO)
+        write("\x1b[2K" + word(line) + "\n");
+    write(TAGLINE + "\n\n");
+}
+function paintGlyphRow(theme, row) {
+    const { primary, secondary, accent } = theme.palette;
+    let out = "";
+    for (const ch of row) {
+        const idx = theme.glyphs.indexOf(ch);
+        if (ch === " " || idx <= 0)
+            out += " ";
+        else if (idx <= 2)
+            out += chalk.ansi256(secondary)(ch);
+        else if (idx <= 4)
+            out += chalk.ansi256(primary)(ch);
+        else
+            out += chalk.ansi256(accent).bold(ch);
+    }
+    return out;
+}
+/** Colored, themed sigil for one frame. */
+export function sigilLines(theme, values, frame = 0) {
+    const sig = renderThemedSigil(theme, values, frame);
+    return sig.grid.map((row) => "     " + paintGlyphRow(theme, row));
+}
+/** The persona materializing — sparse → full over a few frames. */
+export async function awaken(fm, state) {
+    const theme = personaTheme(fm);
+    const name = displayName(fm);
+    write("  " + chalk.bold.ansi256(theme.palette.accent)(name) + chalk.dim(`  ·  sigil #${theme.seed.toString(16)}\n\n`));
+    const lines = sigilLines(theme, state.values, 0);
+    if (!supportsAnim()) {
+        write(lines.join("\n") + "\n\n");
+        return;
+    }
+    // reveal mask: rows appear from the center outward
+    const order = [...lines.keys()].sort((a, b) => Math.abs(a - lines.length / 2) - Math.abs(b - lines.length / 2));
+    const shown = new Set();
+    for (const idx of order) {
+        shown.add(idx);
+        write("\x1b[s"); // save cursor
+        for (let i = 0; i < lines.length; i++)
+            write("\x1b[2K" + (shown.has(i) ? lines[i] : "") + "\n");
+        write("\x1b[u"); // restore cursor
+        await sleep(60);
+    }
+    write("\x1b[" + lines.length + "B");
+    write("\n");
+}
+/** A colored aura/mood gauge for the prompt + dashboard. */
+export function auraBar(theme, values, frame = 0) {
+    const intensity = themeIntensity(theme, values, frame);
+    const ticks = 11;
+    const lit = Math.round(intensity * (ticks - 1));
+    let bar = "";
+    for (let i = 0; i < ticks; i++) {
+        bar += i <= lit ? chalk.ansi256(theme.palette.primary)("◈") : chalk.ansi256(theme.palette.dim)("·");
+    }
+    return bar;
+}
+/** Envelope bars colored in the persona's palette. */
+export function envelopeBars(theme, values, envelopes, width = 18) {
+    const rows = [];
+    for (const [k, v] of Object.entries(values)) {
+        const e = envelopes[k];
+        if (!e)
+            continue;
+        const pos = barIndex(v, { ...e, mean: 0 }, width);
+        let bar = "";
+        for (let i = 0; i < width; i++)
+            bar += i === pos ? chalk.ansi256(theme.palette.accent)("◉") : chalk.ansi256(theme.palette.dim)("─");
+        rows.push(`  ${k.padEnd(28)} ${bar} ${chalk.dim(v.toFixed(2))}`);
+    }
+    return rows.join("\n");
+}
+/** Per-event flourish — themed glyphs + color, distinct per event kind. */
+export function eventLine(theme, e) {
+    const p = (n) => chalk.ansi256(n);
+    const trunc = (s, n) => (s.length > n ? s.slice(0, n - 1) + "…" : s);
+    switch (e.type) {
+        case "observe":
+            return chalk.dim(`  ◌ observe  [${e.source}] ${trunc(e.observation, 66)}`);
+        case "appraise":
+            return p(theme.palette.secondary)(`  ◍ appraise `) + chalk.dim(`${trunc(e.signal.appraisal, 60)} (conf ${e.signal.confidence.toFixed(2)})`);
+        case "govern": {
+            const ok = e.verdicts.filter((v) => v.admitted).length;
+            return chalk.dim(`  ◇ govern   ${ok} admitted, ${e.verdicts.length - ok} rejected`);
+        }
+        case "mutate": {
+            const r = e.result;
+            const ripple = p(theme.palette.accent)("◦○◉○◦");
+            return `  ${ripple} ${chalk.bold(r.entry.field)} ${r.from.toFixed(3)}→${r.to.toFixed(3)}` +
+                (r.clamped ? chalk.yellow(" clamped") : "") + (r.blocked ? chalk.red(" blocked") : "");
+        }
+        case "memory":
+            return p(theme.palette.primary)(`  ✶ memory  `) + chalk.dim(`[${e.entry.source}] ${trunc(e.entry.content, 52)} #${e.entry.hash.slice(0, 8)}`);
+        case "anomaly":
+            return chalk.bgRed.whiteBright(` ! ${e.kind} `) + chalk.red(` ${e.detail}`);
+        case "recompile":
+            return p(theme.palette.secondary)(`  ↻ live-sync  ${e.reason}`);
+        case "abstain":
+            return chalk.yellow(`  ⊘ abstain  ${e.reason}`);
+        case "error":
+            return chalk.red(`  ✗ ${e.message}`);
+        case "tick-complete":
+            return chalk.dim(`  ─ ${e.mutationsApplied} mutation(s), ${e.memoriesWritten} memory write(s)`);
+        default:
+            return null;
+    }
+}
+/** Style a line of output to the persona's voice. */
+export function voiceWrap(theme, text) {
+    switch (theme.voice.density) {
+        case "terse":
+            return chalk.ansi256(theme.palette.dim)(text);
+        case "expansive":
+            return chalk.ansi256(theme.palette.accent)("◇ ") + chalk.ansi256(theme.palette.primary)(text);
+        default:
+            return chalk.ansi256(theme.palette.primary)(text);
+    }
+}
+export async function farewell(fm) {
+    const theme = personaTheme(fm);
+    write("\n" + chalk.ansi256(theme.palette.dim)("  persona sleeping. state + memory persisted.") + "\n");
+}
+/** Loop a renderer for `frames` at `interval`ms (TTY only), clearing each frame. */
+export async function play(render, frames, interval) {
+    if (!supportsAnim()) {
+        write(render(0) + "\n");
+        return;
+    }
+    for (let f = 0; f < frames; f++) {
+        write("\x1b[2J\x1b[H" + render(f));
+        await sleep(interval);
+    }
+}

package/package.json

@@ -0,0 +1,53 @@
+{
+  "name": "@personaxis/tui",
+  "version": "0.11.0",
+  "description": "Personaxis TUI — Ink 7 components (living dashboard, streaming transcript with commit queue, brand sigil/aura) + the pre-Ink REPL line editor (until F3.6).",
+  "license": "MIT",
+  "type": "module",
+  "main": "dist/index.js",
+  "exports": {
+    ".": "./dist/index.js",
+    "./visual": "./dist/visual.js",
+    "./screen": "./dist/screen.js",
+    "./ink": "./dist/ink.js"
+  },
+  "bin": {
+    "personaxis-dash": "dist/bin.js"
+  },
+  "files": [
+    "dist"
+  ],
+  "dependencies": {
+    "chalk": "^5.4.1",
+    "ink": "^7.1.0",
+    "react": "^19.0.0",
+    "marked": "^15.0.0",
+    "marked-terminal": "^7.3.0",
+    "ink-text-input": "^6.0.0",
+    "zustand": "^5.0.0",
+    "diff": "^7.0.0",
+    "@personaxis/core": "0.11.0",
+    "@personaxis/protocol": "0.11.0"
+  },
+  "devDependencies": {
+    "@types/node": "^22.10.0",
+    "typescript": "^5.8.3",
+    "vitest": "^3.0.0",
+    "@types/react": "^19.0.0",
+    "@types/diff": "^7.0.0",
+    "ink-testing-library": "^4.0.0"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/personaxis/cli.git",
+    "directory": "packages/tui"
+  },
+  "scripts": {
+    "build": "tsc",
+    "lint": "tsc --noEmit",
+    "test": "vitest run"
+  }
+}