@xingular/harness 0.1.7 → 1.1.1

package/dist/sdk/terminal/tui/sessionUi.d.ts

@@ -0,0 +1,3 @@
+import type { ExtensionUIContext } from '@earendil-works/pi-coding-agent';
+/** Retained UI methods belong to the resource generation that received them. */
+export declare function sessionUiContext(ui: ExtensionUIContext, current: () => boolean): ExtensionUIContext;

package/dist/sdk/terminal/tui/sessionUi.js

@@ -0,0 +1,30 @@
+const dialogs = new Set(['select', 'input', 'editor', 'custom']);
+/** Retained UI methods belong to the resource generation that received them. */
+export function sessionUiContext(ui, current) {
+    return new Proxy(ui, {
+        get(target, key, receiver) {
+            const value = Reflect.get(target, key, receiver);
+            if (typeof value !== 'function')
+                return value;
+            return (...args) => {
+                if (current())
+                    return Reflect.apply(value, target, args);
+                if (key === 'confirm')
+                    return Promise.resolve(false);
+                if (dialogs.has(String(key)))
+                    return Promise.resolve(undefined);
+                if (key === 'onTerminalInput')
+                    return () => { };
+                if (key === 'setTheme')
+                    return { success: false, error: 'This terminal session has ended.' };
+                if (key === 'getEditorText')
+                    return '';
+                if (key === 'getToolsExpanded')
+                    return false;
+                if (key === 'getAllThemes')
+                    return [];
+                return undefined;
+            };
+        }
+    });
+}

package/dist/sdk/terminal/tui/settingsModel.d.ts

@@ -0,0 +1,14 @@
+import type { AgentSession, ExtensionUIContext } from '@earendil-works/pi-coding-agent';
+import type { TerminalSettingItem } from "./pages/settingsPage.js";
+export interface SettingsModelHost {
+    session(): AgentSession;
+    ui: ExtensionUIContext;
+    control<T = unknown>(method: string, params?: Record<string, unknown>): Promise<T>;
+    hotkeys?(): string;
+    refresh(): void;
+}
+export declare function createSettingsModel(host: SettingsModelHost): {
+    items: () => TerminalSettingItem[];
+    apply: (id: string) => Promise<void>;
+    load: () => Promise<void>;
+};

package/dist/sdk/terminal/tui/settingsModel.js

@@ -0,0 +1,114 @@
+const PRIVATE_ACCESS_ID = 'browser.allowPrivate';
+const GROUP_ORDER = ['Theme', 'Display', 'Images', 'Thinking', 'Recovery', 'Editor', 'Queues', 'Commands', 'Terminal', 'Keyboard', 'Compaction', 'Network'];
+export function createSettingsModel(host) {
+    let browserSettings = null;
+    const booleans = (session) => {
+        const settings = session.settingsManager;
+        return [
+            ['Auto compaction', () => session.autoCompactionEnabled, (value) => session.setAutoCompactionEnabled(value)],
+            ['Auto retry', () => session.autoRetryEnabled, (value) => session.setAutoRetryEnabled(value)],
+            ['Show images', () => settings.getShowImages(), (value) => settings.setShowImages(value)],
+            ['Resize images', () => settings.getImageAutoResize(), (value) => settings.setImageAutoResize(value)],
+            ['Block images', () => settings.getBlockImages(), (value) => settings.setBlockImages(value)],
+            ['Skill commands', () => settings.getEnableSkillCommands(), (value) => settings.setEnableSkillCommands(value)],
+            ['Hide thinking', () => settings.getHideThinkingBlock(), (value) => settings.setHideThinkingBlock(value)],
+            ['Hardware cursor', () => settings.getShowHardwareCursor(), (value) => settings.setShowHardwareCursor(value)],
+            ['Terminal progress', () => settings.getShowTerminalProgress(), (value) => settings.setShowTerminalProgress(value)]
+        ];
+    };
+    const locations = [
+        ['Context', 'Compaction'], ['Model', 'Recovery'], ['Appearance', 'Images'], ['Appearance', 'Images'],
+        ['Context', 'Images'], ['Interaction', 'Commands'], ['Appearance', 'Display'], ['Interaction', 'Editor'],
+        ['Interaction', 'Terminal'], ['Model', 'Thinking'], ['Interaction', 'Queues'], ['Interaction', 'Queues'],
+        ['Appearance', 'Theme'], ['Interaction', 'Keyboard']
+    ];
+    const descriptions = [
+        'Compact the context automatically when the session approaches its limit.', 'Retry eligible provider failures automatically.',
+        'Display actual image content returned by tools.', 'Resize image attachments before provider requests.',
+        'Block image attachments in provider requests.', 'Expose commands for the skills loaded in this session.',
+        'Collapse assistant thinking blocks in the transcript.', 'Display the terminal hardware cursor for editing and input methods.',
+        'Report active work through supported terminal progress controls.', 'Reasoning effort for the current model.',
+        'Delivery mode for messages that steer an active run.', 'Delivery mode for messages queued after a run.',
+        'Theme loaded from the trusted resource catalog.', 'View the current application keyboard bindings.'
+    ];
+    /** One line per setting, `Label: value`; its position is the setting's id. */
+    const options = (session) => [
+        ...booleans(session).map(([label, get]) => `${label}: ${get() ? 'on' : 'off'}`),
+        `Thinking: ${session.thinkingLevel}`, `Steering: ${session.steeringMode}`, `Follow-up: ${session.followUpMode}`,
+        `Theme: ${host.ui.theme.name}`, 'Keyboard controls'
+    ];
+    function items() {
+        const result = options(host.session()).map((option, index) => {
+            const split = option.indexOf(':');
+            return { id: String(index), tab: locations[index][0], group: locations[index][1], label: split < 0 ? option : option.slice(0, split), value: split < 0 ? '' : option.slice(split + 1).trim(), description: descriptions[index] };
+        });
+        if (browserSettings)
+            result.push({
+                id: PRIVATE_ACCESS_ID,
+                tab: 'Browser',
+                group: 'Network',
+                label: 'Private address access',
+                value: browserSettings.allowPrivate ? 'On' : 'Off',
+                description: 'This device-wide setting affects agent browsing and annotation capture. When on, pages can reach localhost and private networks.'
+            });
+        return result.sort((a, b) => GROUP_ORDER.indexOf(a.group) - GROUP_ORDER.indexOf(b.group));
+    }
+    async function load() {
+        const config = await host.control('terminal.browser.config');
+        if (!config || typeof config.allowPrivate !== 'boolean')
+            throw new Error('The Harness returned invalid browser settings.');
+        browserSettings = { allowPrivate: config.allowPrivate };
+    }
+    async function apply(id) {
+        if (id === PRIVATE_ACCESS_ID) {
+            if (!browserSettings)
+                return;
+            const allowPrivate = !browserSettings.allowPrivate;
+            if (allowPrivate && !await host.ui.confirm('Allow private network addresses?', 'This device-wide setting lets pages opened by agent browsing and annotation capture reach localhost and private networks.'))
+                return;
+            const saved = await host.control('terminal.browser.configure', { allowPrivate });
+            if (!saved || typeof saved.allowPrivate !== 'boolean')
+                throw new Error('The Harness returned invalid browser settings.');
+            browserSettings = { allowPrivate: saved.allowPrivate };
+            host.refresh();
+            return;
+        }
+        const session = host.session();
+        const index = Number(id);
+        const switches = booleans(session);
+        const selected = options(session)[index];
+        if (selected === undefined)
+            return;
+        if (index < switches.length) {
+            const [, get, set] = switches[index];
+            set(!get());
+        }
+        else if (selected.startsWith('Thinking:')) {
+            const level = await host.ui.select('Thinking effort', session.getAvailableThinkingLevels());
+            if (level)
+                session.setThinkingLevel(level, { persist: true });
+        }
+        else if (selected.startsWith('Steering:') || selected.startsWith('Follow-up:')) {
+            const mode = await host.ui.select('Queue delivery', ['all', 'one-at-a-time']);
+            if (mode === 'all' || mode === 'one-at-a-time') {
+                if (selected.startsWith('Steering:'))
+                    session.setSteeringMode(mode);
+                else
+                    session.setFollowUpMode(mode);
+            }
+        }
+        else if (selected.startsWith('Theme:')) {
+            const theme = await host.ui.select('Theme', host.ui.getAllThemes().map(item => item.name));
+            if (theme) {
+                const result = host.ui.setTheme(theme);
+                if (!result.success)
+                    throw new Error(result.error);
+                session.settingsManager.setTheme(theme);
+            }
+        }
+        else
+            host.ui.notify(host.hotkeys?.() ?? 'Use /help for commands. Keyboard bindings are managed by the terminal application.', 'info');
+        host.refresh();
+    }
+    return { items, apply, load };
+}

package/dist/sdk/terminal/tui/sideQuestion.d.ts

@@ -0,0 +1,53 @@
+import type { Theme } from '@earendil-works/pi-coding-agent';
+import { type Component } from '@earendil-works/pi-tui';
+import type { SideQuestionContext, SideQuestionRead } from "../../sessions/sideQuestions.js";
+export type SideState = 'thinking' | 'answered' | 'failed';
+type SideQuestionStart = {
+    runId: string;
+    sessionId: string;
+    nativeSessionId: string | null;
+};
+/** Visible native history and tool activity, with hidden reasoning and image bytes omitted. */
+export declare function sideQuestionSnapshot(messages: readonly unknown[], running: boolean): string;
+export interface SideQuestionOptions {
+    context(): SideQuestionContext;
+    start(question: string, context: SideQuestionContext): Promise<SideQuestionStart>;
+    read(runId: string, afterSequence: number): Promise<SideQuestionRead>;
+    interrupt(runId: string): Promise<unknown>;
+    copyText(text: string): Promise<void>;
+    theme(): Theme;
+    /** Puts the dock above the composer, or takes it away. */
+    mount(dock: Component | undefined): void;
+    changed(): void;
+}
+export declare class SideQuestion {
+    private readonly options;
+    private runId;
+    private generation;
+    private pollTimer;
+    private question;
+    private answerText;
+    private error;
+    private current;
+    private startedAt;
+    private afterSequence;
+    private answerOffset;
+    private readonly dock;
+    constructor(options: SideQuestionOptions);
+    get visible(): boolean;
+    get state(): SideState | undefined;
+    get answer(): string;
+    /** Asks one question, replacing any earlier one. Empty text dismisses. */
+    ask(question: string): Promise<void>;
+    /** Scrolls the answer while it is longer than the dock. */
+    scroll(direction: 'up' | 'down'): void;
+    /** Copies the whole side answer, including any lines outside the dock. */
+    copyAnswer(): Promise<void>;
+    /** Interrupts a running side question and removes the dock. */
+    dismiss(): Promise<void>;
+    private poll;
+    private release;
+    /** The dock: question, a scrollable answer window, and a hint for browsing or copying. */
+    private render;
+}
+export {};

package/dist/sdk/terminal/tui/sideQuestion.js

@@ -0,0 +1,230 @@
+import { truncateToWidth, visibleWidth, wrapTextWithAnsi } from '@earendil-works/pi-tui';
+import { contentWidth, footerRow, neutralRule, padded, safeText } from "./chrome.js";
+import { getWorkingSpinnerFrames, SPINNER_INTERVAL_MS, spinnerFrameAt } from "./workingStatus.js";
+const QUESTION_ROWS = 2;
+const ANSWER_ROWS = 8;
+const MAX_CLIENT_CONTEXT_CHARS = 300_000;
+const POLL_INTERVAL_MS = 160;
+function blocks(content) {
+    if (typeof content === 'string')
+        return [{ type: 'text', text: content }];
+    return Array.isArray(content) ? content.filter((block) => typeof block === 'object' && block !== null) : [];
+}
+function contentText(content) {
+    return blocks(content).filter(block => block.type === 'text' && typeof block.text === 'string').map(block => String(block.text)).join('\n').trim();
+}
+function serialized(value) {
+    if (typeof value === 'string')
+        return value;
+    try {
+        return JSON.stringify(value) ?? '';
+    }
+    catch {
+        return '[unavailable]';
+    }
+}
+/** Visible native history and tool activity, with hidden reasoning and image bytes omitted. */
+export function sideQuestionSnapshot(messages, running) {
+    const lines = [];
+    for (const message of messages) {
+        if (!message || typeof message !== 'object')
+            continue;
+        const item = message;
+        const parts = blocks(item.content);
+        if (item.role === 'user' || item.role === 'assistant') {
+            const text = parts.filter(block => block.type === 'text' && typeof block.text === 'string').map(block => String(block.text)).join('\n').trim();
+            if (text)
+                lines.push(`${item.role === 'user' ? 'User' : 'Assistant'}:\n${safeText(text)}`);
+            for (const call of parts.filter(block => block.type === 'toolCall')) {
+                const name = typeof call.name === 'string' ? call.name : 'unknown tool';
+                lines.push(`Assistant tool call (${name}):\n${safeText(serialized(call.arguments))}`);
+            }
+            if (parts.some(block => block.type === 'image'))
+                lines.push(`${item.role === 'user' ? 'User' : 'Assistant'} attached an image; image bytes are omitted.`);
+        }
+        else if (item.role === 'toolResult') {
+            const name = typeof item.toolName === 'string' ? item.toolName : typeof item.name === 'string' ? item.name : 'unknown tool';
+            const output = contentText(item.content);
+            lines.push(`Tool result (${name}${typeof item.toolCallId === 'string' ? `, ${item.toolCallId}` : ''}):\n${safeText(output || '(no text result)')}`);
+            if (parts.some(block => block.type === 'image'))
+                lines.push('Tool result also contained an image; image bytes are omitted.');
+        }
+    }
+    if (!lines.length)
+        lines.push('(No visible conversation messages yet.)');
+    if (running)
+        lines.push('The main reply is still running; its latest message may be unfinished.');
+    const full = lines.join('\n\n');
+    return full.length > MAX_CLIENT_CONTEXT_CHARS
+        ? `[Earlier visible context omitted to fit the side-question request.]\n\n${full.slice(-MAX_CLIENT_CONTEXT_CHARS)}`
+        : full;
+}
+function payload(event) {
+    return event.payload && typeof event.payload === 'object' ? event.payload : {};
+}
+export class SideQuestion {
+    options;
+    runId;
+    generation = 0;
+    pollTimer;
+    question = '';
+    answerText = '';
+    error;
+    current;
+    startedAt = 0;
+    afterSequence = -1;
+    answerOffset = 0;
+    dock;
+    constructor(options) {
+        this.options = options;
+        this.dock = { invalidate: () => { }, render: width => this.render(width) };
+    }
+    get visible() { return this.current !== undefined; }
+    get state() { return this.current; }
+    get answer() { return this.answerText; }
+    /** Asks one question, replacing any earlier one. Empty text dismisses. */
+    async ask(question) {
+        const text = question.trim();
+        if (!text) {
+            await this.dismiss();
+            return;
+        }
+        const generation = ++this.generation;
+        await this.release();
+        this.question = text;
+        this.startedAt = Date.now();
+        this.answerText = '';
+        this.error = undefined;
+        this.answerOffset = 0;
+        this.afterSequence = -1;
+        this.current = 'thinking';
+        this.options.mount(this.dock);
+        this.options.changed();
+        try {
+            const started = await this.options.start(text, this.options.context());
+            if (generation !== this.generation) {
+                await this.options.interrupt(started.runId).catch(() => undefined);
+                return;
+            }
+            this.runId = started.runId;
+            void this.poll(generation);
+        }
+        catch (error) {
+            if (generation !== this.generation)
+                return;
+            this.current = 'failed';
+            this.error = error instanceof Error ? error.message : String(error);
+            this.options.changed();
+        }
+    }
+    /** Scrolls the answer while it is longer than the dock. */
+    scroll(direction) {
+        const step = Math.max(1, ANSWER_ROWS - 2);
+        this.answerOffset = Math.max(0, this.answerOffset + (direction === 'up' ? -step : step));
+        this.options.changed();
+    }
+    /** Copies the whole side answer, including any lines outside the dock. */
+    async copyAnswer() {
+        if (this.answerText)
+            await this.options.copyText(this.answerText);
+    }
+    /** Interrupts a running side question and removes the dock. */
+    async dismiss() {
+        this.generation++;
+        await this.release();
+        this.current = undefined;
+        this.options.mount(undefined);
+        this.options.changed();
+    }
+    async poll(generation) {
+        const runId = this.runId;
+        if (!runId || generation !== this.generation)
+            return;
+        try {
+            const result = await this.options.read(runId, this.afterSequence);
+            if (generation !== this.generation)
+                return;
+            for (const event of result.events) {
+                this.afterSequence = Math.max(this.afterSequence, event.sequence);
+                const data = payload(event);
+                if (event.type === 'message.delta' && typeof data.text === 'string')
+                    this.answerText += data.text;
+                if (event.type === 'message.completed' && data.role === 'assistant' && typeof data.text === 'string')
+                    this.answerText = data.text;
+                if (event.type === 'failed')
+                    this.error = typeof data.message === 'string' ? data.message : 'The side question failed.';
+                if (event.type === 'status.changed' && data.status === 'failed')
+                    this.error = typeof data.reason === 'string' ? data.reason : 'The side question failed.';
+                if (event.type === 'status.changed' && data.status === 'interrupted')
+                    this.error = 'The side question was interrupted.';
+                if (event.type === 'completed')
+                    this.current = 'answered';
+                if (event.type === 'failed' || event.type === 'status.changed' && ['failed', 'interrupted'].includes(String(data.status)))
+                    this.current = 'failed';
+            }
+            if (result.run.status === 'completed')
+                this.current = 'answered';
+            if (result.run.status === 'failed' || result.run.status === 'interrupted') {
+                this.current = 'failed';
+                this.error ??= result.run.terminalReason ?? 'The side question did not complete.';
+            }
+            this.options.changed();
+            if (this.current === 'thinking')
+                this.pollTimer = setTimeout(() => { void this.poll(generation); }, POLL_INTERVAL_MS);
+        }
+        catch (error) {
+            if (generation !== this.generation)
+                return;
+            this.current = 'failed';
+            this.error = error instanceof Error ? error.message : String(error);
+            this.options.changed();
+        }
+    }
+    async release() {
+        if (this.pollTimer)
+            clearTimeout(this.pollTimer);
+        this.pollTimer = undefined;
+        const runId = this.runId;
+        this.runId = undefined;
+        if (!runId || this.current !== 'thinking')
+            return;
+        try {
+            await this.options.interrupt(runId);
+        }
+        catch { /* The dock can still be dismissed if a run already stopped. */ }
+    }
+    /** The dock: question, a scrollable answer window, and a hint for browsing or copying. */
+    render(width) {
+        if (width < 1 || !this.current)
+            return [];
+        const theme = this.options.theme();
+        const inner = contentWidth(width);
+        const spinner = this.current === 'thinking'
+            ? spinnerFrameAt(Date.now() - this.startedAt, getWorkingSpinnerFrames(process.env.TERM), SPINNER_INTERVAL_MS)
+            : '';
+        const marker = `${spinner ? `${spinner} ` : ''}/btw`;
+        const markerWidth = visibleWidth(marker) + 1;
+        const asked = wrapTextWithAnsi(safeText(this.question), Math.max(1, inner - markerWidth));
+        const question = asked.slice(0, QUESTION_ROWS).map((line, index) => {
+            const prefix = index === 0 ? `${theme.bold(theme.fg('accent', marker))} ` : ' '.repeat(markerWidth);
+            return prefix + theme.fg('muted', line);
+        });
+        if (asked.length > QUESTION_ROWS)
+            question[QUESTION_ROWS - 1] = truncateToWidth(question[QUESTION_ROWS - 1], inner - 1, '') + theme.fg('muted', '…');
+        const text = this.current === 'failed' ? `${this.answerText ? `${this.answerText}\n` : ''}${this.error ?? 'The side question failed.'}` : this.answerText;
+        const wrapped = text ? text.split('\n').flatMap(line => line ? wrapTextWithAnsi(safeText(line), inner) : ['']) : [];
+        const maxOffset = Math.max(0, wrapped.length - ANSWER_ROWS);
+        this.answerOffset = Math.min(this.answerOffset, maxOffset);
+        const shown = wrapped.slice(this.answerOffset, this.answerOffset + ANSWER_ROWS).map(line => this.current === 'failed' ? theme.fg('error', line) : line);
+        const before = this.answerOffset;
+        const after = Math.max(0, wrapped.length - before - shown.length);
+        const textHint = before || after ? `PgUp/PgDn browse · ${before ? `${before} above` : ''}${before && after ? ' · ' : ''}${after ? `${after} below` : ''} · ` : '';
+        return [
+            neutralRule(width, theme),
+            ...question.map(line => padded(line, width)),
+            ...(shown.length ? ['', ...shown.map(line => padded(line, width))] : []),
+            '',
+            footerRow(`${textHint}Ctrl+X copy · /btw or Esc dismiss`, width, theme)
+        ].map(line => truncateToWidth(line, width, ''));
+    }
+}

package/dist/sdk/terminal/tui/skillInvocation.d.ts

@@ -0,0 +1,9 @@
+import type { AutocompleteProvider } from '@earendil-works/pi-tui';
+export interface SkillEntry {
+    name: string;
+    description: string;
+}
+/** Rewrites a leading `$name` of a loaded skill into `/skill:name`. Anything else passes through, so `$5` stays text. */
+export declare function expandSkillInvocation(text: string, skills: ReadonlySet<string>): string;
+/** Offers the loaded skills at a `$` that starts a word. Every other completion is `base`'s. */
+export declare function skillCompletions(base: AutocompleteProvider, skills: () => readonly SkillEntry[]): AutocompleteProvider;

package/dist/sdk/terminal/tui/skillInvocation.js

@@ -0,0 +1,43 @@
+/** Rewrites a leading `$name` of a loaded skill into `/skill:name`. Anything else passes through, so `$5` stays text. */
+export function expandSkillInvocation(text, skills) {
+    const trimmed = text.trimStart();
+    const match = /^\$(\S+)(?=\s|$)/.exec(trimmed);
+    if (!match || !skills.has(match[1]))
+        return text;
+    return `/skill:${match[1]}${trimmed.slice(match[0].length)}`;
+}
+/** A `$` that starts a word, and the partial name after it, at the cursor. */
+const SKILL_TOKEN = /(?:^|\s)\$([^\s$]*)$/;
+/** A line whose first word is a skill invocation. */
+const SKILL_LINE = /^\s*\$\S/;
+/** Offers the loaded skills at a `$` that starts a word. Every other completion is `base`'s. */
+export function skillCompletions(base, skills) {
+    return {
+        triggerCharacters: [...(base.triggerCharacters ?? []), '$'],
+        async getSuggestions(lines, cursorLine, cursorCol, options) {
+            const line = lines[cursorLine] ?? '';
+            const token = SKILL_TOKEN.exec(line.slice(0, cursorCol));
+            if (token) {
+                const partial = token[1];
+                const items = skills()
+                    .filter((skill) => skill.name.startsWith(partial))
+                    .map((skill) => ({ value: skill.name, label: `$${skill.name}`, description: skill.description }));
+                return items.length ? { items, prefix: `$${partial}` } : null;
+            }
+            // The arguments of a line that starts with a skill invocation are free text, not file paths.
+            if (SKILL_LINE.test(line))
+                return null;
+            return base.getSuggestions(lines, cursorLine, cursorCol, options);
+        },
+        applyCompletion(lines, cursorLine, cursorCol, item, prefix) {
+            if (!prefix.startsWith('$'))
+                return base.applyCompletion(lines, cursorLine, cursorCol, item, prefix);
+            const line = lines[cursorLine] ?? '';
+            const start = cursorCol - prefix.length;
+            const inserted = `$${item.value} `;
+            const newLines = [...lines];
+            newLines[cursorLine] = `${line.slice(0, start)}${inserted}${line.slice(cursorCol)}`;
+            return { lines: newLines, cursorLine, cursorCol: start + inserted.length };
+        }
+    };
+}

package/dist/sdk/terminal/tui/status.d.ts

@@ -0,0 +1,18 @@
+import type { Theme } from '@earendil-works/pi-coding-agent';
+export interface BandState {
+    cwd: string;
+    model?: {
+        name: string;
+        reasoning: boolean;
+        contextWindow: number;
+    };
+    thinkingLevel: string;
+    branch: string | null;
+    account?: string;
+    inputTokens: number;
+    outputTokens: number;
+}
+export declare function singleLine(text: string): string;
+export declare function displayProjectName(cwd: string): string;
+export declare function formatTokenCount(value: number): string;
+export declare function renderStatusBand(state: BandState, width: number, theme: Theme): string;

package/dist/sdk/terminal/tui/status.js

@@ -0,0 +1,67 @@
+// Presentation adapted from Oh My Pi 18.11.3's status line; it sits in the footer below the prompt frame.
+// Upstream MIT license and evidence are recorded in NOTICE.md and docs/terminal-tui.md.
+import { basename, sep } from 'node:path';
+import { parseColor, stripTerminalSequences, truncateToWidth, visibleWidth } from '@earendil-works/pi-tui';
+import { TITANIUM } from "./theme.js";
+// OMP's shipped light theme supplies status colors separately from transcript colors.
+const LIGHT_STATUS = {
+    ...TITANIUM, darkTitanium: '#e0e0e0', electricBlue: '#875f87', subtleGray: '#808080',
+    brightAluminum: '#005f87', readoutGreen: '#005f00', titaniumGold: '#005f5f'
+};
+const palette = (theme) => theme.appearance === 'light' ? LIGHT_STATUS : TITANIUM;
+export function singleLine(text) {
+    return stripTerminalSequences(text).replace(/[\x00-\x1f\x7f-\x9f]/g, ' ').replace(/ +/g, ' ').trim();
+}
+export function displayProjectName(cwd) {
+    return singleLine(basename(cwd) || cwd || sep);
+}
+export function formatTokenCount(value) {
+    const count = Math.max(0, Number.isFinite(value) ? Math.floor(value) : 0);
+    if (count >= 1_000_000_000)
+        return `${Math.floor(count / 1_000_000_000)}B`;
+    if (count >= 1_000_000)
+        return `${Math.floor(count / 1_000_000)}M`;
+    if (count >= 1_000)
+        return `${Math.floor(count / 1_000)}K`;
+    return count.toLocaleString('en-US');
+}
+function fitParts(parts, width) {
+    const fitted = parts.map(part => ({ ...part }));
+    const separator = ' | ';
+    const plain = () => fitted.map(part => part.text).join(separator);
+    while (fitted.length > 1 && visibleWidth(plain()) > width) {
+        const last = fitted[fitted.length - 1];
+        const otherWidth = visibleWidth(plain()) - visibleWidth(separator) - visibleWidth(last.text);
+        const available = width - otherWidth - visibleWidth(separator);
+        if (available > 0 && available < visibleWidth(last.text)) {
+            last.text = truncateToWidth(last.text, available, '', false);
+            if (visibleWidth(plain()) <= width)
+                return fitted;
+        }
+        fitted.pop();
+    }
+    if (fitted.length && visibleWidth(plain()) > width) {
+        fitted[0].text = truncateToWidth(fitted[0].text, width, '', false);
+    }
+    return fitted;
+}
+function color(theme, hex, text) {
+    return theme.style(text, { fg: parseColor(hex) });
+}
+export function renderStatusBand(state, width, theme) {
+    const size = Math.max(0, Math.floor(width));
+    if (!size)
+        return '';
+    const colors = palette(theme);
+    const model = state.model ? singleLine(state.model.name).replace(/^Claude /, '') || 'no-model' : 'no-model';
+    const account = singleLine(state.account ?? '') || 'account unknown';
+    const effort = singleLine(state.thinkingLevel) || 'off';
+    const parts = fitParts([
+        { text: displayProjectName(state.cwd), color: colors.brightAluminum },
+        { text: singleLine(state.branch ?? '') || '—', color: colors.readoutGreen },
+        { text: `${account} · ${model} · ${effort}`, color: colors.electricBlue },
+        { text: `↑ ${formatTokenCount(state.inputTokens)} ↓ ${formatTokenCount(state.outputTokens)}`, color: colors.titaniumGold }
+    ], size);
+    const separator = color(theme, colors.subtleGray, ' | ');
+    return parts.map(part => color(theme, part.color, part.text)).join(separator);
+}

package/dist/sdk/terminal/tui/theme.d.ts

@@ -0,0 +1,45 @@
+/*!
+ * Adapted from @oh-my-pi/pi-tui 18.11.3 (https://github.com/can1357/oh-my-pi).
+ *
+ * MIT License
+ *
+ * Copyright (c) 2025 Mario Zechner
+ * Copyright (c) 2025-2026 Can Bölük
+ * Copyright (c) 2026 Stencil Labs, Inc.
+ *
+ * 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.
+ */
+import { Theme } from '@earendil-works/pi-coding-agent';
+export declare const TITANIUM: {
+    readonly brushedTitanium: "#151820";
+    readonly darkTitanium: "#0f1216";
+    readonly electricBlue: "#00b4ff";
+    readonly deepBlue: "#0082b3";
+    readonly titaniumGold: "#d4c090";
+    readonly brightAluminum: "#e8ecf4";
+    readonly dimAluminum: "#9ca3b0";
+    readonly warningAmber: "#ffb347";
+    readonly readoutGreen: "#00ff88";
+    readonly alertRed: "#ff4757";
+    readonly subtleGray: "#2a3038";
+};
+export declare function createHarnessTheme(base: Theme): Theme;
+export declare function createHarnessLightTheme(base: Theme): Theme;
+export declare function composerRuleColor(theme: Theme): string;
+export declare function autocompleteRuleColor(theme: Theme): string;