talos-code 0.0.1 → 0.1.0

package/dist/tui/approval.js

@@ -0,0 +1,36 @@
+/* R5a (Q-R5-17, gate finding 15): `beforeDeny` hears the engine's own refusal before the kernel is answered, so whoever shows
+   the row can say who refused before the kernel's receipt of the "no" arrives. */
+export function createApprovalCoordinator({ engine, answer, interactive, mode, beforeDeny }) { const pending = new Map(); return { async request(sessionId, talosRequestId, action) { const currentMode = typeof mode === 'function' ? mode() : mode; const d = await engine.decide(action, { interactive, mode: currentMode }); if (d.kind === 'allow') {
+        await answer(sessionId, talosRequestId, true);
+        return { pending: false, allowed: true, source: d.source };
+    } if (d.kind === 'deny') {
+        try {
+            beforeDeny?.(talosRequestId, { code: d.code, message: d.message });
+        }
+        catch { /* a listener never changes the answer */ }
+        await answer(sessionId, talosRequestId, false);
+        return { pending: false, allowed: false, code: d.code, message: d.message };
+    } pending.set(talosRequestId, { engineId: d.requestId, sessionId }); return { pending: true, allowed: false, action: d.action, reason: d.reason, ...(d.rule ? { rule: d.rule } : {}) }; }, async resolve(talosRequestId, choice) { const p = pending.get(talosRequestId); if (!p)
+        throw new Error('APPROVAL_NOT_PENDING'); pending.delete(talosRequestId); await engine.resolve(p.engineId, choice); await answer(p.sessionId, talosRequestId, choice.startsWith('allow-')); } }; }
+/*
+ * R3 gate E4, owner decision Q-R3-3: why a tool was allowed to run. The engine's allow `source` (permission-engine.ts:38-42)
+ * names it: a session grant, an allow rule (its text), accept-edits, bypassPermissions (Full access), the auto classifier.
+ * `rule` without a text is the built-in allowance for reads inside the project and documented read-only commands: no
+ * approval was involved, so nothing is said. The person's answer names the rest; a denied tool did not run.
+ */
+export function decisionFromSource(source) {
+    if (source === 'session')
+        return { kind: 'session' };
+    if (source === 'acceptEdits')
+        return { kind: 'accept-edits' };
+    if (source === 'bypassPermissions')
+        return { kind: 'full-access' };
+    if (source === 'auto')
+        return { kind: 'auto' };
+    if (source === 'rule' || !source)
+        return null;
+    return { kind: 'rule', rule: source };
+}
+export function decisionFromChoice(choice) {
+    return choice === 'allow-once' ? { kind: 'once' } : choice === 'allow-session' ? { kind: 'session' } : choice === 'allow-always' ? { kind: 'always' } : null;
+}

package/dist/tui/boot/boot-sequence.js

@@ -0,0 +1,76 @@
+import { t } from "../../i18n/index.js";
+import { DESKTOP_LOGO_SOURCE, TALOS_ASCII_FRAMES } from "./desktop-logo.js";
+import { renderCinematicBoot, rowsToSegments, TALOS_BOOT_DURATION_MS, TALOS_GOLD_PALETTE } from "./cinematic.js";
+/*
+ * R4 Q-R4-4 (owner, 2026-09-24): how long the boot holds the screen when nobody presses a key.
+ * - full, with motion: the whole cinematic reveal (7.2 s), on the first launch and after an update only;
+ * - full, without motion (reduced motion, or no colour and so no logo): a static frame for at most 1 s — before R4 these
+ *   terminals waited the whole 7.2 s for an animation they never showed (measured 8,440 ms and 8,600 ms to the composer);
+ * - short (every other launch): the final frame for at most 600 ms.
+ * The sequence that draws the boot owns this length: it signals the end with `onComplete`, and the state functions below
+ * follow that signal instead of re-reading the 7.2 s constant, so lane N passes only `mode` (the R4 contract).
+ */
+export const SHORT_BOOT_MS = 600;
+export const STATIC_BOOT_MS = 1000;
+export function bootRevealMs({ mode, motion }) { return mode === 'short' ? SHORT_BOOT_MS : motion ? TALOS_BOOT_DURATION_MS : STATIC_BOOT_MS; }
+export function createBootState(startedAt) { return { phase: 'revealing', startedAt, skipped: false, runtimeReady: false }; }
+/* R4: a runtime that becomes ready after the reveal ended (`waiting`, whatever its length) opens the composer at once. */
+export function markBootReady(state, now) { if (state.phase === 'error')
+    return state; const elapsed = Math.max(0, now - state.startedAt); const ready = state.skipped || state.phase === 'waiting' || elapsed >= TALOS_BOOT_DURATION_MS; return { ...state, runtimeReady: true, phase: ready ? 'ready' : state.phase }; }
+export function markBootError(state) { return { ...state, phase: 'error' }; }
+export function skipBoot(state) { return { ...state, skipped: true, phase: state.runtimeReady ? 'ready' : state.phase }; }
+/* R4: `completeBoot` is the sequence's own signal that its reveal is over (BootSequence calls it only when its clock says so,
+   re-reading Date.now(), B1 slice 20); the reveal can be 600 ms, 1 s or 7.2 s, so the 7.2 s constant is no longer re-checked. */
+export function completeBoot(state, _now) { if (state.phase === 'error' || state.phase === 'ready')
+    return state; return { ...state, phase: state.runtimeReady ? 'ready' : 'waiting' }; }
+export function bootPhaseAt(state, now) { if (state.phase === 'ready' || state.phase === 'error' || state.phase === 'waiting')
+    return state.phase; const elapsed = Math.max(0, now - state.startedAt); if (state.runtimeReady && (state.skipped || elapsed >= TALOS_BOOT_DURATION_MS))
+    return 'ready'; if (state.skipped || elapsed >= TALOS_BOOT_DURATION_MS)
+    return 'waiting'; return 'revealing'; }
+export function bootFrameAt(state, now, motion) { const last = TALOS_ASCII_FRAMES.length - 1; if (!motion || state.skipped || state.phase === 'ready' || state.phase === 'error')
+    return last; const elapsed = Math.max(0, now - state.startedAt); return Math.min(last, Math.floor(elapsed / TALOS_BOOT_DURATION_MS * Math.max(1, last))); }
+export function bootLinesAt(state, now, { motion, unicode, width = 100 }) { const final = !motion || state.skipped || state.phase === 'ready' || state.phase === 'error'; return renderCinematicBoot(Math.max(0, now - state.startedAt), width, unicode, final).lines; }
+export function shouldRenderBootLogo(capabilities) { return capabilities.interactive && capabilities.color; }
+export function createBootSequenceComponent(React, Ink) {
+    // `logo:false` draws the plain "starting" line and keeps only the timer that ends the boot: without it, a terminal
+    // that gets no logo (no colour) had nothing to call `completeBoot`, and a runtime ready early waited for a key.
+    /* R4 CONTRACT (owner: lane F; lane N passes them from app.ts): `mode` from launch-state.ts bootPlan (Q-R4-4, full or
+       short), `hint` the skip line to draw (dictionary id firstrun.boot.skipHint).
+       R4 lane F: the hint defaults to the dictionary line, so the boot says a key skips it (s01 D-09) whether or not the caller
+       passes it; an empty string draws no hint. It takes the place of the dim stage label, which repeated the stage name the
+       frame already shows (`[SIGNAL ACQUISITION]` twice, gate §2.1). The short boot is the final frame without the counter. */
+    return function BootSequence({ state, logo = true, motion, unicode, width = 100, accentColor, mutedColor, onComplete, mode = 'full', hint = t('firstrun.boot.skipHint') }) {
+        const [now, setNow] = React.useState(() => Date.now());
+        // B1 slice 20: the animation stops with its last frame. Past the reveal every tick redrew an identical logo, 30
+        // times a second, for as long as the runtime kept the boot on screen — an idle render loop.
+        const animated = logo && motion && mode === 'full';
+        const revealMs = bootRevealMs({ mode, motion: animated });
+        React.useEffect(() => { if (!animated || state.phase === 'ready' || state.phase === 'error' || state.skipped)
+            return; const timer = setInterval(() => { const at = Date.now(); setNow(at); if (at - state.startedAt >= TALOS_BOOT_DURATION_MS)
+            clearInterval(timer); }, 33); return () => clearInterval(timer); }, [animated, state.startedAt, state.phase, state.skipped]);
+        /*
+         * B1 slice 20. The logo leaves when this timer says the reveal is over, so the timer must agree with the clock
+         * `completeBoot` reads. Node runs timers on its own loop clock and promises no exact timing: seen through
+         * Date.now() a 7,115 ms timer fired after 7,114, `completeBoot` found the reveal unfinished and returned the same
+         * state, React skipped the render, nothing re-armed, and the logo waited for a key. ⇒ Re-read Date.now() when
+         * the timer fires and re-arm for whatever is left.
+         * ⛔ Only while `revealing`: in `waiting` the end is already signalled, and signalling again made a new state
+         * object, a new `onComplete`, this effect again — a render loop for as long as the runtime was not ready.
+         */
+        React.useEffect(() => { if (state.phase !== 'revealing' || state.skipped)
+            return; let timer; const settle = () => { timer = undefined; const remaining = revealMs - Math.max(0, Date.now() - state.startedAt); if (remaining > 0) {
+            timer = setTimeout(settle, remaining);
+            return;
+        } onComplete?.(); }; settle(); return () => { if (timer !== undefined)
+            clearTimeout(timer); }; }, [state.startedAt, state.phase, state.skipped, onComplete, revealMs]);
+        const phase = bootPhaseAt(state, now);
+        const label = phase === 'error' ? t('firstrun.boot.failed') : phase === 'waiting' ? t('firstrun.boot.waiting') : hint;
+        const labelText = label ? React.createElement(Ink.Text, { dimColor: true, color: mutedColor }, label) : null;
+        if (!logo)
+            return labelText ? React.createElement(Ink.Box, { flexDirection: 'column' }, React.createElement(Ink.Text, { color: accentColor }, 'starting'), labelText) : React.createElement(Ink.Text, { color: accentColor }, 'starting');
+        const final = !animated || state.skipped || state.phase === 'ready' || state.phase === 'error';
+        const frame = renderCinematicBoot(Math.max(0, now - state.startedAt), width, unicode, final, { counter: mode === 'full' });
+        const rows = rowsToSegments(frame);
+        return React.createElement(Ink.Box, { flexDirection: 'column' }, ...rows.map((segments, rowIndex) => React.createElement(Ink.Text, { key: rowIndex, color: accentColor }, ...segments.map((segment, index) => React.createElement(Ink.Text, { key: index, color: segment.level < 0 ? undefined : (TALOS_GOLD_PALETTE[segment.level] ?? accentColor) }, segment.text)))), ...(labelText ? [labelText] : []));
+    };
+}

package/dist/tui/boot/cinematic.js

@@ -0,0 +1,243 @@
+export const TALOS_GOLD_PALETTE = ['#604A12', '#9D7F24', '#D4AF37', '#F7D774', '#FFF4C2'];
+export const TALOS_BOOT_DURATION_MS = 7200;
+const LOGO_FULL = [
+    '████████╗ █████╗ ██╗      ██████╗ ███████╗',
+    '╚══██╔══╝██╔══██╗██║     ██╔═══██╗██╔════╝',
+    '   ██║   ███████║██║     ██║   ██║███████╗',
+    '   ██║   ██╔══██║██║     ██║   ██║╚════██║',
+    '   ██║   ██║  ██║███████╗╚██████╔╝███████║',
+    '   ╚═╝   ╚═╝  ╚═╝╚══════╝ ╚═════╝ ╚══════╝',
+];
+const LOGO_COMPACT = ['╔╦╗╔═╗╦  ╔═╗╔═╗', ' ║ ╠═╣║  ║ ║╚═╗', ' ╩ ╩ ╩╩═╝╚═╝╚═╝'];
+const ASCII_MAP = {
+    '█': '#', '▓': '#', '▒': '+', '░': '.', '╔': '+', '╗': '+', '╚': '+', '╝': '+', '╦': '+', '╩': '+', '╠': '+', '╣': '+', '═': '-', '║': '|', '╲': '\\', '╱': '/', '◇': 'o', '◆': 'O', '◈': 'O', '●': 'o', '•': '.', '·': '.', '━': '=', '─': '-', '│': '|',
+};
+function clamp(value, min, max) { return Math.max(min, Math.min(max, value)); }
+function easeOutCubic(t) { const v = clamp(t, 0, 1); return 1 - Math.pow(1 - v, 3); }
+function easeInOutSine(t) { const v = clamp(t, 0, 1); return -(Math.cos(Math.PI * v) - 1) / 2; }
+function triangleWave(t) { let x = t % 2; if (x < 0)
+    x += 2; return x <= 1 ? x : 2 - x; }
+function layoutForWidth(terminalWidth) {
+    const tw = Math.max(32, Math.trunc(terminalWidth || 80));
+    const mode = tw < 48 ? 'micro' : tw < 72 ? 'compact' : tw < 100 ? 'medium' : 'full';
+    const width = Math.min(112, Math.max(30, tw - 2));
+    const height = mode === 'micro' ? 16 : mode === 'compact' ? 22 : mode === 'medium' ? 26 : 28;
+    const cx = Math.floor(width / 2);
+    const cy = Math.floor(Math.min(height - 8, height * 0.36));
+    return { mode, width, height, cx, cy };
+}
+function mulberry32(seed) { let a = seed >>> 0; return () => { a = (a + 0x6D2B79F5) >>> 0; let t = a; t = Math.imul(t ^ (t >>> 15), t | 1); t ^= t + Math.imul(t ^ (t >>> 7), t | 61); return ((t ^ (t >>> 14)) >>> 0) / 4294967296; }; }
+const rand = mulberry32(1413565519);
+const PARTICLES = Array.from({ length: 64 }, () => ({ x: rand(), y: rand(), vx: (rand() - .5) * .055, vy: (rand() - .5) * .035, phase: rand() * Math.PI * 2, tier: Math.floor(rand() * 3) }));
+function newCanvas(layout) { return Array.from({ length: layout.height }, () => Array.from({ length: layout.width }, () => ({ char: ' ', level: -1 }))); }
+function setCell(canvas, layout, x, y, char, level = 2) { if (x < 0 || y < 0 || x >= layout.width || y >= layout.height)
+    return; const cell = canvas[y][x]; if (char === ' ' && cell.char !== ' ')
+    return; if (level >= cell.level) {
+    cell.char = char;
+    cell.level = level;
+} }
+function putText(canvas, layout, x, y, text, level = 2) { for (const [i, ch] of Array.from(text).entries())
+    setCell(canvas, layout, x + i, y, ch, level); }
+function putCentered(canvas, layout, y, text, level = 2) { putText(canvas, layout, Math.floor((layout.width - Array.from(text).length) / 2), y, text, level); }
+function drawPartialLine(canvas, layout, x0, y0, x1, y1, progress, char, level = 1) { const dx = x1 - x0, dy = y1 - y0, steps = Math.max(Math.abs(dx), Math.abs(dy)); if (steps <= 0) {
+    setCell(canvas, layout, x0, y0, char, level);
+    return;
+} const count = Math.floor(steps * clamp(progress, 0, 1)); for (let s = 0; s <= count; s++) {
+    const t = s / steps;
+    setCell(canvas, layout, Math.round(x0 + dx * t), Math.round(y0 + dy * t), char, level);
+} }
+function stageInfo(elapsed) {
+    if (elapsed < 1)
+        return { name: 'SIGNAL ACQUISITION', progress: elapsed, id: 0 };
+    if (elapsed < 2.2)
+        return { name: 'NETWORK CONVERGENCE', progress: (elapsed - 1) / 1.2, id: 1 };
+    if (elapsed < 3.4)
+        return { name: 'CORE IGNITION', progress: (elapsed - 2.2) / 1.2, id: 2 };
+    if (elapsed < 4.6)
+        return { name: 'SYNCHRONIZATION BUS', progress: (elapsed - 3.4) / 1.2, id: 3 };
+    if (elapsed < 5.8)
+        return { name: 'TALOS ASSEMBLY', progress: (elapsed - 4.6) / 1.2, id: 4 };
+    if (elapsed < 6.7)
+        return { name: 'ENERGY SHIMMER', progress: (elapsed - 5.8) / .9, id: 5 };
+    return { name: 'SYSTEM ONLINE', progress: clamp((elapsed - 6.7) / .5, 0, 1), id: 6 };
+}
+function drawParticles(canvas, layout, elapsed, visibility) { if (layout.mode === 'micro')
+    return; const limit = layout.mode === 'compact' ? 26 : layout.mode === 'medium' ? 42 : 64; const glyphs = ['·', '•', '+']; for (let i = 0; i < limit; i++) {
+    const p = PARTICLES[i];
+    let nx = (p.x + p.vx * elapsed) % 1, ny = (p.y + p.vy * elapsed) % 1;
+    if (nx < 0)
+        nx += 1;
+    if (ny < 0)
+        ny += 1;
+    const pulse = .5 + .5 * Math.sin(elapsed * 2.4 + p.phase);
+    if (pulse > 1 - visibility) {
+        const x = 1 + Math.floor(nx * Math.max(1, layout.width - 2));
+        const y = 2 + Math.floor(ny * Math.max(1, layout.height - 6));
+        setCell(canvas, layout, x, y, glyphs[Math.min(glyphs.length - 1, p.tier)], p.tier);
+    }
+} }
+function drawNetwork(canvas, layout, progress) { if (layout.mode === 'micro')
+    return; const { width: w, height: h, cx, cy } = layout, p = easeOutCubic(progress); const points = [[2, 3], [w - 3, 3], [2, Math.max(5, cy - 1)], [w - 3, Math.max(5, cy - 1)], [4, Math.min(h - 6, cy + 5)], [w - 5, Math.min(h - 6, cy + 5)]]; if (layout.mode === 'full') {
+    points.push([Math.floor(w * .18), h - 6], [Math.floor(w * .82), h - 6]);
+} for (const [x, y] of points) {
+    drawPartialLine(canvas, layout, x, y, cx, cy, p, '·', 0);
+    setCell(canvas, layout, x, y, '◇', 2);
+} if (p > .45) {
+    const inner = (p - .45) / .55;
+    drawPartialLine(canvas, layout, cx - 18, cy, cx + 18, cy, inner, '─', 1);
+    drawPartialLine(canvas, layout, cx, cy - 6, cx, cy + 6, inner, '│', 1);
+} }
+function drawDiamond(canvas, layout, rx, ry, level) { const { cx, cy } = layout; drawPartialLine(canvas, layout, cx, cy - ry, cx + rx, cy, 1, '╲', level); drawPartialLine(canvas, layout, cx + rx, cy, cx, cy + ry, 1, '╱', level); drawPartialLine(canvas, layout, cx, cy + ry, cx - rx, cy, 1, '╲', level); drawPartialLine(canvas, layout, cx - rx, cy, cx, cy - ry, 1, '╱', level); }
+function drawCore(canvas, layout, progress, elapsed) { const p = easeInOutSine(progress); const maxRx = layout.mode === 'full' ? 15 : layout.mode === 'medium' ? 12 : 8; const maxRy = layout.mode === 'full' ? 6 : layout.mode === 'medium' ? 5 : 4; const rx = Math.max(2, Math.round(maxRx * p)), ry = Math.max(1, Math.round(maxRy * p)); if (p > .05)
+    drawDiamond(canvas, layout, rx, ry, 2); if (p > .28)
+    drawDiamond(canvas, layout, Math.max(2, Math.floor(rx * .56)), Math.max(1, Math.floor(ry * .56)), 3); const pulse = .5 + .5 * Math.sin(elapsed * 8); setCell(canvas, layout, layout.cx, layout.cy, p < .33 ? '·' : p < .66 ? '◇' : pulse > .45 ? '◆' : '◈', 4); if (p > .55) {
+    setCell(canvas, layout, layout.cx - Math.floor(rx * .56), layout.cy, '●', 3);
+    setCell(canvas, layout, layout.cx + Math.floor(rx * .56), layout.cy, '●', 3);
+    setCell(canvas, layout, layout.cx, layout.cy - Math.floor(ry * .56), '●', 3);
+    setCell(canvas, layout, layout.cx, layout.cy + Math.floor(ry * .56), '●', 3);
+} }
+function drawScanner(canvas, layout, elapsed, visibility) { if (visibility <= 0)
+    return; const span = layout.mode === 'full' ? Math.min(44, layout.width - 10) : layout.mode === 'medium' ? Math.min(36, layout.width - 8) : Math.min(24, layout.width - 6); const left = layout.cx - Math.floor(span / 2), right = left + span - 1, head = left + Math.round((span - 1) * triangleWave(elapsed * .78 + .12)); for (let x = left; x <= right; x++) {
+    const dist = Math.abs(head - x);
+    if (dist === 0)
+        setCell(canvas, layout, x, layout.cy, '◆', 4);
+    else if (dist === 1)
+        setCell(canvas, layout, x, layout.cy, '━', 3);
+    else if (dist <= 3)
+        setCell(canvas, layout, x, layout.cy, '═', 2);
+    else if (dist <= 6)
+        setCell(canvas, layout, x, layout.cy, '─', 1);
+    else if ((x - left) % 3 === 0)
+        setCell(canvas, layout, x, layout.cy, '·', 0);
+} }
+function logoForMode(mode) { return mode === 'full' || mode === 'medium' ? LOGO_FULL : LOGO_COMPACT; }
+function drawLogoReveal(canvas, layout, progress, final = false) { const logo = logoForMode(layout.mode), logoHeight = logo.length, logoWidth = Math.max(...logo.map(line => Array.from(line).length)); let startY = layout.mode === 'micro' ? Math.max(6, layout.height - logoHeight - 4) : Math.max(layout.cy + 7, layout.height - logoHeight - 4); if (startY + logoHeight >= layout.height)
+    startY = Math.max(2, layout.height - logoHeight - 3); const startX = Math.floor((layout.width - logoWidth) / 2), p = final ? 1 : easeOutCubic(progress), front = Math.round((logoWidth + 8) * p) - 4; for (let row = 0; row < logoHeight; row++) {
+    const chars = Array.from(logo[row]);
+    const localFront = front - Math.round(row * 1.35);
+    for (let col = 0; col < chars.length; col++) {
+        const ch = chars[col];
+        if (ch === ' ')
+            continue;
+        if (col <= localFront)
+            setCell(canvas, layout, startX + col, startY + row, ch, 2);
+        else if (col - localFront <= 2 && !final)
+            setCell(canvas, layout, startX + col, startY + row, (col + row) % 2 === 0 ? '▒' : '░', (col + row) % 2 === 0 ? 1 : 0);
+    }
+} return { x: startX, y: startY, width: logoWidth, height: logoHeight }; }
+function applyShimmer(canvas, layout, bounds, elapsed, final) { const shimmerX = final ? bounds.x + Math.floor(bounds.width * .58) : bounds.x - 7 + Math.round((bounds.width + 14) * clamp((elapsed - 5.8) / .9, 0, 1)); for (let y = bounds.y; y < bounds.y + bounds.height; y++) {
+    for (let x = bounds.x; x < bounds.x + bounds.width; x++) {
+        const cell = canvas[y]?.[x];
+        if (!cell || cell.char === ' ')
+            continue;
+        const d = Math.abs(x - shimmerX);
+        if (d <= 1)
+            cell.level = 4;
+        else if (d <= 3)
+            cell.level = Math.max(cell.level, 3);
+        else if (d <= 6)
+            cell.level = Math.max(cell.level, 2);
+    }
+} }
+function toAscii(char) { return ASCII_MAP[char] ?? (/[\x00-\x7F]/u.test(char) ? char : '#'); }
+function canvasToFrame(canvas, layout, stage, unicode) { const lines = [], levels = []; for (const row of canvas) {
+    const chars = [], ls = [];
+    for (const cell of row) {
+        chars.push(unicode ? cell.char : toAscii(cell.char));
+        ls.push(cell.level);
+    }
+    lines.push(chars.join('').replace(/\s+$/u, ''));
+    levels.push(ls);
+} return { lines, levels, stage: stage.name, mode: layout.mode }; }
+/* R4 Q-R4-4: the short boot is the final frame without the `BOOT nnn%` counter (`counter:false`): a counter that says 100% on
+   every launch is a progress bar with nothing in progress, and s09 recognises a replayed full boot by it. */
+export function renderCinematicBoot(elapsedMs, terminalWidth, unicode = true, final = false, { counter = true } = {}) {
+    const layout = layoutForWidth(terminalWidth);
+    const elapsed = final ? TALOS_BOOT_DURATION_MS / 1000 : clamp(elapsedMs / 1000, 0, TALOS_BOOT_DURATION_MS / 1000);
+    const geometryElapsed = Math.floor(elapsed * 15) / 15, particleElapsed = Math.floor(elapsed * 12) / 12;
+    let stage = stageInfo(geometryElapsed);
+    let canvas = newCanvas(layout);
+    let logoBounds;
+    if (layout.mode !== 'micro') {
+        putText(canvas, layout, 2, 0, 'TALOS // AUTONOMOUS TERMINAL', 2);
+        if (counter) {
+            const right = `BOOT ${String(Math.min(100, Math.floor(elapsed / 7.2 * 100))).padStart(3, '0')}%`;
+            putText(canvas, layout, Math.max(2, layout.width - Array.from(right).length - 2), 0, right, 2);
+        }
+        for (let x = 2; x < layout.width - 2; x++)
+            if (x % 7 !== 0)
+                setCell(canvas, layout, x, 1, '─', 0);
+    }
+    if (stage.id === 0)
+        drawParticles(canvas, layout, particleElapsed, .25 + .75 * stage.progress);
+    else if (stage.id === 1) {
+        drawParticles(canvas, layout, particleElapsed, 1 - .35 * stage.progress);
+        drawNetwork(canvas, layout, stage.progress);
+    }
+    else if (stage.id === 2) {
+        drawParticles(canvas, layout, particleElapsed, .45);
+        drawNetwork(canvas, layout, 1);
+        drawCore(canvas, layout, stage.progress, geometryElapsed);
+    }
+    else if (stage.id === 3) {
+        drawParticles(canvas, layout, particleElapsed, .24);
+        drawNetwork(canvas, layout, 1);
+        drawCore(canvas, layout, 1, geometryElapsed);
+        drawScanner(canvas, layout, geometryElapsed, stage.progress);
+    }
+    else if (stage.id === 4) {
+        drawNetwork(canvas, layout, 1 - .45 * stage.progress);
+        drawCore(canvas, layout, 1, geometryElapsed);
+        drawScanner(canvas, layout, geometryElapsed, 1 - .35 * stage.progress);
+        logoBounds = drawLogoReveal(canvas, layout, stage.progress);
+    }
+    else {
+        drawCore(canvas, layout, 1, geometryElapsed);
+        logoBounds = drawLogoReveal(canvas, layout, 1, true);
+    }
+    if (final) {
+        stage = { name: 'SYSTEM ONLINE', progress: 1, id: 6 };
+        canvas = newCanvas(layout);
+        if (layout.mode !== 'micro') {
+            putText(canvas, layout, 2, 0, 'TALOS // AUTONOMOUS TERMINAL', 2);
+            if (counter)
+                putText(canvas, layout, Math.max(2, layout.width - 11), 0, 'BOOT 100%', 2);
+            for (let x = 2; x < layout.width - 2; x++)
+                if (x % 7 !== 0)
+                    setCell(canvas, layout, x, 1, '─', 0);
+        }
+        drawCore(canvas, layout, 1, geometryElapsed);
+        logoBounds = drawLogoReveal(canvas, layout, 1, true);
+    }
+    if (logoBounds && (stage.id >= 5 || final))
+        applyShimmer(canvas, layout, logoBounds, elapsed, final);
+    const statusY = layout.height - 2;
+    if (layout.mode === 'micro')
+        putCentered(canvas, layout, statusY, '[ TALOS // READY ]', 3);
+    else {
+        putText(canvas, layout, 2, statusY, `[${stage.name}]`, stage.id >= 6 ? 3 : 2);
+        const right = stage.id >= 6 || final ? 'CORE ●   BUS ●   READY ●' : 'CORE ◇   BUS ◇   LINK ◇';
+        putText(canvas, layout, Math.max(2, layout.width - Array.from(right).length - 2), statusY, right, stage.id >= 6 ? 3 : 1);
+    }
+    if (stage.id >= 6) {
+        const pulse = .5 + .5 * Math.sin(elapsed * 4);
+        if (pulse > .72)
+            for (let y = layout.cy - 1; y <= layout.cy + 1; y++)
+                for (let x = layout.cx - 1; x <= layout.cx + 1; x++) {
+                    const cell = canvas[y]?.[x];
+                    if (cell && cell.char !== ' ')
+                        cell.level = 4;
+                }
+    }
+    return canvasToFrame(canvas, layout, stage, unicode);
+}
+export function rowsToSegments(frame) {
+    return frame.lines.map((line, rowIndex) => { const chars = Array.from(line), levels = frame.levels[rowIndex] ?? []; const out = []; for (let i = 0; i < chars.length; i++) {
+        const level = levels[i] ?? -1;
+        const previous = out.at(-1);
+        if (previous && previous.level === level)
+            previous.text += chars[i];
+        else
+            out.push({ text: chars[i], level });
+    } return out; });
+}

package/dist/tui/boot/desktop-logo.js

@@ -0,0 +1,82 @@
+/**
+ * Source of truth: TALOS Desktop 0.1.7 @ 0c432153a288f64237e98403869d02d20d8fabc7
+ * - resources/harness-ui/public/talos/brand/logo-short.svg
+ * - resources/harness-ui/public/index.html boot layers
+ * - resources/harness-ui/public/avvio.js reveal timing
+ *
+ * These frames are manually curated fixed-width terminal interpretations of the
+ * Desktop graph mark. They are checked in; startup never rasterizes SVG assets.
+ */
+export const DESKTOP_LOGO_SOURCE = {
+    commit: '0c432153a288f64237e98403869d02d20d8fabc7',
+    svg: 'resources/harness-ui/public/talos/brand/logo-short.svg',
+    markup: 'resources/harness-ui/public/index.html',
+    script: 'resources/harness-ui/public/avvio.js',
+    nominalRevealMs: 7200,
+};
+export const TALOS_ASCII_FRAMES = Object.freeze([
+    Object.freeze([
+        '             ',
+        '             ',
+        '    ╱   ╲    ',
+        '   ╱     ╲   ',
+        '  │       │  ',
+        '  │       │  ',
+        '   ╲     ╱   ',
+        '    ╲___╱    ',
+    ]),
+    Object.freeze([
+        '      ●      ',
+        '             ',
+        '    ╱   ╲    ',
+        '   ╱     ╲   ',
+        '  │       │  ',
+        '  │       │  ',
+        '   ╲     ╱   ',
+        '    ╲___╱    ',
+    ]),
+    Object.freeze([
+        '      ●      ',
+        '      │      ',
+        '    ╱   ╲    ',
+        '   ╱     ╲   ',
+        '  │       │  ',
+        '  │       │  ',
+        '   ╲     ╱   ',
+        '    ╲___╱    ',
+    ]),
+    Object.freeze([
+        '      ●      ',
+        '      │      ',
+        '    ╱   ╲    ',
+        '   ╱  ●  ╲   ',
+        '  │       │  ',
+        '  │       │  ',
+        '   ╲     ╱   ',
+        '    ╲___╱    ',
+    ]),
+    Object.freeze([
+        '      ●      ',
+        '      │      ',
+        '    ╱   ╲    ',
+        '   ╱  ●  ╲   ',
+        '  │  ╱│╲  │  ',
+        '  │   │   │  ',
+        '   ╲     ╱   ',
+        '    ╲___╱    ',
+    ]),
+    Object.freeze([
+        '      ●      ',
+        '      │      ',
+        '    ╱   ╲    ',
+        '   ╱  ●  ╲   ',
+        '  │  ╱│╲  │  ',
+        '  │ ● │ ● │  ',
+        '   ╲  ●  ╱   ',
+        '    ╲___╱    ',
+    ]),
+]);
+export function asciiLogoFrame(index) {
+    const frame = TALOS_ASCII_FRAMES[Math.max(0, Math.min(TALOS_ASCII_FRAMES.length - 1, Math.trunc(index)))];
+    return frame.map(line => line.replaceAll('●', 'o').replaceAll('│', '|').replaceAll('╱', '/').replaceAll('╲', '\\'));
+}

package/dist/tui/boot.js

@@ -0,0 +1,3 @@
+import { TALOS_ASCII_FRAMES } from "./boot/desktop-logo.js";
+export const BOOT_FRAMES = Object.freeze(TALOS_ASCII_FRAMES.map((_, index) => String(index)));
+export function bootLabel(_frame, phase, detail = '') { const mark = phase === 'loading' ? '…' : phase === 'ready' ? '✓' : '!'; const status = phase === 'loading' ? 'starting' : phase; return `TALOS ${mark} ${status}${detail ? ` · ${detail}` : ''}`; }

package/dist/tui/busy-input.js

@@ -0,0 +1,58 @@
+/*
+ * R5a lane S — S5, what Enter does while TALOS works (owner decisions Q-R5-7 and Q-R5-8; gate E8; owner 2026-09-16).
+ *
+ * Three named modes (Hermes `/busy queue|steer|interrupt`, `hermes_cli/config_defaults.py:808`, 2026-09-24;
+ * `ui-tui/src/app/useConfigSync.ts:45-64`, 2026-09-02), config `ui.busyInput`, default `queue` (today's behaviour):
+ *   - queue: Enter keeps the message and sends it when the turn ends;
+ *   - steer: Enter steers the running turn (what Alt+S does);
+ *   - interrupt: Enter stops the turn, then sends the message.
+ * In every mode `Alt+S` steers and Esc interrupts (E8); a `!` command typed during a turn is queued whatever the mode
+ * (owner 2026-09-16: never runs beside the agent). Slash commands follow Q-R5-8: the views run at once, the commands that
+ * change the session wait for the turn to end; every other command keeps today's behaviour (it runs at once).
+ * Pure: app.ts carries the decision out.
+ */
+import { t } from "../i18n/index.js";
+export const BUSY_INPUT_MODES = Object.freeze(['queue', 'steer', 'interrupt']);
+export const DEFAULT_BUSY_INPUT = 'queue';
+export function parseBusyInput(value) { return typeof value === 'string' && BUSY_INPUT_MODES.includes(value) ? value : null; }
+/* Q-R5-8 (a), as the owner decided it: views run at once; these change the session and wait for the turn. `/busy` is not
+   one of them (owner 2026-09-24): it changes what Enter does now, a screen preference, so it runs at once like Hermes's
+   (no busy guard, ui-tui/src/app/slash/commands/session.ts:622). */
+export const SLASH_VIEWS = new Set(['help', 'status', 'context', 'queue', 'usage']);
+export const SLASH_AFTER_TURN = new Set(['model', 'effort', 'provider', 'compact', 'clear', 'resume', 'fork', 'permissions']);
+export function slashTiming(name) { return SLASH_AFTER_TURN.has(name) ? 'after-turn' : 'now'; }
+/** What Enter does with `text` now. `running` is whether a turn is open. */
+export function busyEnterAction({ text, running, mode }) {
+    const trimmed = String(text ?? '').trim();
+    if (trimmed.startsWith('/')) {
+        const name = trimmed.slice(1).split(/\s+/u)[0] ?? '';
+        return running && slashTiming(name) === 'after-turn' ? 'slash-after-turn' : 'slash-now';
+    }
+    if (!running)
+        return 'send';
+    if (trimmed.startsWith('!'))
+        return 'queue';
+    return mode === 'steer' ? 'steer' : mode === 'interrupt' ? 'interrupt-and-send' : 'queue';
+}
+/** The fixed line while a turn runs: what Enter, Alt+S and Esc do in this mode (Q-R5-7). */
+export function busyLine(mode) { return t(`screen.busyLine.${mode}`); }
+export function busyEffect(mode) { return t(`screen.busyInput.effect.${mode}`); }
+/** The one-time tip, the first time Enter is pressed while TALOS works (Hermes `cli.md:430`, 2026-09-23). */
+export function busyTip(mode) { return t('screen.busyInput.tip', { effect: busyEffect(mode) }); }
+export function busySlash(args) {
+    if (args.length === 0)
+        return { kind: 'show' };
+    const mode = args.length === 1 ? parseBusyInput(args[0].toLowerCase()) : null;
+    return mode ? { kind: 'set', mode } : { kind: 'usage' };
+}
+export function busyShowText(mode) { return t('screen.busyInput.show', { mode, effect: busyEffect(mode) }); }
+export function busySetText(mode) { return t('screen.busyInput.set', { mode, effect: busyEffect(mode) }); }
+/** `/busy [mode]`: the line to show and, for a valid mode, the mode to adopt (and remember). */
+export function busyCommand(args, current) {
+    const choice = busySlash(args);
+    if (choice.kind === 'set')
+        return { text: busySetText(choice.mode), mode: choice.mode };
+    return { text: choice.kind === 'show' ? busyShowText(current) : t('screen.usage.busy'), mode: null };
+}
+/** The Enter actions that earn the one-time tip: a message or a `!` command typed while TALOS works. */
+export function tipsOnEnter(action) { return action === 'queue' || action === 'steer' || action === 'interrupt-and-send'; }