@xingular/harness 1.1.1 → 1.3.1-unstable.0

package/dist/sdk/terminal/opentui/model.js

@@ -0,0 +1,482 @@
+import { sessionEntryToContextMessages } from '@earendil-works/pi-coding-agent';
+import { parseProposedPlan } from "../tui/planMode.js";
+import { ansiLabel, ansiPlain } from "./ansi.js";
+const MAX_TOOL_OUTPUT = 12_000;
+const OUTPUT_CLIP_MARKER = '\n… output clipped …\n';
+function appendCapped(current, delta) {
+    const combined = current + delta;
+    if (combined.length <= MAX_TOOL_OUTPUT)
+        return combined;
+    const available = MAX_TOOL_OUTPUT - OUTPUT_CLIP_MARKER.length;
+    const head = Math.ceil(available / 2);
+    return `${combined.slice(0, head)}${OUTPUT_CLIP_MARKER}${combined.slice(-(available - head))}`;
+}
+function blocks(content) {
+    if (typeof content === 'string')
+        return [{ type: 'text', text: content }];
+    return Array.isArray(content) ? content.filter((item) => typeof item === 'object' && item !== null) : [];
+}
+function contentText(content) {
+    return blocks(content)
+        .filter(block => block.type === 'text' && typeof block.text === 'string')
+        .map(block => String(block.text))
+        .join('\n');
+}
+function withoutBoldMarkers(text) {
+    return text.replace(/\*\*(.*?)\*\*/gs, '$1');
+}
+function imageCount(content) {
+    return blocks(content).filter(block => block.type === 'image').length;
+}
+function imageContents(content) {
+    return blocks(content).flatMap(block => block.type === 'image' && typeof block.data === 'string' && typeof block.mimeType === 'string'
+        ? [{ data: block.data, mimeType: block.mimeType }]
+        : []);
+}
+function stringField(message, name) {
+    const value = message[name];
+    return typeof value === 'string' ? value : undefined;
+}
+function numberField(message, name) {
+    const value = message[name];
+    return typeof value === 'number' && Number.isFinite(value) ? value : undefined;
+}
+function clip(text, limit = MAX_TOOL_OUTPUT) {
+    return text.length > limit ? `${text.slice(0, limit)}\n… ${text.length - limit} more characters` : text;
+}
+function argumentSummary(name, args) {
+    const value = (args ?? {});
+    const pick = (...names) => {
+        for (const key of names) {
+            const item = value[key];
+            if (typeof item === 'string' && item.trim())
+                return item;
+        }
+        return undefined;
+    };
+    const path = pick('path', 'file_path', 'filePath', 'target');
+    const summary = name === 'bash' || name === 'shell'
+        ? pick('command', 'cmd')
+        : name === 'grep'
+            ? [pick('pattern'), pick('path')].filter(Boolean).join('  ')
+            : name === 'find'
+                ? [pick('pattern'), pick('path')].filter(Boolean).join('  ')
+                : name === 'websearch' || name === 'web_search'
+                    ? pick('query')
+                    : name === 'webfetch' || name === 'web_fetch'
+                        ? pick('url')
+                        : name === 'spawn_subagent' || name === 'spawnSubagent'
+                            ? [pick('agent'), pick('title', 'brief', 'description', 'prompt')].filter(Boolean).join(' · ')
+                            : path;
+    if (summary)
+        return ansiLabel(summary, 100);
+    if (!args || typeof args !== 'object')
+        return '';
+    try {
+        return ansiLabel(JSON.stringify(args), 100);
+    }
+    catch {
+        return '';
+    }
+}
+function toolOutput(message) {
+    const text = ansiPlain(contentText(message.content));
+    const details = message.details;
+    if (details && typeof details === 'object') {
+        const diff = details.diff;
+        if (typeof diff === 'string' && diff.trim())
+            return clip(`${text}${text ? '\n' : ''}${diff}`);
+    }
+    return clip(text);
+}
+const TODO_STATUSES = new Set(['pending', 'in_progress', 'completed']);
+/** The items of a `todo_write` (or pre-rename `checklist_write`) call, or null when they are not a todo list. */
+export function todoEntries(args) {
+    const items = args?.items;
+    if (!Array.isArray(items))
+        return null;
+    const entries = [];
+    for (const item of items) {
+        const entry = item;
+        if (!entry || typeof entry.text !== 'string' || !entry.text.trim() || typeof entry.status !== 'string' || !TODO_STATUSES.has(entry.status))
+            return null;
+        entries.push({ text: ansiLabel(entry.text.trim(), 500), status: entry.status });
+    }
+    return entries;
+}
+function sameTranscriptItem(left, right) {
+    if (left.kind !== right.kind)
+        return false;
+    if (left.kind === 'todo' && right.kind === 'todo') {
+        return left.id === right.id && left.origin === right.origin && left.toolCallId === right.toolCallId && left.status === right.status
+            && JSON.stringify(left.items) === JSON.stringify(right.items);
+    }
+    const leftFields = Object.entries(left);
+    const rightValues = right;
+    return leftFields.length === Object.keys(right).length
+        && leftFields.every(([key, value]) => rightValues[key] === value);
+}
+/** Gives each object a stable number, so a cache key can say "this exact tool result". */
+const objectIds = new WeakMap();
+let nextObjectId = 0;
+function objectId(value) {
+    let id = objectIds.get(value);
+    if (id === undefined)
+        objectIds.set(value, id = nextObjectId++);
+    return id;
+}
+function compactedHistory(session) {
+    const manager = session.sessionManager;
+    if (typeof manager?.getBranch !== 'function' || typeof manager.buildSessionProjection !== 'function')
+        return null;
+    const branch = manager.getBranch();
+    const at = branch.findLastIndex(entry => entry.type === 'compaction');
+    if (at < 0)
+        return null;
+    const compactionId = branch[at].id;
+    const earlier = new Set(branch.slice(0, at).map(entry => entry.id));
+    const projected = manager.buildSessionProjection().entries;
+    const first = projected[0];
+    if (!first || first.sourceEntry.id !== compactionId || first.messages.length === 0)
+        return null;
+    let head = 0;
+    for (const entry of projected) {
+        if (entry.sourceEntry.id !== compactionId && !earlier.has(entry.sourceEntry.id))
+            break;
+        head += entry.messages.length;
+    }
+    return {
+        archive: branch.slice(0, at).flatMap(entry => sessionEntryToContextMessages(entry)),
+        summaryIndex: first.messages.length - 1,
+        head
+    };
+}
+export class TranscriptModel {
+    session;
+    /** Items derived from a finished message, reused while its position and tool results stay the same. */
+    messageItems = new WeakMap();
+    hideThinking = false;
+    showImages = true;
+    expanded = false;
+    notices = [];
+    nextNotice = 0;
+    liveBash;
+    cachedView;
+    cachedItems = new Map();
+    /** What a compaction took out of Pi's message list, rebuilt from the session history on bind. */
+    history;
+    bind(session) {
+        this.session = session;
+        this.history = undefined;
+        this.invalidate();
+    }
+    clear() {
+        this.session = undefined;
+        this.history = undefined;
+        this.notices = [];
+        this.liveBash = undefined;
+        this.invalidate();
+    }
+    // Pi mutates the session messages outside this model, so callers invalidate after runtime events.
+    invalidate() {
+        this.cachedView = undefined;
+    }
+    beginBash(command) {
+        const messages = (this.session?.messages ?? []);
+        this.liveBash = {
+            command,
+            output: '',
+            timestamp: Date.now(),
+            previousCount: messages.filter(message => message.role === 'bashExecution').length
+        };
+        this.invalidate();
+    }
+    appendBashOutput(id, delta) {
+        const live = this.liveBash;
+        if (!live || !delta || (live.id !== undefined && live.id !== id))
+            return false;
+        live.id ??= id;
+        live.output = appendCapped(live.output, delta);
+        this.invalidate();
+        return true;
+    }
+    finishBash() {
+        this.liveBash = undefined;
+        this.invalidate();
+    }
+    clearNotices() {
+        this.notices = [];
+        this.invalidate();
+    }
+    setThinkingHidden(hidden) {
+        if (this.hideThinking === hidden)
+            return;
+        this.hideThinking = hidden;
+        this.messageItems = new WeakMap();
+        this.invalidate();
+    }
+    setImagesShown(shown) {
+        if (this.showImages === shown)
+            return;
+        this.showImages = shown;
+        this.messageItems = new WeakMap();
+        this.invalidate();
+    }
+    setExpanded(expanded) {
+        this.expanded = expanded;
+    }
+    get isExpanded() {
+        return this.expanded;
+    }
+    notice(text, level = 'info') {
+        const lines = text.split(/\r\n?|\n/u).filter(line => line.trim());
+        const multiline = lines.length > 1;
+        for (const line of lines) {
+            const sequence = this.nextNotice++;
+            this.addNotice(sequence, multiline, { kind: 'notice', id: `notice-${sequence}`, text: line, level });
+        }
+        this.invalidate();
+    }
+    commandHelp(groups) {
+        const sequence = this.nextNotice++;
+        this.addNotice(sequence, true, { kind: 'command-help', id: `command-help-${sequence}`, groups });
+        this.invalidate();
+    }
+    /** A `/todo` snapshot: the list at the moment the command ran, with no tool row. */
+    todo(items) {
+        const sequence = this.nextNotice++;
+        this.addNotice(sequence, true, { kind: 'todo', id: `todo-${sequence}`, origin: 'command', items });
+        this.invalidate();
+    }
+    addNotice(sequence, multiline, item) {
+        const messages = this.session?.messages ?? [];
+        this.notices.push({ afterMessageCount: messages.length, anchor: messages.at(-1), sequence, multiline, item });
+        if (this.notices.length > 60)
+            this.notices = this.notices.slice(-60);
+    }
+    /**
+     * Notices in the order they appear, each with the message index it goes before. Compaction
+     * replaces the message list with a shorter one, so a notice follows the message it was posted
+     * after; a notice whose message was summarized goes right after the compaction card.
+     */
+    placedNotices(messages) {
+        const indexes = new Map();
+        messages.forEach((message, index) => indexes.set(message, index));
+        const summary = messages.findIndex(message => message.role === 'compactionSummary');
+        return this.notices.map(notice => {
+            if (!notice.anchor)
+                return { place: 0, notice };
+            const index = indexes.get(notice.anchor);
+            if (index !== undefined)
+                return { place: index + 1, notice };
+            return { place: summary >= 0 ? summary + 1 : Math.min(notice.afterMessageCount, messages.length), notice };
+        }).sort((left, right) => left.place - right.place || left.notice.sequence - right.notice.sequence);
+    }
+    view() {
+        if (this.cachedView)
+            return this.cachedView;
+        const session = this.session;
+        if (!session)
+            return this.cachedView = {
+                items: this.stabilize(this.notices.map(notice => notice.item)),
+                hasUserMessages: false,
+                hasMultilineNotice: this.notices.some(notice => notice.multiline)
+            };
+        const live = session.messages;
+        const messages = this.displayMessages(live);
+        const streaming = session.state.streamingMessage;
+        const all = streaming && !messages.includes(streaming) ? [...messages, streaming] : messages;
+        const pending = session.state.pendingToolCalls ?? new Set();
+        const results = new Map();
+        for (const message of messages) {
+            if (message.role === 'toolResult' && typeof message.toolCallId === 'string')
+                results.set(message.toolCallId, message);
+        }
+        const items = [];
+        const bashExecutionCount = live.filter(message => message.role === 'bashExecution').length;
+        const notices = this.placedNotices(messages);
+        let noticeIndex = 0;
+        for (let index = 0; index < all.length; index += 1) {
+            while (noticeIndex < notices.length && notices[noticeIndex].place <= index) {
+                items.push(notices[noticeIndex++].notice.item);
+            }
+            const message = all[index];
+            if (message === streaming) {
+                items.push(...this.messageItemsFor(message, index, true, results, pending));
+                continue;
+            }
+            const key = this.messageKey(message, index, results, pending);
+            const cached = this.messageItems.get(message);
+            if (cached && cached.key === key) {
+                items.push(...cached.items);
+                continue;
+            }
+            const derived = this.messageItemsFor(message, index, false, results, pending);
+            this.messageItems.set(message, { key, items: derived });
+            items.push(...derived);
+        }
+        if (this.liveBash && bashExecutionCount === this.liveBash.previousCount) {
+            items.push({
+                kind: 'bash', id: `live-${this.liveBash.id ?? 'pending'}`, command: this.liveBash.command,
+                timestamp: this.liveBash.timestamp, output: ansiPlain(this.liveBash.output), running: true, cancelled: false
+            });
+        }
+        for (; noticeIndex < notices.length; noticeIndex += 1)
+            items.push(notices[noticeIndex].notice.item);
+        return this.cachedView = {
+            items: this.stabilize(items),
+            hasUserMessages: messages.some(message => message.role === 'user'),
+            hasMultilineNotice: this.notices.some(notice => notice.multiline)
+        };
+    }
+    /**
+     * Pi's list after a compaction starts with the summary and the kept messages. The transcript
+     * shows the whole conversation instead: everything before the compaction from the session
+     * history, the summary, then what came after.
+     */
+    displayMessages(live) {
+        if (this.history === undefined) {
+            try {
+                this.history = this.session ? compactedHistory(this.session) : null;
+            }
+            catch {
+                this.history = null;
+            }
+        }
+        const history = this.history;
+        if (!history || live.length < history.head || live[history.summaryIndex]?.role !== 'compactionSummary')
+            return live;
+        return [...history.archive, live[history.summaryIndex], ...live.slice(history.head)];
+    }
+    /** What a message's items depend on besides the message itself. */
+    messageKey(message, index, results, pending) {
+        let key = `${index}`;
+        if (message.role !== 'assistant')
+            return key;
+        for (const block of blocks(message.content)) {
+            if (block.type !== 'toolCall' || typeof block.id !== 'string')
+                continue;
+            const result = results.get(block.id);
+            key += result ? `|${objectId(result)}` : pending.has(block.id) ? '|r' : '|p';
+        }
+        return key;
+    }
+    messageItemsFor(message, index, isStreaming, results, pending) {
+        const items = [];
+        const role = message.role;
+        if (role === 'user') {
+            const text = contentText(message.content);
+            const images = imageCount(message.content);
+            if (!text && !images)
+                return items;
+            items.push({ kind: 'user', id: `m${index}`, text, images, timestamp: numberField(message, 'timestamp') ?? 0 });
+            return items;
+        }
+        if (role === 'assistant') {
+            const model = stringField(message, 'model');
+            const content = blocks(message.content);
+            let textIndex = 0;
+            for (const block of content) {
+                if (block.type === 'thinking' && typeof block.thinking === 'string' && !this.hideThinking) {
+                    const text = block.redacted === true ? '[redacted thinking]' : withoutBoldMarkers(String(block.thinking));
+                    if (text.trim())
+                        items.push({ kind: 'thinking', id: `m${index}.t${textIndex++}`, text, streaming: isStreaming });
+                }
+                else if (block.type === 'text' && typeof block.text === 'string') {
+                    const id = `m${index}.x${textIndex++}`;
+                    const timestamp = numberField(message, 'timestamp') ?? 0;
+                    const plan = parseProposedPlan(block.text);
+                    if (!plan) {
+                        if (block.text.trim())
+                            items.push({ kind: 'assistant', id, text: block.text, model, streaming: isStreaming, timestamp });
+                        continue;
+                    }
+                    if (plan.before)
+                        items.push({ kind: 'assistant', id: `${id}.b`, text: plan.before, model, streaming: isStreaming, timestamp });
+                    items.push({ kind: 'plan', id: `${id}.p`, title: plan.title, body: plan.body, streaming: isStreaming && !plan.complete });
+                    if (plan.after)
+                        items.push({ kind: 'assistant', id: `${id}.a`, text: plan.after, model, streaming: isStreaming, timestamp });
+                }
+                else if (block.type === 'toolCall' && typeof block.id === 'string' && typeof block.name === 'string') {
+                    const result = results.get(block.id);
+                    const status = result ? (result.isError === true ? 'error' : 'ok') : pending.has(block.id) ? 'running' : 'pending';
+                    const resultImageCount = result ? imageCount(result.content) : 0;
+                    const id = `m${index}.c${textIndex++}`;
+                    const todo = (block.name === 'todo_write' || block.name === 'checklist_write') && result?.isError !== true ? todoEntries(block.arguments) : null;
+                    if (todo) {
+                        items.push({ kind: 'todo', id, origin: 'tool', toolCallId: block.id, status, items: todo });
+                        continue;
+                    }
+                    items.push({
+                        kind: 'tool', id, toolCallId: block.id, name: block.name,
+                        summary: argumentSummary(block.name, block.arguments), status,
+                        output: result && resultImageCount === 0 ? toolOutput(result) : '',
+                        durationMs: result ? numberField(result, 'durationMs') : undefined
+                    });
+                    if (result && resultImageCount > 0) {
+                        items.push({
+                            kind: 'image-result', id: `${id}.image-result`, text: toolOutput(result),
+                            imageCount: resultImageCount, images: this.showImages ? imageContents(result.content) : [],
+                            showImages: this.showImages
+                        });
+                    }
+                }
+            }
+            const stop = stringField(message, 'stopReason');
+            const error = stringField(message, 'errorMessage');
+            if (stop === 'error' && error)
+                items.push({ kind: 'notice', id: `m${index}.error`, text: error, level: 'error' });
+            if (stop === 'aborted')
+                items.push({ kind: 'notice', id: `m${index}.aborted`, text: 'Stopped by the person.', level: 'warning' });
+            return items;
+        }
+        if (role === 'bashExecution') {
+            const command = stringField(message, 'command') ?? '';
+            if (!command)
+                return items;
+            items.push({
+                kind: 'bash', id: `m${index}`, command, timestamp: numberField(message, 'timestamp') ?? 0,
+                output: clip(ansiPlain(stringField(message, 'output') ?? '')),
+                running: false, exitCode: numberField(message, 'exitCode'), cancelled: message.cancelled === true
+            });
+            return items;
+        }
+        if (role === 'custom') {
+            if (message.display === false)
+                return items;
+            const text = contentText(message.content);
+            if (!text.trim())
+                return items;
+            items.push({ kind: 'custom', id: `m${index}`, label: stringField(message, 'customType') ?? 'Extension', text });
+            return items;
+        }
+        if (role === 'compactionSummary') {
+            const summary = stringField(message, 'summary') ?? '';
+            if (!summary.trim())
+                return items;
+            items.push({ kind: 'compaction', id: `m${index}`, summary, tokensBefore: numberField(message, 'tokensBefore') });
+            return items;
+        }
+        if (role === 'branchSummary') {
+            const text = stringField(message, 'summary') ?? '';
+            if (text.trim())
+                items.push({ kind: 'summary', id: `m${index}`, label: 'Branch summary', text });
+        }
+        return items;
+    }
+    stabilize(items) {
+        const stable = items.map(item => {
+            const cached = this.cachedItems.get(item.id);
+            if (cached && sameTranscriptItem(cached, item))
+                return cached;
+            this.cachedItems.set(item.id, item);
+            return item;
+        });
+        const currentIds = new Set(stable.map(item => item.id));
+        for (const id of this.cachedItems.keys()) {
+            if (!currentIds.has(id))
+                this.cachedItems.delete(id);
+        }
+        return stable;
+    }
+}

package/dist/sdk/terminal/opentui/subagentsWidget.d.ts

@@ -1,6 +1,6 @@
 import { type TerminalSubagentActivity } from "../subagentMonitor.js";
 export type SubagentTone = 'success' | 'warning' | 'error' | 'muted' | 'accent';
-/** One roster row: status mark, profile, session name, checklist progress, in that order. */
+/** One roster row: status mark, profile, session name, todo progress, in that order. */
 export interface SubagentRowView {
     id: string;
     mark: string;
@@ -10,7 +10,7 @@ export interface SubagentRowView {
     /** The profile's colour name (PROP-0029); null for a copy of the parent. */
     color: string | null;
     title: string;
-    /** `n of m tasks`, or null when the child wrote no checklist. */
+    /** `n of m tasks`, or null when the child wrote no todo. */
     tasks: string | null;
 }
 export interface SubagentRosterView {
@@ -18,7 +18,7 @@ export interface SubagentRosterView {
     /** `+N more · /subagents` when rows were left out. */
     overflow: string | null;
 }
-export declare function subagentTasks(checklist: TerminalSubagentActivity['checklist']): string | null;
+export declare function subagentTasks(todo: TerminalSubagentActivity['todo']): string | null;
 /**
  * The compact live roster shown under the status line: active children first, at most three
  * rows. The session name is cut first when the terminal is narrow.

package/dist/sdk/terminal/opentui/subagentsWidget.js

@@ -21,24 +21,26 @@ function mark(status, frame) {
         case 'running': return { mark: frame, tone: 'warning' };
     }
 }
-export function subagentTasks(checklist) {
-    return checklist && checklist.total > 0 ? `${checklist.done} of ${checklist.total} tasks` : null;
+export function subagentTasks(todo) {
+    return todo && todo.total > 0 ? `${todo.done} of ${todo.total} tasks` : null;
 }
 /**
  * The compact live roster shown under the status line: active children first, at most three
  * rows. The session name is cut first when the terminal is narrow.
  */
 export function subagentRoster(items, width, frame = getWorkingSpinnerFrames()[0] ?? '') {
-    if (!items.length || width < 1)
+    // The status line already describes the main agent; its row is only on the /subagents page.
+    const children = items.filter(item => item.relation !== 'main');
+    if (!children.length || width < 1)
         return null;
-    const ordered = [...items].sort((left, right) => {
+    const ordered = [...children].sort((left, right) => {
         const active = Number(ACTIVE_SUBAGENT_STATUSES.has(right.status)) - Number(ACTIVE_SUBAGENT_STATUSES.has(left.status));
         return active || left.startedAt.localeCompare(right.startedAt) || left.id.localeCompare(right.id);
     });
     const rows = ordered.slice(0, MAX_VISIBLE_ROWS).map((item) => {
         const status = mark(item.status, frame);
         const profile = cut(safe(item.profile?.name ?? '') || 'subagent', Math.max(1, Math.min(24, width - 2)));
-        const tasks = subagentTasks(item.checklist);
+        const tasks = subagentTasks(item.todo);
         const used = 2 + visibleWidth(profile) + GAP.length + (tasks ? GAP.length + tasks.length : 0);
         const title = cut(safe(item.title) || 'Subagent', Math.max(1, width - used));
         return { id: item.id, mark: status.mark, tone: status.tone, profile, color: item.profile?.color ?? null, title, tasks };

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

@@ -0,0 +1,43 @@
+export interface OpenTuiTheme {
+    background: string;
+    panel: string;
+    /** The translucent layer that dims the console behind a centered page dialog. */
+    scrim: string;
+    border: string;
+    borderFocus: string;
+    text: string;
+    muted: string;
+    dim: string;
+    /** The shared selected-row field and its two text tones. */
+    selectionBg: string;
+    selectionText: string;
+    selectionMuted: string;
+    questionSelectedBg: string;
+    questionActionBg: string;
+    questionActionText: string;
+    primary: string;
+    accent: string;
+    success: string;
+    warning: string;
+    error: string;
+    /** The composer's Bash mode marker and rules; the command body keeps the normal text color. */
+    bashMode: string;
+    /** The composer's rules while plan mode is on. */
+    planMode: string;
+    /** Image and pasted-text labels in the composer and in sent messages. */
+    attachment: string;
+    purple: string;
+    cyan: string;
+}
+export declare const opentuiTheme: OpenTuiTheme;
+/** The colour of an agent profile's name (PROP-0029); an unknown name falls back to the accent. */
+export declare function profileColor(theme: OpenTuiTheme, name: string): string;
+export declare function blendHexColor(from: string, to: string, amount: number): string;
+export declare function composerRuleColor(theme: OpenTuiTheme, mode: {
+    bash: boolean;
+    plan: boolean;
+    overlay: boolean;
+}): string;
+export declare function noticeColor(theme: OpenTuiTheme, type: string): string;
+export declare function toolColor(theme: OpenTuiTheme, status: 'running' | 'ok' | 'error' | 'pending'): string;
+export declare function thinkingLevelColor(theme: OpenTuiTheme, level: string): string;

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

@@ -0,0 +1,88 @@
+// OpenCode's terminal palette, carried by the Harness's own product name.
+import { SELECTION_COLORS } from "../tui/selection.js";
+export const opentuiTheme = {
+    background: '#0b0b0d',
+    panel: '#111114',
+    scrim: '#0b0b0d99',
+    border: '#2a2a31',
+    borderFocus: '#3a3a44',
+    text: '#e6e6e9',
+    muted: '#8b8b95',
+    dim: '#5c5c66',
+    selectionBg: SELECTION_COLORS.dark.background,
+    selectionText: SELECTION_COLORS.dark.text,
+    selectionMuted: SELECTION_COLORS.dark.muted,
+    questionSelectedBg: '#193322',
+    questionActionBg: '#35754a',
+    questionActionText: '#f7fff8',
+    primary: '#fab283',
+    accent: '#8ab4f8',
+    success: '#a6da95',
+    warning: '#eed49f',
+    error: '#ed8796',
+    bashMode: '#00ff88',
+    planMode: '#8ab4f8',
+    attachment: '#5ea1ff',
+    purple: '#c6a0f6',
+    cyan: '#8bd5ca'
+};
+/** The colour of an agent profile's name (PROP-0029); an unknown name falls back to the accent. */
+export function profileColor(theme, name) {
+    switch (name) {
+        case 'blue': return theme.accent;
+        case 'green': return theme.success;
+        case 'yellow': return theme.warning;
+        case 'red': return theme.error;
+        case 'magenta': return '#f5bde6';
+        case 'cyan': return theme.cyan;
+        case 'orange': return theme.primary;
+        case 'purple': return theme.purple;
+        case 'main': return theme.primary;
+        default: return theme.accent;
+    }
+}
+export function blendHexColor(from, to, amount) {
+    const start = /^#([\da-f]{6})$/iu.exec(from)?.[1];
+    const end = /^#([\da-f]{6})$/iu.exec(to)?.[1];
+    if (!start || !end)
+        return from;
+    const weight = Number.isFinite(amount) ? Math.max(0, Math.min(1, amount)) : 0;
+    const channels = [0, 2, 4].map(offset => {
+        const first = Number.parseInt(start.slice(offset, offset + 2), 16);
+        const second = Number.parseInt(end.slice(offset, offset + 2), 16);
+        return Math.round(first + (second - first) * weight).toString(16).padStart(2, '0');
+    });
+    return `#${channels.join('')}`;
+}
+export function composerRuleColor(theme, mode) {
+    if (mode.bash)
+        return theme.bashMode;
+    if (mode.plan)
+        return theme.planMode;
+    return mode.overlay ? theme.border : theme.dim;
+}
+export function noticeColor(theme, type) {
+    if (type === 'error')
+        return theme.error;
+    if (type === 'warning')
+        return theme.warning;
+    return theme.muted;
+}
+export function toolColor(theme, status) {
+    if (status === 'error')
+        return theme.error;
+    if (status === 'running')
+        return theme.warning;
+    if (status === 'pending')
+        return theme.dim;
+    return theme.success;
+}
+export function thinkingLevelColor(theme, level) {
+    if (level === 'off')
+        return theme.dim;
+    if (level === 'minimal' || level === 'low')
+        return theme.muted;
+    if (level === 'medium')
+        return theme.accent;
+    return theme.primary;
+}