mu-harness 0.16.3

package/esm/harness/npm/src/session/store.js

@@ -0,0 +1,24 @@
+import { appendFile, mkdir, readFile, rm } from 'node:fs/promises';
+import { join } from 'node:path';
+const EXT = '.jsonl';
+const fileFor = (dir, id) => {
+    if (!/^[\w-]+$/.test(id))
+        throw new Error(`SessionStore: invalid session id "${id}"`);
+    return join(dir, `${id}${EXT}`);
+};
+export const createSessionStore = ({ dir }) => ({
+    load: async (id) => {
+        const raw = await readFile(fileFor(dir, id), 'utf-8');
+        const messages = raw.split('\n').filter(Boolean).map((line) => JSON.parse(line));
+        return { id, messages };
+    },
+    append: async (id, messages) => {
+        if (messages.length === 0)
+            return;
+        await mkdir(dir, { recursive: true });
+        await appendFile(fileFor(dir, id), messages.map((message) => `${JSON.stringify(message)}\n`).join(''));
+    },
+    delete: async (id) => {
+        await rm(fileFor(dir, id), { force: true });
+    },
+});

package/esm/harness/npm/src/session/title.d.ts

@@ -0,0 +1,9 @@
+export declare const titleFallback: (text: string, max?: number) => string;
+export declare const cleanTitle: (raw: string, max?: number) => string;
+export interface RunTitlerOptions {
+    id: string;
+    text: string;
+    setTitle(id: string, title: string): void | Promise<void>;
+    generate(text: string): Promise<string>;
+}
+export declare const runTitler: (options: RunTitlerOptions) => Promise<void>;

package/esm/harness/npm/src/session/title.js

@@ -0,0 +1,24 @@
+export const titleFallback = (text, max = 50) => {
+    const clean = text.replace(/\s+/g, ' ').trim();
+    return clean.length > max ? `${clean.slice(0, max - 1)}…` : clean;
+};
+export const cleanTitle = (raw, max = 60) => {
+    const line = raw
+        .replace(/<think>[\s\S]*?<\/think>/g, '')
+        .split('\n')
+        .map((entry) => entry.trim())
+        .find((entry) => entry.length > 0) ?? '';
+    const unquoted = line.replace(/^["'`]+|["'`]+$/g, '').trim();
+    return unquoted.length > max ? `${unquoted.slice(0, max - 1)}…` : unquoted;
+};
+export const runTitler = async (options) => {
+    await options.setTitle(options.id, titleFallback(options.text));
+    try {
+        const title = cleanTitle(await options.generate(options.text));
+        if (title)
+            await options.setTitle(options.id, title);
+    }
+    catch {
+        // keep the fallback
+    }
+};

package/esm/harness/npm/src/session/types.d.ts

@@ -0,0 +1,17 @@
+import type { ContentPart, LoopEvent, Message } from 'mu-core';
+export type AgentSessionEvent = {
+    type: 'turn_start';
+    input: Message;
+} | LoopEvent | {
+    type: 'turn_end';
+} | {
+    type: 'error';
+    error: unknown;
+};
+export interface AgentSession {
+    readonly id: string;
+    readonly messages: readonly Message[];
+    send(input: string | ContentPart[]): Promise<void>;
+    abort(): void;
+    subscribe(listener: (event: AgentSessionEvent) => void): () => void;
+}

package/esm/harness/npm/src/session/types.js

@@ -0,0 +1 @@
+export {};

package/esm/harness/npm/src/skills/index.d.ts

@@ -0,0 +1,7 @@
+export type { Skill } from './types.js';
+export { createSkillRegistry, type SkillRegistry } from './registry.js';
+export { parseSkill } from './parser.js';
+export { loadSkills } from './loader.js';
+export { createSkillTool } from './tool.js';
+export { createSkillWriterTool } from './writer.js';
+export { createRunSkillTool, runSkill, type RunSkillDeps } from './run.js';

package/esm/harness/npm/src/skills/index.js

@@ -0,0 +1,6 @@
+export { createSkillRegistry } from './registry.js';
+export { parseSkill } from './parser.js';
+export { loadSkills } from './loader.js';
+export { createSkillTool } from './tool.js';
+export { createSkillWriterTool } from './writer.js';
+export { createRunSkillTool, runSkill } from './run.js';

package/esm/harness/npm/src/skills/loader.d.ts

@@ -0,0 +1,2 @@
+import type { Skill } from './types.js';
+export declare const loadSkills: (dir: string) => Promise<Skill[]>;

package/esm/harness/npm/src/skills/loader.js

@@ -0,0 +1,26 @@
+import { readdir, readFile, stat } from 'node:fs/promises';
+import { join } from 'node:path';
+import { parseSkill } from './parser.js';
+export const loadSkills = async (dir) => {
+    let entries;
+    try {
+        entries = await readdir(dir);
+    }
+    catch {
+        return [];
+    }
+    const skills = [];
+    for (const entry of entries.sort()) {
+        const skillDir = join(dir, entry);
+        try {
+            if (!(await stat(skillDir)).isDirectory())
+                continue;
+            const source = await readFile(join(skillDir, 'SKILL.md'), 'utf-8');
+            skills.push(parseSkill(source, entry, skillDir));
+        }
+        catch {
+            continue;
+        }
+    }
+    return skills;
+};

package/esm/harness/npm/src/skills/parser.d.ts

@@ -0,0 +1,2 @@
+import type { Skill } from './types.js';
+export declare const parseSkill: (source: string, fallbackName: string, dir?: string) => Skill;

package/esm/harness/npm/src/skills/parser.js

@@ -0,0 +1,10 @@
+import { parseFrontmatter, str } from '../common/index.js';
+export const parseSkill = (source, fallbackName, dir) => {
+    const { fields, body } = parseFrontmatter(source);
+    return {
+        name: str(fields.name) ?? fallbackName,
+        description: str(fields.description) ?? '',
+        prompt: body,
+        dir,
+    };
+};

package/esm/harness/npm/src/skills/registry.d.ts

@@ -0,0 +1,8 @@
+import type { Skill } from './types.js';
+export interface SkillRegistry {
+    list(): Skill[];
+    get(name: string): Skill | undefined;
+    add(skill: Skill): void;
+    select(names: string[]): SkillRegistry;
+}
+export declare const createSkillRegistry: (skills?: Skill[]) => SkillRegistry;

package/esm/harness/npm/src/skills/registry.js

@@ -0,0 +1,16 @@
+export const createSkillRegistry = (skills = []) => {
+    const byName = new Map();
+    for (const skill of skills)
+        if (!byName.has(skill.name))
+            byName.set(skill.name, skill);
+    const view = (allow) => ({
+        list: () => [...byName.values()].filter((skill) => !allow || allow.has(skill.name)),
+        get: (name) => (!allow || allow.has(name) ? byName.get(name) : undefined),
+        add: (skill) => {
+            byName.set(skill.name, skill);
+            allow?.add(skill.name);
+        },
+        select: (names) => view(new Set(allow ? names.filter((name) => allow.has(name)) : names)),
+    });
+    return view();
+};

package/esm/harness/npm/src/skills/run.d.ts

@@ -0,0 +1,14 @@
+import type { Tool } from 'mu-core';
+import type { AgentRegistry } from '../agents/index.js';
+import { type RunSubAgentDeps } from '../subAgents/index.js';
+import type { SkillRegistry } from './registry.js';
+export interface RunSkillDeps extends RunSubAgentDeps {
+    skills: SkillRegistry;
+    agents?: AgentRegistry;
+}
+export declare const runSkill: (deps: RunSkillDeps, args: {
+    skill: string;
+    task: string;
+    agent: string;
+}) => Promise<string>;
+export declare const createRunSkillTool: (deps: RunSkillDeps) => Tool;

package/esm/harness/npm/src/skills/run.js

@@ -0,0 +1,45 @@
+import { runSubAgent } from '../subAgents/index.js';
+export const runSkill = async (deps, args) => {
+    const skill = deps.skills.get(args.skill);
+    if (!skill)
+        throw new Error(`unknown skill "${args.skill}"`);
+    const base = deps.agents?.get(args.agent);
+    if (!base)
+        throw new Error(`unknown agent "${args.agent}"`);
+    const agent = {
+        name: base.name,
+        description: skill.description,
+        prompt: [base.prompt, skill.prompt].filter(Boolean).join('\n\n'),
+        tools: base.tools,
+        model: base.model,
+    };
+    const result = await runSubAgent(agent, args.task, deps);
+    return result.text;
+};
+export const createRunSkillTool = (deps) => ({
+    name: 'run_skill',
+    description: 'Invoke a sub-agent equipped with a named skill to carry out a specific task. Returns its final answer.',
+    prompt: 'To carry out a self-contained task under a skill, call `run_skill` with the skill name, the task, and the agent persona to run it as.',
+    parameters: {
+        type: 'object',
+        properties: {
+            skill: { type: 'string', description: 'Skill name to equip the agent with.' },
+            task: { type: 'string', description: 'The precise task to carry out.' },
+            agent: { type: 'string', description: 'Agent persona to run the skill as (defines its tools).' },
+        },
+        required: ['skill', 'task', 'agent'],
+        additionalProperties: false,
+    },
+    run: async (input) => {
+        const { skill, task, agent } = (input ?? {});
+        if (!skill || !task || !agent) {
+            return [{ type: 'text', text: 'Error: run_skill requires `skill`, `task`, and `agent`.' }];
+        }
+        try {
+            return [{ type: 'text', text: await runSkill(deps, { skill, task, agent }) }];
+        }
+        catch (error) {
+            return [{ type: 'text', text: `Error: ${error instanceof Error ? error.message : String(error)}` }];
+        }
+    },
+});

package/esm/harness/npm/src/skills/tool.d.ts

@@ -0,0 +1,3 @@
+import type { Tool } from 'mu-core';
+import type { SkillRegistry } from './registry.js';
+export declare const createSkillTool: (registry: SkillRegistry) => Tool;

package/esm/harness/npm/src/skills/tool.js

@@ -0,0 +1,31 @@
+export const createSkillTool = (registry) => ({
+    name: 'skill',
+    description: "Load a named skill's instructions into the conversation, then follow them.",
+    get prompt() {
+        const list = registry.list();
+        if (!list.length)
+            return undefined;
+        const catalog = list.map((skill) => `- ${skill.name}${skill.description ? `: ${skill.description}` : ''}`).join('\n');
+        return `When a request matches one of these skills, call \`skill\` with its name BEFORE acting, then follow the returned instructions:\n${catalog}`;
+    },
+    parameters: {
+        type: 'object',
+        properties: {
+            name: { type: 'string', description: 'Skill name.' },
+        },
+        required: ['name'],
+        additionalProperties: false,
+    },
+    run: async (input) => {
+        const { name } = (input ?? {});
+        if (!name)
+            return [{ type: 'text', text: 'Error: skill requires `name`.' }];
+        const skill = registry.get(name);
+        if (!skill)
+            return [{ type: 'text', text: `Error: unknown skill "${name}".` }];
+        const header = skill.dir
+            ? `Skill "${skill.name}" (bundled files live under ${skill.dir}):\n\n`
+            : `Skill "${skill.name}":\n\n`;
+        return [{ type: 'text', text: header + skill.prompt }];
+    },
+});

package/esm/harness/npm/src/skills/types.d.ts

@@ -0,0 +1,6 @@
+export interface Skill {
+    name: string;
+    description: string;
+    prompt: string;
+    dir?: string;
+}

package/esm/harness/npm/src/skills/types.js

@@ -0,0 +1 @@
+export {};

package/esm/harness/npm/src/skills/writer.d.ts

@@ -0,0 +1,7 @@
+import type { Tool } from 'mu-core';
+import type { SkillRegistry } from './registry.js';
+export type SkillScope = 'local' | 'config';
+export declare const createSkillWriterTool: (deps: {
+    dirs: Record<SkillScope, string>;
+    registry: SkillRegistry;
+}) => Tool;

package/esm/harness/npm/src/skills/writer.js

@@ -0,0 +1,43 @@
+import { mkdir, writeFile } from 'node:fs/promises';
+import { join } from 'node:path';
+import { parseSkill } from './parser.js';
+const slug = (name) => name.trim().toLowerCase().replace(/[^a-z0-9]+/g, '-').replace(/^-+|-+$/g, '');
+export const createSkillWriterTool = (deps) => ({
+    name: 'create_skill',
+    description: 'Create a reusable skill: a named set of instructions the agent can load on demand later.',
+    prompt: 'When you discover a reusable workflow worth keeping, capture it with `create_skill` (name, description, instructions). Use `scope: "local"` for a skill specific to this project, or `scope: "config"` to make it available across all projects. It can then be loaded via `skill`.',
+    parameters: {
+        type: 'object',
+        properties: {
+            name: { type: 'string', description: 'Short skill name (kebab-case).' },
+            description: { type: 'string', description: 'One line describing when this skill should be used.' },
+            instructions: { type: 'string', description: 'The skill body: the instructions to follow when it is invoked.' },
+            scope: {
+                type: 'string',
+                enum: ['local', 'config'],
+                description: 'Where to save it: "local" = this project (<cwd>/skills), "config" = global config dir. Defaults to "local".',
+            },
+        },
+        required: ['name', 'description', 'instructions'],
+        additionalProperties: false,
+    },
+    run: async (input) => {
+        const { name, description, instructions, scope } = (input ?? {});
+        if (!name || !description || !instructions) {
+            return [{ type: 'text', text: 'Error: create_skill requires `name`, `description`, and `instructions`.' }];
+        }
+        const base = deps.dirs[scope ?? 'local'];
+        if (!base)
+            return [{ type: 'text', text: `Error: unknown scope "${scope}".` }];
+        const id = slug(name);
+        if (!id)
+            return [{ type: 'text', text: `Error: invalid skill name "${name}".` }];
+        const skillDir = join(base, id);
+        const file = join(skillDir, 'SKILL.md');
+        const source = `---\nname: ${id}\ndescription: ${JSON.stringify(description)}\n---\n\n${instructions.trim()}\n`;
+        await mkdir(skillDir, { recursive: true });
+        await writeFile(file, source, 'utf-8');
+        deps.registry.add(parseSkill(source, id, skillDir));
+        return [{ type: 'text', text: `Created skill "${id}" at ${file}. It is now available via the \`skill\` tool.` }];
+    },
+});

package/esm/harness/npm/src/subAgents/index.d.ts

@@ -0,0 +1,4 @@
+export type { SubAgentRegistry, SubAgentResult, SubAgentRun } from './types.js';
+export { createSubAgentRegistry } from './registry.js';
+export { runSubAgent, type RunSubAgentDeps } from './runner.js';
+export { createSubAgentTool } from './tool.js';

package/esm/harness/npm/src/subAgents/index.js

@@ -0,0 +1,3 @@
+export { createSubAgentRegistry } from './registry.js';
+export { runSubAgent } from './runner.js';
+export { createSubAgentTool } from './tool.js';

package/esm/harness/npm/src/subAgents/registry.d.ts

@@ -0,0 +1,2 @@
+import type { SubAgentRegistry } from './types.js';
+export declare const createSubAgentRegistry: () => SubAgentRegistry;

package/esm/harness/npm/src/subAgents/registry.js

@@ -0,0 +1,18 @@
+export const createSubAgentRegistry = () => {
+    const runs = new Map();
+    const listeners = new Set();
+    return {
+        register: (run) => {
+            runs.set(run.runId, run);
+            for (const listener of listeners)
+                listener(run);
+        },
+        get: (runId) => runs.get(runId),
+        list: () => [...runs.values()],
+        byParent: (parentId) => [...runs.values()].filter((run) => run.parentId === parentId),
+        subscribe: (listener) => {
+            listeners.add(listener);
+            return () => listeners.delete(listener);
+        },
+    };
+};

package/esm/harness/npm/src/subAgents/runner.d.ts

@@ -0,0 +1,15 @@
+import type { Agent } from '../agents/index.js';
+import type { AgentSession } from '../session/index.js';
+import type { SubAgentRegistry, SubAgentResult } from './types.js';
+export interface RunSubAgentDeps {
+    spawn(agent: Agent): AgentSession;
+    /** When provided, the spawned run is registered (so hosts can read/observe it). */
+    runs?: SubAgentRegistry;
+    /** Parent session id the run is attributed to. */
+    parentId?: string;
+    /** Run id; defaults to the spawned session's id so persistence keys align. */
+    runId?: string;
+    /** Aborts the spawned session when the parent turn is cancelled. */
+    signal?: AbortSignal;
+}
+export declare const runSubAgent: (agent: Agent, task: string, deps: RunSubAgentDeps) => Promise<SubAgentResult>;

package/esm/harness/npm/src/subAgents/runner.js

@@ -0,0 +1,33 @@
+const finalText = (session) => {
+    for (let i = session.messages.length - 1; i >= 0; i--) {
+        const message = session.messages[i];
+        if (message.role === 'assistant') {
+            return message.content.map((part) => (part.type === 'text' ? part.text : '')).join('');
+        }
+    }
+    return '';
+};
+export const runSubAgent = async (agent, task, deps) => {
+    const session = deps.spawn(agent);
+    deps.runs?.register({ runId: deps.runId ?? session.id, agent: agent.name, parentId: deps.parentId, session });
+    const { signal } = deps;
+    if (signal?.aborted)
+        session.abort();
+    const onAbort = () => session.abort();
+    signal?.addEventListener('abort', onAbort, { once: true });
+    let failure;
+    const unsubscribe = session.subscribe((event) => {
+        if (event.type === 'error')
+            failure = event.error;
+    });
+    try {
+        await session.send(task);
+    }
+    finally {
+        unsubscribe();
+        signal?.removeEventListener('abort', onAbort);
+    }
+    if (failure !== undefined)
+        throw failure instanceof Error ? failure : new Error(String(failure));
+    return { agent: agent.name, text: finalText(session) };
+};

package/esm/harness/npm/src/subAgents/tool.d.ts

@@ -0,0 +1,6 @@
+import type { Tool } from 'mu-core';
+import type { AgentRegistry } from '../agents/index.js';
+import { type RunSubAgentDeps } from './runner.js';
+export declare const createSubAgentTool: (deps: {
+    registry: AgentRegistry;
+} & RunSubAgentDeps) => Tool;

package/esm/harness/npm/src/subAgents/tool.js

@@ -0,0 +1,30 @@
+import { runSubAgent } from './runner.js';
+export const createSubAgentTool = (deps) => ({
+    name: 'subagent',
+    description: 'Delegate an isolated task to a named sub-agent. Returns its final answer.',
+    prompt: 'Delegate self-contained research or sub-tasks to a named sub-agent with `subagent`; treat its answer as research input.',
+    parameters: {
+        type: 'object',
+        properties: {
+            agent: { type: 'string', description: 'Sub-agent name.' },
+            task: { type: 'string', description: 'The task to delegate.' },
+        },
+        required: ['agent', 'task'],
+        additionalProperties: false,
+    },
+    run: async (input, ctx) => {
+        const { agent, task } = (input ?? {});
+        if (!agent || !task)
+            return [{ type: 'text', text: 'Error: subagent requires `agent` and `task`.' }];
+        const def = deps.registry.get(agent);
+        if (!def)
+            return [{ type: 'text', text: `Error: unknown sub-agent "${agent}".` }];
+        const result = await runSubAgent(def, task, {
+            spawn: deps.spawn,
+            runs: deps.runs,
+            parentId: deps.parentId,
+            signal: ctx.signal,
+        });
+        return [{ type: 'text', text: result.text }];
+    },
+});

package/esm/harness/npm/src/subAgents/types.d.ts

@@ -0,0 +1,18 @@
+import type { AgentSession } from '../session/index.js';
+export interface SubAgentResult {
+    agent: string;
+    text: string;
+}
+export interface SubAgentRun {
+    runId: string;
+    agent: string;
+    parentId?: string;
+    session: AgentSession;
+}
+export interface SubAgentRegistry {
+    register(run: SubAgentRun): void;
+    get(runId: string): SubAgentRun | undefined;
+    list(): SubAgentRun[];
+    byParent(parentId: string): SubAgentRun[];
+    subscribe(listener: (run: SubAgentRun) => void): () => void;
+}

package/esm/harness/npm/src/subAgents/types.js

@@ -0,0 +1 @@
+export {};

package/esm/harness/npm/src/tui/channel.d.ts

@@ -0,0 +1,3 @@
+import type { Channel } from '../channels/index.js';
+import type { ChatApp, ChatAppOptions } from './types.js';
+export declare const createChatApp: (channel: Channel, opts?: ChatAppOptions) => ChatApp;

package/esm/harness/npm/src/tui/channel.js

@@ -0,0 +1,53 @@
+import { flex, ProcessTerminal, TUI } from 'mu-tui';
+import { composer, header, message, status, transcript } from './components/index.js';
+import { defaultKit } from './kit.js';
+const defaultLayout = (parts, ctx) => ctx.components.column([parts.header, flex(parts.transcript), parts.status, parts.composer]);
+export const createChatApp = (channel, opts = {}) => {
+    const slots = opts.slots ?? {};
+    const components = { ...defaultKit, ...opts.components };
+    const resolveMessage = slots.message ?? message;
+    const ctx = {
+        channel,
+        components,
+        renderMessage: (msg) => resolveMessage(msg, ctx),
+        status: { current: 'idle' },
+    };
+    const parts = {
+        header: (slots.header ?? header)(ctx),
+        transcript: (slots.transcript ?? transcript)(ctx),
+        status: (slots.status ?? status)(ctx),
+        composer: (slots.composer ?? composer)(ctx),
+    };
+    const root = (slots.layout ?? defaultLayout)(parts, ctx);
+    const terminal = opts.terminal ?? new ProcessTerminal({ bracketedPaste: true, focusEvents: true });
+    const tui = new TUI(terminal);
+    const unsubscribe = channel.subscribe((event) => {
+        if (event.type === 'turn_start')
+            ctx.status.current = 'thinking';
+        else if (event.type === 'turn_end')
+            ctx.status.current = 'idle';
+        else if (event.type === 'error')
+            ctx.status.current = 'error';
+        tui.requestRender();
+    });
+    tui.setRoot(root);
+    tui.setFocus(parts.composer);
+    const stop = () => {
+        unsubscribe();
+        tui.stop();
+    };
+    return {
+        tui,
+        start: () => {
+            tui.addGlobalKeybinding({
+                chord: { key: 'c', ctrl: true },
+                handler: () => {
+                    stop();
+                    opts.onExit?.();
+                },
+            });
+            tui.start();
+        },
+        stop,
+    };
+};

package/esm/harness/npm/src/tui/components/composer.d.ts

@@ -0,0 +1,3 @@
+import type { Component } from 'mu-tui';
+import type { ChatContext } from '../types.js';
+export declare const composer: (ctx: ChatContext) => Component;

package/esm/harness/npm/src/tui/components/composer.js

@@ -0,0 +1,13 @@
+export const composer = (ctx) => {
+    const input = ctx.components.editor({
+        placeholder: 'Message…',
+        onSubmit: (value) => {
+            const trimmed = value.trim();
+            if (!trimmed)
+                return;
+            input.setValue('');
+            void ctx.channel.send(trimmed);
+        },
+    });
+    return input;
+};

package/esm/harness/npm/src/tui/components/header.d.ts

@@ -0,0 +1,3 @@
+import type { Component } from 'mu-tui';
+import type { ChatContext } from '../types.js';
+export declare const header: (ctx: ChatContext) => Component;

package/esm/harness/npm/src/tui/components/header.js

@@ -0,0 +1 @@
+export const header = (ctx) => ctx.components.text(`\x1b[1m${ctx.channel.title}\x1b[0m`);

package/esm/harness/npm/src/tui/components/index.d.ts

@@ -0,0 +1,5 @@
+export { composer } from './composer.js';
+export { header } from './header.js';
+export { formatMessage, message, partToText } from './message.js';
+export { status } from './status.js';
+export { messagesView, transcript } from './transcript.js';

package/esm/harness/npm/src/tui/components/index.js

@@ -0,0 +1,5 @@
+export { composer } from './composer.js';
+export { header } from './header.js';
+export { formatMessage, message, partToText } from './message.js';
+export { status } from './status.js';
+export { messagesView, transcript } from './transcript.js';

package/esm/harness/npm/src/tui/components/message.d.ts

@@ -0,0 +1,6 @@
+import type { ContentPart, Message } from 'mu-core';
+import type { Component } from 'mu-tui';
+import type { ChatContext } from '../types.js';
+export declare const partToText: (part: ContentPart) => string;
+export declare const formatMessage: (message: Message) => string;
+export declare const message: (msg: Message, ctx: ChatContext) => Component;

package/esm/harness/npm/src/tui/components/message.js

@@ -0,0 +1,26 @@
+export const partToText = (part) => {
+    switch (part.type) {
+        case 'text':
+            return part.text;
+        case 'tool_call':
+            return `\x1b[2m[${part.name}]\x1b[0m`;
+        case 'tool_result':
+            return part.content.map(partToText).join('');
+        case 'image':
+            return '\x1b[2m[image]\x1b[0m';
+        case 'audio':
+            return '\x1b[2m[audio]\x1b[0m';
+    }
+};
+const isToolResults = (message) => message.content.length > 0 && message.content.every((part) => part.type === 'tool_result');
+const label = (message) => {
+    if (isToolResults(message))
+        return '\x1b[2mtool\x1b[0m';
+    if (message.role === 'user')
+        return '\x1b[36myou\x1b[0m';
+    if (message.role === 'assistant')
+        return '\x1b[32magent\x1b[0m';
+    return `\x1b[2m${message.role}\x1b[0m`;
+};
+export const formatMessage = (message) => `${label(message)}  ${message.content.map(partToText).join('')}`;
+export const message = (msg, ctx) => ctx.components.text(formatMessage(msg));

package/esm/harness/npm/src/tui/components/status.d.ts

@@ -0,0 +1,3 @@
+import type { Component } from 'mu-tui';
+import type { ChatContext } from '../types.js';
+export declare const status: (ctx: ChatContext) => Component;

package/esm/harness/npm/src/tui/components/status.js

@@ -0,0 +1,8 @@
+const LABELS = {
+    idle: '\x1b[2m● ready\x1b[0m',
+    thinking: '\x1b[33m◍ thinking…\x1b[0m',
+    error: '\x1b[31m✗ error\x1b[0m',
+};
+export const status = (ctx) => ({
+    render: (s) => ctx.components.text(LABELS[ctx.status.current]).render(s),
+});

package/esm/harness/npm/src/tui/components/transcript.d.ts

@@ -0,0 +1,4 @@
+import type { Component } from 'mu-tui';
+import type { ChatContext } from '../types.js';
+export declare const messagesView: (ctx: ChatContext) => Component;
+export declare const transcript: (ctx: ChatContext) => Component;