@xingular/harness 2.0.0 → 2.0.1-unstable

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

@@ -0,0 +1,241 @@
+import { truncateToWidth, visibleWidth, wrapTextWithAnsi } from '@earendil-works/pi-tui';
+import { contentWidth, footerRow, neutralRule, padded, safeText } from "./chrome.js";
+import { MarkdownBlock, markdownSource } from "./markdown.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;
+    /** The answer is taller than the dock, so PageUp/PageDown browse it instead of the transcript. */
+    overflowing = false;
+    answerMarkdown = new MarkdownBlock();
+    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; }
+    get scrollable() { return this.overflowing; }
+    /** 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.overflowing = false;
+        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.overflowing = false;
+        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 answer = this.answerText ? this.answerMarkdown.lines(markdownSource(this.answerText), inner, theme) : [];
+        const failure = this.current === 'failed'
+            ? wrapTextWithAnsi(safeText(this.error ?? 'The side question failed.'), inner).map(line => theme.fg('error', line))
+            : [];
+        const wrapped = [...answer, ...(answer.length && failure.length ? [''] : []), ...failure];
+        this.overflowing = wrapped.length > ANSWER_ROWS;
+        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);
+        const before = this.answerOffset;
+        const after = Math.max(0, wrapped.length - before - shown.length);
+        const textHint = before || after ? `PgUp/PgDn/wheel 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,28 @@
+import type { AutocompleteProvider } from '@earendil-works/pi-tui';
+export interface SkillEntry {
+    name: string;
+    description: string;
+}
+export interface SkillToken {
+    /** What has been typed after the `$`. */
+    query: string;
+    /** Where the `$` is. */
+    from: number;
+    /** The caret. */
+    to: number;
+}
+export interface SkillInvocationMatch {
+    name: string;
+    /** Where the `$` is. */
+    from: number;
+    /** Just after the name. */
+    to: number;
+}
+/** The skill token being typed at `caret`, or null when the caret is not in one. */
+export declare function skillTokenAt(text: string, caret: number): SkillToken | null;
+/** Every `$name` token in the message, whether or not the name is a loaded skill. */
+export declare function skillInvocationMatches(text: string): SkillInvocationMatch[];
+/** Every `$name` in the message that names an enabled skill, in message order, once each. */
+export declare function skillInvocations(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,63 @@
+/** A `$` that starts a word, and the partial name after it, at the cursor. */
+const SKILL_TOKEN = /(?:^|[\s(])\$([^\s$]*)$/;
+/** A `$name` at a word start, ending at whitespace, punctuation or the end of the message. */
+const SKILL_INVOCATION = /(?:^|[\s(])\$([A-Za-z0-9][A-Za-z0-9_-]*)(?=[\s.,;:!?)]|$)/gu;
+/** A line whose first word is a skill invocation. */
+const SKILL_LINE = /^\s*\$\S/;
+/** The skill token being typed at `caret`, or null when the caret is not in one. */
+export function skillTokenAt(text, caret) {
+    const match = SKILL_TOKEN.exec(text.slice(0, caret));
+    if (!match)
+        return null;
+    const query = match[1] ?? '';
+    return { query, from: caret - query.length - 1, to: caret };
+}
+/** Every `$name` token in the message, whether or not the name is a loaded skill. */
+export function skillInvocationMatches(text) {
+    const found = [];
+    for (const match of text.matchAll(SKILL_INVOCATION)) {
+        const from = match.index + match[0].indexOf('$');
+        found.push({ name: match[1], from, to: from + 1 + match[1].length });
+    }
+    return found;
+}
+/** Every `$name` in the message that names an enabled skill, in message order, once each. */
+export function skillInvocations(text, skills) {
+    const found = [];
+    for (const match of skillInvocationMatches(text)) {
+        if (skills.has(match.name) && !found.includes(match.name))
+            found.push(match.name);
+    }
+    return found;
+}
+/** 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 = skillTokenAt(line, cursorCol);
+            if (token) {
+                const partial = token.query;
+                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,54 @@
+/*!
+ * 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';
+/**
+ * Categorical colours for a bar that splits one reading by kind — the same values as the App's
+ * `--data-1..4` tokens, so a screen and a terminal show the same split in the same colours. They
+ * carry no severity: a red run is a category, not a problem.
+ */
+export declare const SERIES_COLORS: {
+    readonly dark: readonly ["#3987e5", "#d95926", "#199e70", "#c98500"];
+    readonly light: readonly ["#2a78d6", "#eb6834", "#1baf7a", "#eda100"];
+};
+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;

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

@@ -0,0 +1,185 @@
+/*!
+ * 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';
+import { SELECTION_COLORS } from "./selection.js";
+const orange = { dark: '#ffb347', light: '#9a7326' };
+/**
+ * Categorical colours for a bar that splits one reading by kind — the same values as the App's
+ * `--data-1..4` tokens, so a screen and a terminal show the same split in the same colours. They
+ * carry no severity: a red run is a category, not a problem.
+ */
+export const SERIES_COLORS = {
+    dark: ['#3987e5', '#d95926', '#199e70', '#c98500'],
+    light: ['#2a78d6', '#eb6834', '#1baf7a', '#eda100']
+};
+export const TITANIUM = {
+    brushedTitanium: '#151820',
+    darkTitanium: '#0f1216',
+    electricBlue: '#00b4ff',
+    deepBlue: '#0082b3',
+    titaniumGold: '#d4c090',
+    brightAluminum: '#e8ecf4',
+    dimAluminum: '#9ca3b0',
+    warningAmber: orange.dark,
+    readoutGreen: '#00ff88',
+    alertRed: '#ff4757',
+    subtleGray: '#2a3038'
+};
+const foreground = {
+    accent: '#00b4ff',
+    border: '#2a3038',
+    borderAccent: '#00b4ff',
+    borderMuted: '#1f252d',
+    success: '#00ff88',
+    error: '#ff4757',
+    warning: orange.dark,
+    muted: '#9ca3b0',
+    dim: '#6b7280',
+    text: '',
+    thinkingText: '#9ca3b0',
+    userMessageText: '',
+    customMessageText: '',
+    customMessageLabel: '#d4c090',
+    toolTitle: '',
+    toolOutput: '#9ca3b0',
+    mdHeading: '#00b4ff',
+    mdLink: '#00b4ff',
+    mdLinkUrl: '#0082b3',
+    mdCode: '#00ff88',
+    mdCodeBlock: '#9ca3b0',
+    mdCodeBlockBorder: '#2a3038',
+    mdQuote: '#9ca3b0',
+    mdQuoteBorder: '#2a3038',
+    mdHr: '#2a3038',
+    mdListBullet: '#00b4ff',
+    toolDiffAdded: '#00ff88',
+    toolDiffRemoved: '#ff4757',
+    toolDiffContext: '#9ca3b0',
+    syntaxComment: '#6b7280',
+    syntaxKeyword: '#00b4ff',
+    syntaxFunction: '#00ff88',
+    syntaxVariable: '#e8ecf4',
+    syntaxString: '#d4c090',
+    syntaxNumber: '#ffb347',
+    syntaxType: '#00b4ff',
+    syntaxOperator: '#00b4ff',
+    syntaxPunctuation: '#9ca3b0',
+    thinkingOff: '#4a5058',
+    thinkingMinimal: '#5a6068',
+    thinkingLow: '#6a7078',
+    thinkingMedium: '#9ca3b0',
+    thinkingHigh: '#00b4ff',
+    thinkingXhigh: '#d4c090',
+    bashMode: '#00ff88',
+    scrollbarTrack: '#2a3038',
+    scrollbarThumb: '#9ca3b0',
+    searchMatchText: '#e8ecf4',
+    thinkingMax: '#d4c090'
+};
+const background = {
+    selectedBg: SELECTION_COLORS.dark.background,
+    searchMatchBg: '#0082b3',
+    userMessageBg: '#0f1216',
+    customMessageBg: '#2a3038',
+    toolPendingBg: '#0f1216',
+    toolSuccessBg: '#0f1216',
+    toolErrorBg: '#1a0f10'
+};
+export function createHarnessTheme(base) {
+    return new Theme(foreground, background, base.getColorMode(), { name: 'harness-titanium', appearance: 'dark' });
+}
+const lightForeground = {
+    accent: '#5a8080',
+    border: '#547da7',
+    borderAccent: '#5a8080',
+    borderMuted: '#b0b0b0',
+    success: '#588458',
+    error: '#aa5555',
+    warning: orange.light,
+    muted: '#6c6c6c',
+    dim: '#767676',
+    text: '',
+    thinkingText: '#6c6c6c',
+    userMessageText: '',
+    customMessageText: '',
+    customMessageLabel: '#7e57c2',
+    toolTitle: '',
+    toolOutput: '#6c6c6c',
+    mdHeading: '#9a7326',
+    mdLink: '#547da7',
+    mdLinkUrl: '#767676',
+    mdCode: '#5a8080',
+    mdCodeBlock: '#588458',
+    mdCodeBlockBorder: '#6c6c6c',
+    mdQuote: '#6c6c6c',
+    mdQuoteBorder: '#6c6c6c',
+    mdHr: '#6c6c6c',
+    mdListBullet: '#588458',
+    toolDiffAdded: '#588458',
+    toolDiffRemoved: '#aa5555',
+    toolDiffContext: '#6c6c6c',
+    syntaxComment: '#008000',
+    syntaxKeyword: '#0000FF',
+    syntaxFunction: '#795E26',
+    syntaxVariable: '#001080',
+    syntaxString: '#A31515',
+    syntaxNumber: '#098658',
+    syntaxType: '#267F99',
+    syntaxOperator: '#000000',
+    syntaxPunctuation: '#000000',
+    thinkingOff: '#b0b0b0',
+    thinkingMinimal: '#767676',
+    thinkingLow: '#547da7',
+    thinkingMedium: '#5a8080',
+    thinkingHigh: '#875f87',
+    thinkingXhigh: '#8b008b',
+    bashMode: '#588458',
+    scrollbarTrack: '#b0b0b0',
+    scrollbarThumb: '#6c6c6c',
+    searchMatchText: '#3b3b3b',
+    thinkingMax: '#8b008b'
+};
+const lightBackground = {
+    selectedBg: SELECTION_COLORS.light.background,
+    searchMatchBg: '#d0d0e0',
+    userMessageBg: '#e8e8e8',
+    customMessageBg: '#ede7f6',
+    toolPendingBg: '#e8e8f0',
+    toolSuccessBg: '#e8f0e8',
+    toolErrorBg: '#f0e8e8'
+};
+export function createHarnessLightTheme(base) {
+    return new Theme(lightForeground, lightBackground, base.getColorMode(), { name: 'light', appearance: 'light' });
+}
+// The composer keeps its neutral frame; the slash completion divider uses warning amber.
+export function composerRuleColor(theme) {
+    return theme.appearance === 'light' ? '#9a9a9a' : '#999999';
+}
+export function autocompleteRuleColor(theme) {
+    return theme.appearance === 'light' ? orange.light : orange.dark;
+}

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

@@ -0,0 +1,11 @@
+import { EFFORTS } from "../../core/effort.js";
+type Level = (typeof EFFORTS)[number];
+/** The part of a model the rule reads. */
+export interface LevelModel {
+    reasoning?: boolean;
+    thinkingLevelMap?: Partial<Record<string, string | null>>;
+}
+export declare function supportedLevels(model: LevelModel | undefined): Level[];
+/** The level a model runs at when asked for `level`: itself, else the nearest above, else the nearest below. */
+export declare function clampLevel(model: LevelModel | undefined, level: string): Level;
+export {};