talos-code 0.0.1 → 0.2.0

package/dist/tui/overlays/scroll-window.js

@@ -0,0 +1,234 @@
+import { displayWidth, splitGraphemes } from "../text-width.js";
+const BORDER_ROWS = 2, BORDER_COLUMNS = 2;
+// Below this a border costs more than it shows: 4 rows keep top, bottom and two rows of content.
+const MIN_BORDERED_ROWS = 4;
+/** Lossless word wrap by display width: the rows join back to the text; a word longer than a row is broken inside it. */
+export function wrapDisplay(text, width) {
+    const limit = Math.max(1, Math.floor(width));
+    const rows = [];
+    let row = '', used = 0;
+    const push = () => { rows.push(row); row = ''; used = 0; };
+    const breakInside = (token) => { for (const grapheme of splitGraphemes(token)) {
+        const cells = displayWidth(grapheme);
+        if (row !== '' && used + cells > limit)
+            push();
+        row += grapheme;
+        used += cells;
+    } };
+    for (const token of text.split(/( +)/u)) {
+        if (token === '')
+            continue;
+        const cells = displayWidth(token);
+        if (used + cells <= limit) {
+            row += token;
+            used += cells;
+            continue;
+        }
+        if (token.startsWith(' ') || cells > limit) {
+            breakInside(token);
+            continue;
+        }
+        if (row !== '')
+            push();
+        row = token;
+        used = cells;
+    }
+    if (row !== '' || !rows.length)
+        rows.push(row);
+    return rows;
+}
+/** A line may carry its own line breaks (help text, previews): each is wrapped on its own. */
+function wrapLine(text, width) { return String(text).split(/\r?\n/u).flatMap(part => wrapDisplay(part, width)); }
+export function moreIndicator(above, below) {
+    return [above > 0 ? `↑ ${above} more` : '', below > 0 ? `↓ ${below} more` : ''].filter(Boolean).join(' · ');
+}
+/*
+ * The window over items of known heights. `budget` counts every row, the marker included: when anything is cut one
+ * row is the "↑/↓ N more" marker (if the budget has room for it next to the selected item). `clip` is set only when the
+ * one item in the window is taller than the window by itself.
+ */
+export function sliceByHeights(heights, { budget, selected, offset }) {
+    const count = heights.length, total = heights.reduce((sum, value) => sum + value, 0), rows = Math.max(0, Math.floor(budget));
+    if (total <= rows)
+        return { start: 0, end: count, above: 0, below: 0, maxOffset: 0, clip: null };
+    const room = rows >= 2 ? rows - 1 : rows;
+    // The last start whose tail fits the window: scrolling past it would only show blank rows.
+    let maxOffset = count, used = 0;
+    for (let index = count - 1; index >= 0; index--) {
+        if (used + heights[index] > room)
+            break;
+        used += heights[index];
+        maxOffset = index;
+    }
+    if (maxOffset === count)
+        maxOffset = Math.max(0, count - 1);
+    let start, end;
+    if (selected !== undefined && count > 0) {
+        const anchor = Math.max(0, Math.min(count - 1, Math.trunc(selected) || 0));
+        start = anchor;
+        end = anchor + 1;
+        used = heights[anchor];
+        // Alternate above/below, above first: uniform rows give `pickerWindow`'s floor(size/2) rows above the selection.
+        let turn = 'above', blocked = { above: false, below: false };
+        while (!(blocked.above && blocked.below)) {
+            const side = blocked[turn] ? (turn === 'above' ? 'below' : 'above') : turn;
+            const index = side === 'above' ? start - 1 : end;
+            if (index < 0 || index >= count || used + heights[index] > room)
+                blocked[side] = true;
+            else {
+                used += heights[index];
+                if (side === 'above')
+                    start = index;
+                else
+                    end = index + 1;
+            }
+            turn = turn === 'above' ? 'below' : 'above';
+        }
+    }
+    else {
+        start = Math.max(0, Math.min(maxOffset, Math.trunc(offset ?? 0) || 0));
+        end = start;
+        used = 0;
+        while (end < count && used + heights[end] <= room) {
+            used += heights[end];
+            end++;
+        }
+        if (end === start && count > 0)
+            end = start + 1;
+    }
+    const clip = end - start === 1 && heights[start] > room ? room : null;
+    return { start, end, above: start, below: count - end, maxOffset, clip };
+}
+/*
+ * Chrome that does not fit is dropped in a fixed order and counted in `dropped`: the title (head[0]) is the last to
+ * go after the first foot line (the key hints), and the other lines go before either. Sections share what is left:
+ * each gets what it needs if the sum fits; otherwise a selected section is served first, then the rest is shared.
+ */
+export function fitOverlay(content, { maxRows, columns }) {
+    const limit = maxRows === undefined || !Number.isFinite(maxRows) ? Number.POSITIVE_INFINITY : Math.max(0, Math.floor(maxRows));
+    const border = limit >= MIN_BORDERED_ROWS;
+    const inner = Math.max(1, Math.floor(columns) - (border ? BORDER_COLUMNS : 0));
+    const available = Math.max(0, limit - (border ? BORDER_ROWS : 0));
+    const head = (content.head ?? []).map(line => wrapLine(line.text, inner));
+    const foot = (content.foot ?? []).map(line => wrapLine(line.text, inner));
+    const sections = content.sections.map(section => section.lines.map(line => wrapLine(line.text, inner)));
+    const need = sections.map(blocks => blocks.reduce((sum, rows) => sum + rows.length, 0));
+    const chromeRows = [...head, ...foot].reduce((sum, rows) => sum + rows.length, 0);
+    const bodyNeed = need.reduce((sum, value) => sum + value, 0);
+    let keepHead = head.map(rows => rows.length), keepFoot = foot.map(rows => rows.length), dropped = 0;
+    if (chromeRows + bodyNeed > available) {
+        // Every section keeps at least one row plus its marker (or less, if it needs less).
+        const reserve = need.reduce((sum, value) => sum + Math.min(value, 2), 0);
+        let left = Math.max(0, available - reserve);
+        keepHead = head.map(() => 0);
+        keepFoot = foot.map(() => 0);
+        const order = [...(head.length ? [['head', 0]] : []), ...foot.map((_, index) => ['foot', index]), ...head.slice(1).map((_, index) => ['head', index + 1])];
+        for (const [where, index] of order) {
+            const rows = (where === 'head' ? head : foot)[index].length, take = Math.min(rows, left);
+            if (where === 'head')
+                keepHead[index] = take;
+            else
+                keepFoot[index] = take;
+            left -= take;
+        }
+        dropped = [...head, ...foot].reduce((sum, rows) => sum + rows.length, 0) - [...keepHead, ...keepFoot].reduce((sum, value) => sum + value, 0);
+    }
+    let bodyLeft = Math.max(0, available - [...keepHead, ...keepFoot].reduce((sum, value) => sum + value, 0));
+    const budgets = need.map(() => 0);
+    if (need.reduce((sum, value) => sum + value, 0) <= bodyLeft)
+        need.forEach((value, index) => { budgets[index] = value; });
+    else {
+        const order = need.map((_, index) => index).sort((a, b) => Number(content.sections[b].selected !== undefined) - Number(content.sections[a].selected !== undefined));
+        for (const index of order) {
+            const take = Math.min(need[index], 2, bodyLeft);
+            budgets[index] = take;
+            bodyLeft -= take;
+        }
+        for (let active = order.filter(index => budgets[index] < need[index]); active.length && bodyLeft > 0; active = active.filter(index => budgets[index] < need[index])) {
+            const share = Math.max(1, Math.floor(bodyLeft / active.length));
+            for (const index of active) {
+                const take = Math.min(need[index] - budgets[index], share, bodyLeft);
+                budgets[index] = budgets[index] + take;
+                bodyLeft -= take;
+            }
+        }
+    }
+    const rows = [];
+    const views = [];
+    let cut = false;
+    const chrome = (lines, wrapped, keep, role) => wrapped.forEach((pieces, index) => {
+        for (const text of pieces.slice(0, keep[index]))
+            rows.push({ text, tone: lines[index].tone ?? (role === 'head' && index === 0 ? 'title' : 'dim'), role, selected: false });
+    });
+    chrome(content.head ?? [], head, keepHead, 'head');
+    sections.forEach((blocks, index) => {
+        const section = content.sections[index], budget = budgets[index];
+        if (budget <= 0) {
+            views.push({ start: 0, end: 0, above: 0, below: blocks.length, maxOffset: 0 });
+            if (blocks.length)
+                cut = true;
+            return;
+        }
+        const view = sliceByHeights(blocks.map(pieces => pieces.length), { budget, selected: section.selected, offset: section.offset });
+        views.push({ start: view.start, end: view.end, above: view.above, below: view.below, maxOffset: view.maxOffset });
+        let used = 0;
+        for (let line = view.start; line < view.end; line++) {
+            const pieces = view.clip !== null ? blocks[line].slice(0, view.clip) : blocks[line];
+            const selected = section.selected !== undefined && line === Math.max(0, Math.min(blocks.length - 1, Math.trunc(section.selected) || 0));
+            const { accentTo, accentColor } = section.lines[line];
+            pieces.forEach((text, piece) => rows.push({ text, tone: section.lines[line].tone ?? 'plain', role: 'body', selected, ...(piece === 0 && typeof accentTo === 'number' && accentTo > 0 ? { accentTo, ...(accentColor ? { accentColor } : {}) } : {}) }));
+            used += pieces.length;
+        }
+        if (view.above || view.below || view.clip !== null) {
+            cut = true;
+            if (used < budget)
+                rows.push({ text: moreIndicator(view.above, view.below) || `↓ ${blocks[view.start].length - (view.clip ?? 0)} more`, tone: 'dim', role: 'more', selected: false });
+        }
+    });
+    chrome(content.foot ?? [], foot, keepFoot, 'foot');
+    return { border, borderStyle: content.borderStyle ?? 'round', rows, sections: views, cut, dropped };
+}
+function toneStyle(tone, accentColor) {
+    if (tone === 'title')
+        return { bold: true, color: accentColor };
+    if (tone === 'accent')
+        return { color: accentColor };
+    if (tone === 'selected')
+        return { inverse: true, color: accentColor };
+    if (tone === 'strong')
+        return { bold: true };
+    if (tone === 'dim')
+        return { dimColor: true };
+    return {};
+}
+/** The fitted overlay as Ink elements: one `Text` per row, cut rather than wrapped by Ink, so its height is exact. */
+export function renderFittedOverlay(h, Ink, fitted, { accentColor } = {}) {
+    // `flexShrink:0`: inside lane L's fixed-height root a shrinking box is exactly how a border ends up under content.
+    const box = fitted.border ? { borderStyle: fitted.borderStyle, flexDirection: 'column', flexShrink: 0 } : { flexDirection: 'column', flexShrink: 0 };
+    return h(Ink.Box, box, ...fitted.rows.map((row, index) => typeof row.accentTo === 'number' && row.accentTo > 0 && row.text
+        ? h(Ink.Text, { key: index, wrap: 'truncate-end' }, h(Ink.Text, toneStyle('accent', row.accentColor ?? accentColor), row.text.slice(0, row.accentTo)), h(Ink.Text, toneStyle(row.tone, accentColor), row.text.slice(row.accentTo)))
+        : h(Ink.Text, { key: index, wrap: 'truncate-end', ...toneStyle(row.tone, accentColor) }, row.text || ' ')));
+}
+/** `maxRows` absent: the whole overlay, as tall as its wrapped content (today's behaviour until lane L passes the budget). */
+export function renderOverlay(h, Ink, content, { maxRows, columns, accentColor }) {
+    return renderFittedOverlay(h, Ink, fitOverlay(content, { maxRows, columns }), { accentColor });
+}
+/** Splits an overlay's own line list into chrome and one selectable list (+ an optional detail section after it). */
+export function listOverlay(lines, { head, list, selected, foot, tones }) {
+    const toned = lines.map((text, index) => ({ text, tone: tones?.(text, index) }));
+    const headLines = toned.slice(0, head), listLines = toned.slice(head, head + list);
+    const footLines = foot ? toned.slice(Math.max(head + list, toned.length - foot)) : [];
+    const detail = toned.slice(head + list, toned.length - footLines.length);
+    const sections = [];
+    if (listLines.length)
+        sections.push({ lines: listLines, selected: Math.max(0, Math.min(listLines.length - 1, selected)) });
+    if (detail.length)
+        sections.push({ lines: detail, offset: 0 });
+    return { head: headLines, sections, foot: footLines };
+}
+/** The control centers' look: the title in the accent colour, every other line dim (as app.ts draws them today). */
+export const centerTones = (_line, index) => index === 0 ? 'accent' : 'dim';
+/** A picker's rows as app.ts draws them: `›` and inverse on the selected row, the accent colour on the others. */
+export function pickerSection(rows, selected, label) {
+    return { lines: rows.map((row, index) => ({ text: `${index === selected ? '›' : ' '} ${label(row)}`, tone: index === selected ? 'selected' : 'accent' })), selected };
+}

package/dist/tui/overlays/session-picker.js

@@ -0,0 +1,115 @@
+import { t, tn } from "../../i18n/index.js";
+import { normalizeSessionSummary } from "../../runtime/session-summary.js";
+import { createSessionMetadataStore } from "../../sessions/metadata-store.js";
+import { moveSelection } from "../selection-list.js";
+import { pickerSection } from "./scroll-window.js";
+function isTyped(row) { return Boolean(row && typeof row.id === 'string' && typeof row.sessionId === 'string' && typeof row.depth === 'number' && typeof row.outcome === 'string' && Array.isArray(row.collisions)); }
+export function normalizeSessions(rows) {
+    return rows.map((row) => {
+        const summary = isTyped(row) ? row : normalizeSessionSummary(row);
+        const tags = Array.isArray(row?.tags) ? row.tags.filter((value) => typeof value === 'string') : [];
+        /* R5b D2: the person's own name (/rename, kept in the metadata) wins over the kernel's short name. */
+        const named = typeof row?.metadataName === 'string' && row.metadataName ? row.metadataName : null;
+        return { ...summary, title: named ?? summary.name ?? summary.id, tags, pinned: row?.pinned === true };
+    }).filter(row => row.id).sort((a, b) => {
+        if (a.pinned !== b.pinned)
+            return a.pinned ? -1 : 1;
+        const aTime = a.updatedAt ?? a.startedAt, bTime = b.updatedAt ?? b.startedAt;
+        if (aTime === bTime)
+            return 0;
+        if (aTime === null)
+            return 1;
+        if (bTime === null)
+            return -1;
+        return bTime.localeCompare(aTime);
+    });
+}
+export function filterSessions(rows, query) { const q = query.trim().toLowerCase(); return q ? rows.filter(row => [row.id, row.title, row.project ?? '', row.path ?? '', ...(Array.isArray(row.tags) ? row.tags : [])].some(value => String(value ?? '').toLowerCase().includes(q))) : [...rows]; }
+export function createSessionPickerModel(controller, action, options = {}) {
+    let all = [];
+    let visible = [];
+    let state = { query: '', selected: 0, pageSize: 10 };
+    let cancelled = false;
+    return {
+        async open() { cancelled = false; const source = await controller.listSessions(); if (options.metadataRoot) {
+            const rows = normalizeSessions(source);
+            const store = createSessionMetadataStore({ rootDir: options.metadataRoot });
+            all = normalizeSessions(await Promise.all(rows.map(async (row) => { const metadata = await store.get(row.id); return { ...row, tags: metadata?.tags ?? [], pinned: metadata?.pinned ?? false, ...(metadata?.name ? { metadataName: metadata.name } : {}) }; })));
+            all = sessionTree(all);
+        }
+        else
+            all = source.map(row => ({ ...row, tags: Array.isArray(row.tags) ? row.tags : [], pinned: row.pinned === true })); visible = all; state = { query: '', selected: 0, pageSize: 10 }; },
+        move(next) { state = moveSelection(state, visible.length, next); },
+        select(index) { state = { ...state, selected: Math.max(0, Math.min(Math.max(0, visible.length - 1), Math.trunc(index))) }; },
+        /* R5b: the session it attached (the fork's new id), so the screen can say where a fork came from. */
+        async confirm() { if (cancelled)
+            return null; const row = visible[state.selected]; if (!row)
+            return null; return action === 'resume' ? await controller.resumeSession(row.id) : await controller.forkSession(row.id); },
+        action: () => action,
+        cancel() { cancelled = true; }, rows: () => visible, selected: () => state.selected,
+        setQuery(query) { visible = filterSessions(all, query); state = { ...state, query, selected: 0 }; },
+    };
+}
+/* R5b D2 (Q-R5-12): how long ago, as a person says it; a date after a month. */
+export function sessionAge(iso, now = Date.now()) {
+    const at = typeof iso === 'string' ? Date.parse(iso) : Number.NaN;
+    if (Number.isNaN(at))
+        return '';
+    const minutes = Math.floor(Math.max(0, now - at) / 60_000);
+    if (minutes < 1)
+        return t('screen.session.ageNow');
+    if (minutes < 60)
+        return t('screen.session.ageMinutes', { count: minutes });
+    const hours = Math.floor(minutes / 60);
+    if (hours < 24)
+        return t('screen.session.ageHours', { count: hours });
+    const days = Math.floor(hours / 24);
+    if (days < 31)
+        return t('screen.session.ageDays', { count: days });
+    return new Date(at).toISOString().slice(0, 10);
+}
+/* R5b D2 (Q-R5-12, "the branch tree"): each fork right under the conversation it came from (depth +1), in the list's own
+   order; a fork whose origin is not listed stays where it was. */
+export function sessionTree(rows) {
+    const ids = new Set(rows.map(row => row.id));
+    const children = new Map();
+    const roots = [];
+    for (const row of rows) {
+        const from = row.forkedFrom;
+        if (from && from !== row.id && ids.has(from)) {
+            const list = children.get(from) ?? [];
+            list.push(row);
+            children.set(from, list);
+        }
+        else
+            roots.push(row);
+    }
+    const out = [];
+    const seen = new Set();
+    const visit = (row, depth) => { if (seen.has(row.id))
+        return; seen.add(row.id); out.push({ ...row, forkDepth: depth }); for (const child of children.get(row.id) ?? [])
+        visit(child, Math.min(depth + 1, 4)); };
+    for (const row of roots)
+        visit(row, 0);
+    for (const row of rows)
+        if (!seen.has(row.id))
+            visit(row, 0);
+    return out;
+}
+function sessionRowText(row, now) {
+    const depth = row.forkDepth ?? 0;
+    const parts = [`${row.title || row.id}`, sessionAge(row.updatedAt ?? row.startedAt, now), row.usage?.turns ? tn('screen.session.turns', row.usage.turns) : '', row.model ?? ''].filter(Boolean);
+    return `${row.pinned ? '★ ' : ''}${'  '.repeat(depth)}${depth || row.forkedFrom ? '⑂ ' : ''}${parts.join(' · ')}${row.tags?.length ? ` · ${row.tags.map((tag) => `#${tag}`).join(' ')}` : ''}`;
+}
+// R1 Q-R1-3: the picker as app.ts draws it, capped and scrolled by overlays/scroll-window.ts.
+// R4 Q-R4-13: with nothing to list it says so and how to start one (review D-10 s09: the empty picker had no text; Claude
+// Code "No conversations found in this project.", Codex "No sessions yet", Pi "No sessions in current folder", gate §5.2).
+export function sessionPickerOverlay({ action, query, rows, selected, now = Date.now() }) {
+    const empty = query.trim() ? t('screen.session.noMatch', { query: query.trim() }) : t('screen.session.empty');
+    return {
+        head: [{ text: t(action === 'resume' ? 'screen.session.resumeTitle' : 'screen.session.forkTitle'), tone: 'title' }, { text: t('screen.picker.search', { query: query || t('screen.none') }), tone: 'dim' }],
+        sections: [rows.length
+                ? pickerSection(rows, selected, row => sessionRowText(row, now))
+                : { lines: [{ text: empty, tone: 'dim' }] }],
+    };
+}

package/dist/tui/overlays/tasks-center.js

@@ -0,0 +1,83 @@
+import { en, t } from "../../i18n/index.js";
+import { centerTones, listOverlay } from "./scroll-window.js";
+const UNSAFE = /[\\\x00-\x1f\x7f-\x9f\u2028\u2029\p{Bidi_Control}\p{Default_Ignorable_Code_Point}]/gu;
+function inert(value) { return String(value ?? '').replace(UNSAFE, ch => { if (ch === '\\')
+    return '\\\\'; const cp = ch.codePointAt(0) ?? 0; return cp <= 0xffff ? '\\u' + cp.toString(16).padStart(4, '0') : '\\u{' + cp.toString(16) + '}'; }); }
+/* R2 (gate §1.5, E4): the kernel's `origine` value (modello|persona) is mapped by value, never printed raw. */
+function writerLabel(value) { const id = `screen.writer.${String(value)}`; return Object.hasOwn(en, id) ? t(id) : inert(value); }
+function clamp(value, count) { return count ? Math.max(0, Math.min(count - 1, value)) : 0; }
+export function createTasksCenterModel(snapshot, selected = 0) { return { snapshot, selected: clamp(selected, snapshot.rows.length) }; }
+export function moveTasksCenterSelection(model, delta) { return { ...model, selected: clamp(model.selected + delta, model.snapshot.rows.length) }; }
+export function selectedTask(model) { return model.snapshot.rows[model.selected] ?? null; }
+function evidenceLabel(row) {
+    if (row.state === 'dangling' || !row.measurement)
+        return 'evidence ' + inert(row.sessionId) + ' · dangling';
+    const m = row.measurement;
+    return 'evidence ' + inert(row.sessionId) + ' · available · writes ' + m.scritture + ' · artifacts ' + m.artefatti + ' · tools ' + m.toolCalls + ' · ok ' + m.toolCallsOk + ' · failed ' + m.toolCallsFalliti + ' · verifiable ' + (m.verificabile ? 'yes' : 'no');
+}
+function scheduleLabel(row) {
+    if (row.state === 'dangling')
+        return 'schedule ' + inert(row.automationId) + ' · dangling';
+    return 'schedule ' + inert(row.automationId) + ' · available · executes ' + inert(row.executionTaskId ?? 'unavailable') + ' · interval ' + inert(row.intervalMinutes ?? 'unavailable') + 'm · ' + (row.active ? 'active' : 'inactive') + ' · next ' + inert(row.nextExecution ?? 'unavailable');
+}
+export function renderTasksCenterLines(model) {
+    const lines = [t('screen.tasks.title')];
+    if (model.snapshot.state === 'invalid') {
+        lines.push('Store: invalid · ' + inert(model.snapshot.error?.code ?? 'TASK_BOARD_INVALID') + ' · ' + inert(model.snapshot.error?.message ?? 'unavailable'));
+        lines.push(t('screen.center.closeRefresh'));
+        return lines;
+    }
+    if (!model.snapshot.rows.length) {
+        lines.push(t('screen.tasks.empty'));
+        lines.push(t('screen.center.closeRefresh'));
+        return lines;
+    }
+    lines.push(...model.snapshot.rows.map((row, index) => (index === model.selected ? '› ' : '  ') + '[' + inert(row.status) + '] ' + inert(row.priority) + ' · ' + inert(row.title) + ' · ' + inert(row.id)));
+    const row = selectedTask(model);
+    if (row) {
+        lines.push('ID: ' + inert(row.id) + ' · writer ' + writerLabel(row.writer) + ' (' + inert(row.writerEvidence) + ')');
+        if (row.description)
+            lines.push('Description: ' + inert(row.description));
+        if (row.dependencies.length) {
+            lines.push('Dependencies:');
+            for (const dep of row.dependencies)
+                lines.push('- depends ' + inert(dep.targetTaskId) + ' · ' + inert(dep.state) + (dep.label ? ' · ' + inert(dep.label) : ''));
+        }
+        else
+            lines.push('Dependencies: none');
+        if (row.evidence.length) {
+            lines.push('Evidence:');
+            for (const evidence of row.evidence)
+                lines.push('- ' + evidenceLabel(evidence));
+        }
+        else
+            lines.push('Evidence: none');
+        if (row.agents.length) {
+            lines.push('Agents:');
+            for (const agent of row.agents)
+                lines.push('- agent ' + inert(agent.sessionId) + ' · ' + inert(agent.state) + ' · parent ' + inert(agent.parentSessionId ?? 'unavailable') + ' · depth ' + inert(agent.depth ?? 'unavailable') + ' · ' + inert(agent.task ?? 'unavailable') + ' · ' + inert(agent.outcome));
+        }
+        else
+            lines.push('Agents: none');
+        if (row.schedules.length) {
+            lines.push('Schedules:');
+            for (const schedule of row.schedules)
+                lines.push('- ' + scheduleLabel(schedule));
+        }
+        else
+            lines.push('Schedules: none');
+    }
+    lines.push(t('screen.center.selectRefresh'));
+    lines.push(t('screen.tasks.edges'));
+    lines.push(t('screen.tasks.edgesEvidence'));
+    lines.push(t('screen.tasks.edgesAssign'));
+    lines.push(t('screen.tasks.edgesSchedule'));
+    return lines;
+}
+// R1 Q-R1-3: the same lines as a capped, scrolling overlay — the list keeps the selection visible, the detail scrolls.
+// The four /tasks edge reference lines follow the key hint: they scroll with the detail, the hint stays.
+export function tasksCenterOverlay(model) {
+    const lines = renderTasksCenterLines(model), list = model.snapshot.state === 'invalid' ? 0 : model.snapshot.rows.length;
+    const reference = list ? 4 : 0, hint = lines.length - 1 - reference;
+    return listOverlay([...lines.slice(0, hint), ...lines.slice(hint + 1), lines[hint]], { head: 1, list, selected: model.selected, foot: 1, tones: centerTones });
+}

package/dist/tui/overlays/theme-picker.js

@@ -0,0 +1,21 @@
+/*
+ * R5b D4 (owner decision Q-R5-14): the /theme picker — the ten product themes and mono, each with a swatch drawn in its
+ * own accent, the one in use marked. The arrows preview a theme on the whole screen (theme-store.ts); Enter keeps it, Esc
+ * puts back the one in use.
+ */
+import { t } from "../../i18n/index.js";
+import { TALOS_THEME_ACCENTS } from "../theme-catalog.js";
+import { THEME_CHOICES } from "../theme-store.js";
+export function themeLabel(id) { return TALOS_THEME_ACCENTS.find(row => row.id === id)?.label ?? t('screen.theme.mono'); }
+export function themePickerOverlay({ selected, current, colors }) {
+    const lines = THEME_CHOICES.map((id, index) => {
+        const row = TALOS_THEME_ACCENTS.find(entry => entry.id === id);
+        const text = `${row ? '■' : ' '} ${themeLabel(id)}${id === 'mono' ? ' · ' + t('screen.theme.noColour') : ''}${id === current ? ' · ' + t('screen.theme.inUse') : ''}`;
+        return { text, tone: index === selected ? 'selected' : 'plain', ...(row && colors ? { accentTo: 1, accentColor: row.accent } : {}) };
+    });
+    return {
+        head: [{ text: t('screen.theme.title'), tone: 'title' }],
+        sections: [{ lines, selected }],
+        foot: [{ text: t('screen.theme.keys', { current: themeLabel(current) }), tone: 'dim' }],
+    };
+}

package/dist/tui/overlays/transcript-search.js

@@ -0,0 +1,58 @@
+import { t } from "../../i18n/index.js";
+import { transcriptItemRaw, transcriptItemText } from "../transcript-model.js";
+import { listOverlay } from "./scroll-window.js";
+export function createTranscriptSearchState(selectedId = null) { return { query: '', mode: 'literal', selectedId, raw: false, notice: null }; }
+function haystack(item) { return (item.id + '\n' + item.kind + '\n' + transcriptItemText(item)).toLocaleLowerCase(); }
+function fuzzyIncludes(text, query) {
+    let at = 0;
+    for (const character of query) {
+        at = text.indexOf(character, at);
+        if (at < 0)
+            return false;
+        at++;
+    }
+    return true;
+}
+export function transcriptSearchMatches(items, query, mode) {
+    const needle = String(query ?? '').trim().toLocaleLowerCase();
+    const matches = [];
+    for (let index = 0; index < items.length; index++) {
+        const item = items[index], text = haystack(item);
+        if (!needle || (mode === 'literal' ? text.includes(needle) : fuzzyIncludes(text, needle)))
+            matches.push({ itemId: item.id, index });
+    }
+    return matches;
+}
+export function selectedTranscriptMatch(matches, selectedId) {
+    if (matches.length === 0)
+        return null;
+    return matches.find(row => row.itemId === selectedId) ?? matches[0] ?? null;
+}
+export function moveTranscriptSearchSelection(matches, selectedId, delta) {
+    if (matches.length === 0)
+        return null;
+    const index = matches.findIndex(row => row.itemId === selectedId);
+    if (index < 0)
+        return matches[0].itemId;
+    const next = Math.max(0, Math.min(matches.length - 1, index + delta));
+    return matches[next].itemId;
+}
+export function transcriptSearchLines({ items, state, raw = state.raw }) {
+    const matches = transcriptSearchMatches(items, state.query, state.mode);
+    const selected = selectedTranscriptMatch(matches, state.selectedId);
+    const position = selected ? matches.findIndex(row => row.itemId === selected.itemId) + 1 : 0;
+    const header = t('screen.search.header', { mode: state.mode, position, total: matches.length, view: t(raw ? 'screen.search.viewRaw' : 'screen.search.viewSemantic') });
+    const query = t('screen.search.query', { query: state.query || t('screen.none') });
+    if (!selected)
+        return [header, query, state.notice ?? t('screen.search.none')];
+    const item = items[selected.index];
+    const preview = (raw ? transcriptItemRaw(item) : transcriptItemText(item)).split(/\r?\n/u).slice(0, 10);
+    return [header, query, ...(state.notice ? [state.notice] : []), t('screen.search.selected', { id: item.id }), ...preview];
+}
+// R1 Q-R1-3: the preview scrolls under the header and the query. The `selected:` row heads the scrolling part as its
+// selected line, so a short budget drops the query before it drops the name of the item Enter would jump to.
+export function transcriptSearchOverlay(input) {
+    const lines = transcriptSearchLines(input), marker = t('screen.search.selected', { id: '' }), selected = lines.findIndex(line => line.startsWith(marker));
+    const head = selected < 0 ? 2 : selected;
+    return listOverlay(lines, { head, list: selected < 0 ? 0 : lines.length - head, selected: 0, foot: 0, tones: (_line, index) => index === 0 ? 'accent' : 'dim' });
+}

package/dist/tui/overlays/trust-center.js

@@ -0,0 +1,29 @@
+import { t, tn } from "../../i18n/index.js";
+import { listOverlay } from "./scroll-window.js";
+const UNSAFE = /[\\\x00-\x1f\x7f-\x9f\u2028\u2029\p{Bidi_Control}\p{Default_Ignorable_Code_Point}]/gu;
+const BACKSLASH = String.fromCharCode(92);
+export function inertTrustCenterText(value) { return String(value).replace(UNSAFE, character => { if (character === BACKSLASH)
+    return BACKSLASH + BACKSLASH; const code = character.codePointAt(0); return code > 0xffff ? `${BACKSLASH}u{${code.toString(16)}}` : `${BACKSLASH}u${code.toString(16).padStart(4, '0')}`; }); }
+function shown(value) { return inertTrustCenterText(value); }
+function statusLabel(snapshot) { return snapshot.trusted ? t('screen.trust.trusted') : t('screen.trust.notTrusted', { reason: snapshot.reason }); }
+export function trustCenterModel(snapshot, { permissionMode }) {
+    const projectSection = [
+        t('screen.trust.project', { root: shown(snapshot.workspace.canonicalRoot) }),
+        t('screen.trust.projectTrust', { status: statusLabel(snapshot) }),
+        `Store: ${snapshot.storeSchema ? snapshot.storeSchema === 'v1' ? 'legacy v1' : 'v2' : 'none'}${snapshot.migrationRequired ? ' · migration available' : ''}${snapshot.rollbackAvailable ? ' · rollback available' : ''}`
+    ];
+    const permissionSection = [t('screen.trust.permissionMode', { mode: shown(permissionMode) }), t('screen.trust.policy')];
+    const resourceSection = snapshot.resources.length ? snapshot.resources.map(row => `${row.kind} · ${shown(row.id)} · ${row.state} · ${shown(row.relativePath)}`) : [t('screen.trust.noResources')];
+    const nestedSection = snapshot.nestedRepositories.length ? snapshot.nestedRepositories.map(row => tn('screen.trust.nested', row.resources.length, { path: shown(row.relativePath) })) : [t('screen.trust.noNested')];
+    const actions = [t('screen.trust.review'), t('screen.trust.accept'), t('screen.trust.revoke')];
+    if (snapshot.migrationRequired)
+        actions.push(t(snapshot.nestedRepositories.length ? 'screen.trust.migrateNested' : 'screen.trust.migrate'));
+    if (snapshot.rollbackAvailable)
+        actions.push(t('screen.trust.rollback'));
+    return { title: t('screen.trust.title'), projectSection, permissionSection, resourceSection, nestedSection, actions };
+}
+export function renderTrustCenterLines(model) { return [model.title, '', ...model.projectSection, '', ...model.permissionSection, '', t('screen.trust.resources'), ...model.resourceSection, '', ...model.nestedSection, '', t('screen.trust.actions'), ...model.actions]; }
+// R1 Q-R1-3: the same lines as a capped, scrolling overlay (overlays/scroll-window.ts).
+export function trustCenterOverlay(model) {
+    return listOverlay([...renderTrustCenterLines(model), t('screen.center.closes')], { head: 1, list: 0, selected: 0, foot: 1, tones: (_line, index) => index === 0 ? 'plain' : 'dim' });
+}

package/dist/tui/overlays/workflow-center.js

@@ -0,0 +1,46 @@
+import { t } from "../../i18n/index.js";
+import { centerTones, listOverlay } from "./scroll-window.js";
+const UNSAFE = /[\\\x00-\x1f\x7f-\x9f\u2028\u2029\p{Bidi_Control}\p{Default_Ignorable_Code_Point}]/gu;
+const BACKSLASH = String.fromCharCode(92);
+function inert(value) {
+    return String(value).replace(UNSAFE, character => {
+        if (character === BACKSLASH)
+            return BACKSLASH + BACKSLASH;
+        const code = character.codePointAt(0);
+        return code > 0xffff ? BACKSLASH + 'u{' + code.toString(16) + '}' : BACKSLASH + 'u' + code.toString(16).padStart(4, '0');
+    });
+}
+function shown(value) { return inert(String(value ?? '—')); }
+export function createWorkflowCenterModel(rows, selected = 0) {
+    const copy = rows.map(row => ({ ...row, references: [...row.references] }));
+    return { title: t('screen.workflow.title'), rows: copy, selected: copy.length ? Math.max(0, Math.min(copy.length - 1, selected)) : 0 };
+}
+export function moveWorkflowCenterSelection(model, delta) {
+    if (!model.rows.length)
+        return model;
+    return { ...model, selected: Math.max(0, Math.min(model.rows.length - 1, model.selected + delta)) };
+}
+export function selectedWorkflow(model) { return model.rows[model.selected] ?? null; }
+export function renderWorkflowCenterLines(model) {
+    const lines = [model.title, ''];
+    if (!model.rows.length)
+        return [...lines, t('screen.workflow.empty')];
+    for (const [index, row] of model.rows.entries()) {
+        const state = row.validation.valid ? (row.trust.required ? (row.trust.trusted ? 'trusted' : row.trust.state) : row.trust.state) : 'invalid';
+        lines.push((index === model.selected ? '›' : ' ') + ' ' + shown(row.id) + ' · ' + row.kind + ' · ' + row.provenance.scope + ' · ' + state);
+    }
+    const row = selectedWorkflow(model);
+    if (!row)
+        return lines;
+    lines.push('', 'Selected: ' + shown(row.name) + ' · ' + row.kind, 'Provenance: ' + row.provenance.scope + ' · ' + shown(row.provenance.path), 'Validation: ' + (row.validation.valid ? 'valid' : 'INVALID ' + shown(row.validation.code)) + (row.validation.message ? ' · ' + shown(row.validation.message) : ''), 'Trust: ' + (row.trust.required ? (row.trust.trusted ? 'trusted' : row.trust.state) : row.trust.state), 'Current fingerprint: ' + shown(row.trust.currentFingerprint), 'Trusted fingerprint: ' + shown(row.trust.trustedFingerprint), 'Executable steps: ' + row.executableSteps);
+    if (row.references.length) {
+        lines.push('References');
+        for (const reference of row.references)
+            lines.push('  ' + reference.type + ' · ' + shown(reference.name) + ' · ' + shown(reference.id));
+    }
+    return lines;
+}
+// R1 Q-R1-3: the same lines as a capped, scrolling overlay — the list keeps the selection visible, the detail scrolls.
+export function workflowCenterOverlay(model) {
+    return listOverlay(renderWorkflowCenterLines(model), { head: 2, list: model.rows.length, selected: model.selected, foot: 0, tones: centerTones });
+}