skyloom 1.13.5 → 1.13.7

package/dist/cli/loom.js

@@ -0,0 +1,1094 @@
+"use strict";
+/**
+ * 天空织机 · 立轴 — the full-screen ink-wash weather-station TUI.
+ *
+ * Architecture notes (why this one works where the old full-screen attempt
+ * failed):
+ *   1. Streamed text never touches the terminal directly. It lands in a
+ *      virtual block buffer; every frame is composed in memory and a diff
+ *      renderer repaints only the rows that changed. Streaming and animation
+ *      therefore cannot fight over the cursor.
+ *   2. All width math goes through the CJK-aware helpers in tui.ts, so the
+ *      hand-rolled input editor cannot mangle fullwidth glyphs.
+ *   3. The animation clock is the single writer: key events and stream events
+ *      only mutate state; the frame timer (and explicit repaint requests)
+ *      flush it.
+ *
+ * Layout (画轴 / hanging scroll):
+ *   ┌─ 天空织机 ───────────────────────────── ▣ 霧 ─┐   header + seal
+ *   │  ≋      ❉        ⸽      particles / shuttles │   sky band (2 rows)
+ *   │ ▁▂▃▅▃▂▁▁▂▄▂▁  mountain grows with the session │
+ *   │ ● 霧 fog   │  conversation viewport            │   rail │ viewport
+ *   │ · 雨 rain  │  …                                │
+ *   ├─ 思忖 ··· ──────────────── model · cost · ctx ─┤   status divider
+ *   │ ≋ ❯ input                                      │   input line
+ *   └─ /help · Tab 补全 · PgUp 翻页 ─────────────────┘
+ *
+ * Design rationale: docs/AESTHETIC_DESIGN.md §2.2 (方案三 · 立轴).
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LoomUI = exports.OrchState = exports.SkyField = exports.Screen = void 0;
+exports.cutVisual = cutVisual;
+exports.padAnsi = padAnsi;
+exports.wrapPlain = wrapPlain;
+exports.mountainRow = mountainRow;
+exports.circled = circled;
+exports.overlay = overlay;
+const readline = __importStar(require("readline"));
+const chalk_1 = __importDefault(require("chalk"));
+const theme_1 = require("../core/theme");
+const tui_1 = require("./tui");
+/* ════════════════════════════════════════
+   ANSI-aware string helpers (pure, tested)
+   ════════════════════════════════════════ */
+const ESC = "\x1b";
+const ANSI_RE = /\x1b\[[0-9;]*m/;
+/** Truncate a styled string to a visual width, keeping ANSI sequences intact. */
+function cutVisual(s, maxW) {
+    let out = "";
+    let w = 0;
+    let i = 0;
+    let cut = false;
+    while (i < s.length) {
+        if (s[i] === ESC) {
+            const m = ANSI_RE.exec(s.slice(i));
+            if (m && m.index === 0) {
+                out += m[0];
+                i += m[0].length;
+                continue;
+            }
+        }
+        const cp = s.codePointAt(i);
+        const ch = String.fromCodePoint(cp);
+        const cw = (0, tui_1.charWidth)(cp);
+        if (w + cw > maxW) {
+            cut = true;
+            break;
+        }
+        out += ch;
+        w += cw;
+        i += ch.length;
+    }
+    return cut ? out + "\x1b[0m" : out;
+}
+/** Pad a styled string with spaces to an exact visual width (truncates if over). */
+function padAnsi(s, w) {
+    const cutS = (0, tui_1.visualWidth)(s) > w ? cutVisual(s, w) : s;
+    const diff = w - (0, tui_1.visualWidth)(cutS);
+    return diff > 0 ? cutS + " ".repeat(diff) : cutS;
+}
+/** CJK-aware plain-text word wrap (latin wraps on spaces, CJK per glyph). */
+function wrapPlain(text, width) {
+    const lines = [];
+    if (width < 4)
+        width = 4;
+    for (const raw of text.split("\n")) {
+        let line = "";
+        let col = 0;
+        let word = "";
+        const flushWord = () => {
+            if (!word)
+                return;
+            const w = (0, tui_1.visualWidth)(word);
+            if (col > 0 && col + w > width) {
+                lines.push(line.trimEnd());
+                line = "";
+                col = 0;
+            }
+            // hard-break monster tokens (plain glyph slicing — no ANSI involved)
+            while ((0, tui_1.visualWidth)(word) > width) {
+                let head = "", hw = 0, i = 0;
+                for (const ch of word) {
+                    const cw = (0, tui_1.charWidth)(ch.codePointAt(0));
+                    if (hw + cw > width - col)
+                        break;
+                    head += ch;
+                    hw += cw;
+                    i += ch.length;
+                }
+                lines.push(line + head);
+                word = word.slice(i);
+                line = "";
+                col = 0;
+            }
+            line += word;
+            col += (0, tui_1.visualWidth)(word);
+            word = "";
+        };
+        for (const ch of raw) {
+            const cp = ch.codePointAt(0);
+            if (ch === " " || ch === "\t") {
+                flushWord();
+                if (col > 0 && col < width) {
+                    line += " ";
+                    col += 1;
+                }
+                continue;
+            }
+            if ((0, tui_1.charWidth)(cp) === 2) {
+                flushWord();
+                if (col + 2 > width) {
+                    lines.push(line.trimEnd());
+                    line = "";
+                    col = 0;
+                }
+                line += ch;
+                col += 2;
+                continue;
+            }
+            word += ch;
+        }
+        flushWord();
+        lines.push(line);
+    }
+    // trim trailing blank produced by terminal newline at very end
+    while (lines.length > 1 && lines[lines.length - 1] === "" && text.endsWith("\n"))
+        lines.pop();
+    return lines;
+}
+/** Repaints only rows whose content changed since the previous frame. */
+class Screen {
+    constructor(out) {
+        this.out = out;
+        this.prev = [];
+    }
+    /** Force the next flush to repaint everything (resize / resume). */
+    invalidate() { this.prev = []; }
+    flush(rows, cursor) {
+        let seq = "\x1b[?25l"; // hide cursor while painting
+        for (let i = 0; i < rows.length; i++) {
+            if (this.prev[i] !== rows[i]) {
+                seq += `\x1b[${i + 1};1H\x1b[2K` + rows[i];
+            }
+        }
+        if (this.prev.length > rows.length) {
+            for (let i = rows.length; i < this.prev.length; i++)
+                seq += `\x1b[${i + 1};1H\x1b[2K`;
+        }
+        if (cursor)
+            seq += `\x1b[${cursor.row + 1};${cursor.col + 1}H\x1b[?25h`;
+        this.out.write(seq);
+        this.prev = rows.slice();
+    }
+}
+exports.Screen = Screen;
+/** Per-agent weather motion over a w×2 field. drift/fall/glint/float/bead/rise. */
+class SkyField {
+    constructor(h = 2) {
+        this.h = h;
+        this.particles = [];
+        this.w = 0;
+    }
+    resize(w) {
+        this.w = Math.max(8, w);
+        const n = Math.max(3, Math.floor(this.w / 7));
+        this.particles = Array.from({ length: n }, (_, i) => ({
+            x: (i * 7.3 + (i * i % 5)) % this.w,
+            y: (i * 13) % this.h,
+            phase: (i * 37) % 17,
+        }));
+    }
+    step(motion, tick) {
+        for (const p of this.particles) {
+            switch (motion) {
+                case "drift":
+                    p.x += 0.45;
+                    p.y = (Math.sin((tick + p.phase) / 6) > 0 ? 0 : 1);
+                    break;
+                case "fall":
+                    p.y += 0.55;
+                    p.x += 0.12;
+                    break;
+                case "glint": /* static, blink via phase at render */ break;
+                case "float":
+                    p.y += 0.28;
+                    p.x += Math.sin((tick + p.phase) / 4) * 0.5;
+                    break;
+                case "bead": /* static, brightness breathes */ break;
+                case "rise":
+                    p.y -= 0.3;
+                    break;
+            }
+            if (p.x >= this.w)
+                p.x -= this.w;
+            if (p.x < 0)
+                p.x += this.w;
+            if (p.y >= this.h)
+                p.y -= this.h;
+            if (p.y < 0)
+                p.y += this.h;
+        }
+    }
+    /** Render the two sky rows. Shuttles (orchestration) overlay the weather. */
+    render(w, motion, symbol, hex, tick, shuttles) {
+        if (w !== this.w)
+            this.resize(w);
+        const grid = Array.from({ length: this.h }, () => Array.from({ length: w }, () => ({ ch: " ", style: (s) => s })));
+        const pigment = chalk_1.default.hex(hex);
+        for (const p of this.particles) {
+            const visible = motion === "glint" ? Math.sin((tick + p.phase) / 3) > -0.2 : true;
+            if (!visible)
+                continue;
+            const dimmed = motion === "bead" ? Math.sin((tick + p.phase) / 5) < 0 : (p.phase % 3 === 0);
+            const x = Math.min(w - 1, Math.round(p.x));
+            const y = Math.min(this.h - 1, Math.round(p.y));
+            grid[y][x] = { ch: symbol, style: dimmed ? (s) => pigment.dim(s) : (s) => pigment(s) };
+        }
+        // Loom shuttles: a thread of ┄ in the agent's pigment, shuttle glyph at the head.
+        for (const sh of shuttles) {
+            const row = sh.row % this.h;
+            const head = Math.round(sh.x) % w;
+            const thread = chalk_1.default.hex(sh.hex).dim;
+            for (let x = 0; x < head; x++)
+                if (grid[row][x].ch === " ")
+                    grid[row][x] = { ch: "┄", style: thread };
+            grid[row][head] = { ch: sh.symbol, style: chalk_1.default.hex(sh.hex).bold };
+        }
+        return grid.map((cells) => {
+            let line = "";
+            for (const c of cells)
+                line += c.ch === " " ? " " : c.style(c.ch);
+            return line;
+        });
+    }
+}
+exports.SkyField = SkyField;
+/** Distant-mountain silhouette; grows slowly as the session lengthens. */
+function mountainRow(width, turns) {
+    const GLYPHS = [" ", "▁", "▂", "▃", "▄", "▅"];
+    const growth = Math.min(1, turns / 30) * 0.7 + 0.3;
+    let out = "";
+    for (let x = 0; x < width; x++) {
+        // layered sines make a credible ridge; deterministic, so the diff renderer
+        // only repaints this row when `turns` changes.
+        const r = Math.sin(x / 6.1) * 0.5 + Math.sin(x / 13.7 + 2) * 0.35 + Math.sin(x / 3.3 + 5) * 0.15;
+        const h = Math.max(0, Math.round((r * 0.5 + 0.5) * (GLYPHS.length - 1) * growth));
+        out += GLYPHS[h];
+    }
+    return chalk_1.default.hex(theme_1.PALETTE.inkFaint).dim(out);
+}
+const CIRCLED = "①②③④⑤⑥⑦⑧⑨⑩⑪⑫⑬⑭⑮⑯⑰⑱⑲⑳";
+function circled(i) { return CIRCLED[i] ?? `(${i + 1})`; }
+class OrchState {
+    constructor() {
+        this.tasks = new Map();
+        this.order = [];
+        this.active = false;
+        /** moving shuttle x-position per running agent */
+        this.shuttleX = new Map();
+    }
+    plan(raw) {
+        this.active = true;
+        for (const t of raw) {
+            if (this.tasks.has(t.id))
+                continue;
+            this.tasks.set(t.id, {
+                id: t.id,
+                index: this.order.length,
+                agent: t.assignedTo || "fog",
+                desc: String(t.description || "").split("\n")[0],
+                deps: (t.allDeps || []).slice(),
+                state: "wait",
+            });
+            this.order.push(t.id);
+        }
+    }
+    start(id) {
+        const t = this.tasks.get(id);
+        if (t) {
+            t.state = "run";
+            t.startedAt = Date.now();
+            this.shuttleX.set(t.agent, 0);
+        }
+    }
+    done(id, ok) {
+        const t = this.tasks.get(id);
+        if (!t)
+            return;
+        t.state = ok ? "ok" : "fail";
+        t.ms = t.startedAt ? Date.now() - t.startedAt : undefined;
+        if (![...this.tasks.values()].some((x) => x.state === "run" && x.agent === t.agent)) {
+            this.shuttleX.delete(t.agent);
+        }
+    }
+    finish() { this.active = false; this.shuttleX.clear(); }
+    runningAgents() {
+        return [...new Set([...this.tasks.values()].filter((t) => t.state === "run").map((t) => t.agent))];
+    }
+    /** Per-agent ✓/✗ tally for the rail. */
+    tally(agent) {
+        let ok = 0, fail = 0, run = false;
+        for (const t of this.tasks.values()) {
+            if (t.agent !== agent)
+                continue;
+            if (t.state === "ok")
+                ok++;
+            else if (t.state === "fail")
+                fail++;
+            else if (t.state === "run")
+                run = true;
+        }
+        return { ok, fail, run };
+    }
+    progress() {
+        let done = 0;
+        for (const t of this.tasks.values())
+            if (t.state === "ok" || t.state === "fail")
+                done++;
+        return { done, total: this.tasks.size };
+    }
+}
+exports.OrchState = OrchState;
+const RAIL_W = 15; // visual columns of the left rail (inside borders)
+const SKY_H = 2;
+class LoomUI {
+    constructor(opts) {
+        this.sky = new SkyField(SKY_H);
+        this.blocks = [];
+        this.byId = new Map();
+        this.tick = 0;
+        this.timer = null;
+        this.destroyed = false;
+        this.agentName = "fog";
+        this.turns = 0;
+        this.busy = false;
+        this.busyLabel = "";
+        this.orch = new OrchState();
+        /** status providers (wired by the chat loop) */
+        this.statusRight = () => "";
+        // input editor state
+        this.inputGlyphs = []; // glyphs
+        this.cursor = 0;
+        this.history = [];
+        this.histIdx = -1;
+        this.histStash = "";
+        this.scrollOff = 0; // 0 = follow tail
+        this.paletteIdx = 0;
+        this.pendingResolve = null;
+        this.modal = null;
+        this.sigintAt = 0;
+        this.onInterrupt = null;
+        /** Shift+Tab cycles interactive modes (default/plan/auto); wired by the chat loop. */
+        this.onModeCycle = null;
+        /** Styled mode badge shown in the status divider when idle ('' = default). */
+        this.modeBadge = "";
+        /** User-defined slash commands shown in the palette ([name, description]). */
+        this.extraCommands = [];
+        this.keypressHandler = null;
+        this.resizeHandler = null;
+        /* ── streaming ── */
+        this.openBlock = null;
+        this.bleedLen = 0;
+        this.flashHint = "";
+        this.viewportCache = null;
+        this.out = opts?.out ?? process.stdout;
+        this.inp = opts?.inp === undefined ? process.stdin : opts.inp;
+        this.headless = opts?.headless ?? false;
+        this.screen = new Screen(this.out);
+    }
+    /* ── lifecycle ── */
+    start() {
+        if (!this.headless) {
+            this.out.write("\x1b[?1049h\x1b[2J"); // alternate screen
+            if (this.inp && this.inp.isTTY) {
+                readline.emitKeypressEvents(this.inp);
+                this.inp.setRawMode(true);
+                this.inp.resume();
+                this.keypressHandler = (str, key) => this.onKey(str, key);
+                this.inp.on("keypress", this.keypressHandler);
+            }
+            this.resizeHandler = () => { this.screen.invalidate(); this.invalidateWraps(); this.paint(); };
+            process.stdout.on?.("resize", this.resizeHandler);
+            this.timer = setInterval(() => this.frame(), 120);
+        }
+        this.paint();
+    }
+    destroy() {
+        if (this.destroyed)
+            return;
+        this.destroyed = true;
+        if (this.timer)
+            clearInterval(this.timer);
+        if (this.inp && this.keypressHandler)
+            this.inp.removeListener("keypress", this.keypressHandler);
+        if (this.resizeHandler)
+            process.stdout.removeListener?.("resize", this.resizeHandler);
+        if (!this.headless) {
+            if (this.inp && this.inp.isTTY)
+                this.inp.setRawMode(false);
+            this.out.write("\x1b[?1049l\x1b[?25h");
+        }
+    }
+    /** Temporarily leave the loom (setup wizard etc.), then restore. */
+    async suspend(fn) {
+        if (this.inp && this.inp.isTTY)
+            this.inp.setRawMode(false);
+        if (this.inp && this.keypressHandler)
+            this.inp.removeListener("keypress", this.keypressHandler);
+        if (this.timer) {
+            clearInterval(this.timer);
+            this.timer = null;
+        }
+        this.out.write("\x1b[?1049l\x1b[?25h");
+        try {
+            return await fn();
+        }
+        finally {
+            this.out.write("\x1b[?1049h\x1b[2J");
+            if (this.inp && this.inp.isTTY) {
+                this.inp.setRawMode(true);
+                this.inp.resume();
+                if (this.keypressHandler)
+                    this.inp.on("keypress", this.keypressHandler);
+            }
+            this.screen.invalidate();
+            if (!this.headless)
+                this.timer = setInterval(() => this.frame(), 120);
+            this.paint();
+        }
+    }
+    /* ── block API ── */
+    push(b) {
+        const blk = { version: 0, ...b };
+        this.blocks.push(blk);
+        if (blk.id)
+            this.byId.set(blk.id, blk);
+        if (this.blocks.length > 3000) {
+            const drop = this.blocks.splice(0, 500);
+            for (const d of drop)
+                if (d.id)
+                    this.byId.delete(d.id);
+        }
+        this.scrollOff = 0; // new content snaps to tail
+        return blk;
+    }
+    blank() { this.push({ kind: "blank", text: "" }); }
+    /** Pre-styled single line (truncated, never wrapped). */
+    line(text, id) {
+        if (id && this.byId.has(id)) {
+            this.update(id, text);
+            return;
+        }
+        this.push({ kind: "line", text, id });
+    }
+    update(id, text) {
+        const b = this.byId.get(id);
+        if (b && b.text !== text) {
+            b.text = text;
+            b.version++;
+        }
+    }
+    /** Wrapped plain-text block. With an id, later calls update it in place. */
+    text(text, style, head, id) {
+        if (id && this.byId.has(id)) {
+            this.update(id, text);
+            return;
+        }
+        this.push({ kind: "text", text, style, head, id });
+    }
+    beginStream(agentName) {
+        const t = (0, theme_1.agentTheme)(agentName);
+        this.blank();
+        this.line(chalk_1.default.bold.hex(t.hex)(`${t.symbol} ${t.kanji} `) + chalk_1.default.hex(t.hex)(t.name));
+        this.blank();
+        this.openBlock = this.push({ kind: "text", text: "", open: true });
+        this.bleedLen = 0;
+    }
+    /** Re-open a fresh stream block (after a tool event), without the header. */
+    continueStream() {
+        this.endStream();
+        this.openBlock = this.push({ kind: "text", text: "", open: true });
+        this.bleedLen = 0;
+    }
+    streamWrite(s) {
+        if (!this.openBlock)
+            this.beginStream(this.agentName);
+        const b = this.openBlock;
+        b.text += s.replace(/\r/g, "");
+        b.version++;
+        this.bleedLen = Math.min(12, this.bleedLen + [...s].length);
+    }
+    endStream() {
+        if (this.openBlock) {
+            this.openBlock.open = false;
+            this.openBlock.version++;
+            this.openBlock = null;
+        }
+        this.bleedLen = 0;
+    }
+    clearViewport() { this.blocks = []; this.byId.clear(); this.scrollOff = 0; this.viewportCache = null; this.paint(); }
+    /** Transient hint in the status divider. */
+    flash(msg, ms = 1600) {
+        this.flashHint = msg;
+        this.paint();
+        setTimeout(() => { if (this.flashHint === msg) {
+            this.flashHint = "";
+            this.paint();
+        } }, ms);
+    }
+    /* ── input ── */
+    /** Read one submitted line (the editor stays live during streaming). */
+    readInput() {
+        return new Promise((resolve) => { this.pendingResolve = resolve; });
+    }
+    /** Modal y/N confirmation (tool approval). */
+    confirm(text) {
+        return new Promise((resolve) => { this.modal = { text, resolve }; this.paint(); });
+    }
+    setHistory(h) { this.history = h.slice(); }
+    onKey(str, key) {
+        if (this.destroyed)
+            return;
+        if (this.modal) {
+            const k = (str || "").toLowerCase();
+            if (k === "y") {
+                const m = this.modal;
+                this.modal = null;
+                m.resolve(true);
+            }
+            else if (k === "n" || key?.name === "return" || key?.name === "escape") {
+                const m = this.modal;
+                this.modal = null;
+                m.resolve(false);
+            }
+            this.paint();
+            return;
+        }
+        const name = key?.name;
+        if (key?.ctrl && name === "c") {
+            this.handleSigint();
+            return;
+        }
+        if (name === "pageup") {
+            this.scrollOff += Math.max(1, this.bodyH() - 2);
+            this.clampScroll();
+            this.paint();
+            return;
+        }
+        if (name === "pagedown") {
+            this.scrollOff -= Math.max(1, this.bodyH() - 2);
+            this.clampScroll();
+            this.paint();
+            return;
+        }
+        if (name === "return") {
+            if (this.busy)
+                return; // a reply is being woven; ignore submit
+            let text = this.inputGlyphs.join("").trim();
+            // Palette open: Enter runs the ↑↓-highlighted command (Claude Code
+            // style). Commands that take arguments fill the input instead so the
+            // user can type them.
+            const matches = this.paletteMatches();
+            if (matches.length > 0 && text.startsWith("/")) {
+                const [cmd] = matches[Math.max(0, Math.min(this.paletteIdx, matches.length - 1))];
+                if (cmd.endsWith(" ")) {
+                    // argument-taking command: fill the input and wait for arguments
+                    // (the palette closes once the line contains a space; a second
+                    // Enter then submits as typed)
+                    this.inputGlyphs = [...cmd];
+                    this.cursor = this.inputGlyphs.length;
+                    this.paletteIdx = 0;
+                    this.paint();
+                    return;
+                }
+                text = cmd.trimEnd();
+            }
+            this.inputGlyphs = [];
+            this.cursor = 0;
+            this.histIdx = -1;
+            this.paletteIdx = 0;
+            if (text) {
+                this.history.unshift(text);
+                if (this.history.length > 200)
+                    this.history.pop();
+            }
+            const r = this.pendingResolve;
+            this.pendingResolve = null;
+            this.paint();
+            if (r)
+                r(text);
+            return;
+        }
+        const paletteOpen = this.paletteMatches().length > 0 && this.inputGlyphs[0] === "/";
+        if (name === "up") {
+            if (paletteOpen) {
+                this.paletteIdx = Math.max(0, this.paletteIdx - 1);
+            }
+            else if (this.histIdx < this.history.length - 1) {
+                if (this.histIdx === -1)
+                    this.histStash = this.inputGlyphs.join("");
+                this.histIdx++;
+                this.inputGlyphs = [...this.history[this.histIdx]];
+                this.cursor = this.inputGlyphs.length;
+            }
+            this.paint();
+            return;
+        }
+        if (name === "down") {
+            if (paletteOpen) {
+                this.paletteIdx = Math.min(this.paletteMatches().length - 1, this.paletteIdx + 1);
+            }
+            else if (this.histIdx >= 0) {
+                this.histIdx--;
+                this.inputGlyphs = [...(this.histIdx === -1 ? this.histStash : this.history[this.histIdx])];
+                this.cursor = this.inputGlyphs.length;
+            }
+            this.paint();
+            return;
+        }
+        if (name === "tab" && key?.shift) {
+            this.onModeCycle?.();
+            this.paint();
+            return;
+        }
+        if (name === "tab") {
+            if (paletteOpen) {
+                const m = this.paletteMatches();
+                const pick = m[Math.min(this.paletteIdx, m.length - 1)];
+                if (pick) {
+                    this.inputGlyphs = [...pick[0].trimEnd()];
+                    this.cursor = this.inputGlyphs.length;
+                }
+            }
+            this.paint();
+            return;
+        }
+        if (name === "escape") {
+            // Esc closes the palette by clearing the slash input; otherwise it
+            // just resets selection / jumps back to the tail.
+            if (paletteOpen) {
+                this.inputGlyphs = [];
+                this.cursor = 0;
+            }
+            this.paletteIdx = 0;
+            this.scrollOff = 0;
+            this.paint();
+            return;
+        }
+        if (name === "backspace") {
+            if (this.cursor > 0) {
+                this.inputGlyphs.splice(this.cursor - 1, 1);
+                this.cursor--;
+            }
+            this.paletteIdx = 0; // filter changed — selection restarts at the top
+            this.paint();
+            return;
+        }
+        if (name === "delete") {
+            if (this.cursor < this.inputGlyphs.length)
+                this.inputGlyphs.splice(this.cursor, 1);
+            this.paint();
+            return;
+        }
+        if (name === "left") {
+            if (this.cursor > 0)
+                this.cursor--;
+            this.paint();
+            return;
+        }
+        if (name === "right") {
+            if (this.cursor < this.inputGlyphs.length)
+                this.cursor++;
+            this.paint();
+            return;
+        }
+        if (key?.ctrl && name === "a") {
+            this.cursor = 0;
+            this.paint();
+            return;
+        }
+        if (key?.ctrl && name === "e") {
+            this.cursor = this.inputGlyphs.length;
+            this.paint();
+            return;
+        }
+        if (key?.ctrl && name === "u") {
+            this.inputGlyphs.splice(0, this.cursor);
+            this.cursor = 0;
+            this.paint();
+            return;
+        }
+        if (key?.ctrl && name === "w") {
+            let i = this.cursor;
+            while (i > 0 && this.inputGlyphs[i - 1] === " ")
+                i--;
+            while (i > 0 && this.inputGlyphs[i - 1] !== " ")
+                i--;
+            this.inputGlyphs.splice(i, this.cursor - i);
+            this.cursor = i;
+            this.paint();
+            return;
+        }
+        if (key?.ctrl && name === "l") {
+            this.clearViewport();
+            return;
+        }
+        if (str && !key?.ctrl && !key?.meta) {
+            const glyphs = [...str].filter((c) => c >= " " || (0, tui_1.charWidth)(c.codePointAt(0)) > 0);
+            if (glyphs.length) {
+                this.inputGlyphs.splice(this.cursor, 0, ...glyphs);
+                this.cursor += glyphs.length;
+                this.histIdx = -1;
+                this.paletteIdx = 0; // filter changed — selection restarts at the top
+                this.paint();
+            }
+        }
+    }
+    handleSigint() {
+        const now = Date.now();
+        if (this.busy && this.onInterrupt) {
+            this.onInterrupt();
+            return;
+        }
+        if (now - this.sigintAt < 1500) {
+            this.destroy();
+            process.stdout.write(chalk_1.default.dim("  再会。\n"));
+            process.exit(0);
+        }
+        this.sigintAt = now;
+        this.flash("再按一次 Ctrl-C 退出");
+    }
+    paletteMatches() {
+        const l = this.inputGlyphs.join("");
+        if (!l.startsWith("/") || l.includes(" "))
+            return [];
+        return [...tui_1.SLASH_COMMANDS, ...this.extraCommands].filter(([c]) => c.trimEnd().startsWith(l));
+    }
+    /* ── geometry ── */
+    cols() { return Math.max(40, this.out.columns || 80); }
+    rows() { return Math.max(12, this.out.rows || 24); }
+    // header(1) + sky(2) + body + divider(1) + input(1) + bottom(1) = rows
+    bodyH() { return this.rows() - SKY_H - 4; }
+    clampScroll() {
+        const total = this.viewportLines().length;
+        const maxOff = Math.max(0, total - this.bodyH());
+        this.scrollOff = Math.max(0, Math.min(this.scrollOff, maxOff));
+    }
+    invalidateWraps() { for (const b of this.blocks)
+        b.cache = undefined; }
+    /* ── frame composition ── */
+    frame() {
+        this.tick++;
+        const animate = this.busy || this.orch.active;
+        // advance shuttles
+        if (this.orch.active) {
+            for (const [a, x] of this.orch.shuttleX)
+                this.orch.shuttleX.set(a, x + 1.3);
+        }
+        // ink "dries": the bleed tail shrinks even when no new tokens arrive
+        if (this.openBlock && this.bleedLen > 0 && this.tick % 2 === 0)
+            this.bleedLen = Math.max(0, this.bleedLen - 2);
+        if (animate || this.tick % 5 === 0) {
+            const t = (0, theme_1.agentTheme)(this.agentName);
+            this.sky.step(t.motion, this.tick);
+            this.paint();
+        }
+    }
+    viewportLines() {
+        const w = this.viewW();
+        // the open block's cursor pulse + bleed tail animate with the clock
+        const anim = this.openBlock ? `|b${this.bleedLen}|t${this.tick & 7}` : "";
+        const key = this.blocks.map((b) => b.version).join(",") + `|${w}|${this.blocks.length}` + anim;
+        if (this.viewportCache && this.viewportCache.key === key)
+            return this.viewportCache.lines;
+        const lines = [];
+        for (const b of this.blocks) {
+            if (b.kind === "blank") {
+                lines.push("");
+                continue;
+            }
+            if (b.kind === "line") {
+                lines.push(cutVisual(b.text, w));
+                continue;
+            }
+            if (!b.cache || b.cache.width !== w || b.cache.version !== b.version) {
+                const wrapped = wrapPlain(b.text, b.head ? w - (0, tui_1.visualWidth)(b.head) : w);
+                b.cache = { width: w, version: b.version, lines: wrapped };
+            }
+            const style = b.style ?? ((s) => s);
+            b.cache.lines.forEach((ln, i) => {
+                const head = b.head ? (i === 0 ? b.head : " ".repeat((0, tui_1.visualWidth)(b.head))) : "";
+                let body = style(ln);
+                if (b.open && i === b.cache.lines.length - 1) {
+                    // ink-bleed: the freshest glyphs render faint, "drying" into full ink
+                    const glyphs = [...ln];
+                    const bleed = Math.min(this.bleedLen, glyphs.length);
+                    if (bleed > 0) {
+                        const headPart = glyphs.slice(0, glyphs.length - bleed).join("");
+                        const tailPart = glyphs.slice(glyphs.length - bleed).join("");
+                        body = style(headPart) + chalk_1.default.hex(theme_1.PALETTE.inkLight)(tailPart);
+                    }
+                    body += this.tick % 8 < 4 ? chalk_1.default.hex((0, theme_1.agentTheme)(this.agentName).hex)("▍") : chalk_1.default.dim("▏");
+                }
+                lines.push(head + body);
+            });
+        }
+        this.viewportCache = { lines, key };
+        return lines;
+    }
+    // borders(2) + rail + rail-border(1) + gutter(1)
+    viewW() { return this.cols() - 2 - RAIL_W - 2; }
+    railLines(h) {
+        const out = [];
+        const W = RAIL_W;
+        out.push("");
+        for (const name of theme_1.AGENT_ORDER) {
+            const t = (0, theme_1.agentTheme)(name);
+            const active = name === this.agentName;
+            const tally = this.orch.tally(name);
+            let marker;
+            if (tally.run)
+                marker = this.tick % 2 ? chalk_1.default.hex(t.hex)(t.symbol) : chalk_1.default.hex(t.hex).dim(t.symbol);
+            else
+                marker = active ? chalk_1.default.hex(t.hex)("●") : chalk_1.default.hex(theme_1.PALETTE.inkFaint)("·");
+            let badge = "";
+            if (tally.ok)
+                badge += chalk_1.default.hex("#3a7a6e")(` ✓${tally.ok}`);
+            if (tally.fail)
+                badge += chalk_1.default.hex("#b3342d")(` ✗${tally.fail}`);
+            const label = active ? chalk_1.default.bold.hex(t.hex)(`${t.kanji} ${t.name}`) : chalk_1.default.hex(t.hex).dim(`${t.kanji} ${t.name}`);
+            out.push(padAnsi(` ${marker} ${label}${badge}`, W));
+        }
+        out.push(chalk_1.default.hex(theme_1.PALETTE.inkFaint)(" " + "╌".repeat(W - 2)));
+        const t = (0, theme_1.agentTheme)(this.agentName);
+        for (const ln of wrapPlain(t.poem, W - 2).slice(0, 2)) {
+            out.push(" " + chalk_1.default.hex(theme_1.PALETTE.inkLight).italic(ln));
+        }
+        out.push(" " + chalk_1.default.hex(theme_1.PALETTE.inkLight).dim(t.pigment));
+        if (this.orch.active) {
+            const p = this.orch.progress();
+            out.push("");
+            out.push(" " + chalk_1.default.hex(t.hex)(`織 ${p.done}/${p.total}`) + chalk_1.default.dim(" 梭"));
+        }
+        while (out.length < h)
+            out.push("");
+        return out.slice(0, h);
+    }
+    /** Compose and flush a frame. Returns the composed rows (used by tests). */
+    paint() {
+        if (this.destroyed)
+            return [];
+        const cols = this.cols();
+        const rows = this.rows();
+        const innerW = cols - 2;
+        const t = (0, theme_1.agentTheme)(this.agentName);
+        const frame = [];
+        const faint = chalk_1.default.hex(theme_1.PALETTE.inkFaint);
+        const B = (s) => faint(s);
+        if (cols < 60 || rows < 14) {
+            const small = [chalk_1.default.yellow(" 窗口太小 · 请放大终端 (≥60×14) ")];
+            this.screen.flush(small, null);
+            return small;
+        }
+        // ── header: title + seal ──
+        {
+            const seal = chalk_1.default.bgHex(t.hex).hex(theme_1.PALETTE.paper).bold(` ${t.kanji} `);
+            const title = chalk_1.default.bold(" 天空织机 ") + chalk_1.default.dim("Skyloom ");
+            // ┌─ title ───…─ seal ─┐  →  2 + w(title) + fill + 4 + 2 = cols
+            const fill = innerW - (0, tui_1.visualWidth)(title) - 6;
+            frame.push(B("┌─") + title + B("─".repeat(Math.max(0, fill))) + seal + B("─┐"));
+        }
+        // ── sky band ──
+        {
+            const shuttles = this.orch.active
+                ? this.orch.runningAgents().map((a, i) => {
+                    const th = (0, theme_1.agentTheme)(a);
+                    return { symbol: th.symbol, hex: th.hex, x: (this.orch.shuttleX.get(a) || 0) % innerW, row: i };
+                })
+                : [];
+            const skyRows = this.sky.render(innerW, t.motion, t.symbol, t.hex, this.tick, shuttles);
+            const mountain = mountainRow(innerW, this.turns);
+            frame.push(B("│") + padAnsi(skyRows[0], innerW) + B("│"));
+            // mountain sits behind the lower particle row: particles overlay where present
+            frame.push(B("│") + overlay(mountain, skyRows[1], innerW) + B("│"));
+        }
+        // ── body: rail │ viewport ──
+        const bodyH = this.bodyH();
+        const rail = this.railLines(bodyH);
+        const view = this.viewportLines();
+        this.clampScroll();
+        const start = Math.max(0, view.length - bodyH - this.scrollOff);
+        const visible = view.slice(start, start + bodyH);
+        for (let i = 0; i < bodyH; i++) {
+            const left = padAnsi(rail[i] ?? "", RAIL_W);
+            const right = padAnsi(visible[i] ?? "", this.viewW());
+            frame.push(B("│") + left + B("│") + " " + right + B("│"));
+        }
+        // ── status divider ──
+        {
+            let leftLabel = "";
+            if (this.modal)
+                leftLabel = "";
+            else if (this.busy && this.busyLabel) {
+                const dots = ["·  ", "·· ", "···", " ··", "  ·", "   "][this.tick % 6];
+                leftLabel = ` ${chalk_1.default.hex(t.hex)(t.symbol)} ${chalk_1.default.dim(this.busyLabel + " " + dots)} `;
+            }
+            else if (this.flashHint)
+                leftLabel = " " + chalk_1.default.yellow(this.flashHint) + " ";
+            else if (this.scrollOff > 0)
+                leftLabel = " " + chalk_1.default.dim(`↑ 回看中 · Esc 回到末尾`) + " ";
+            else if (this.modeBadge)
+                leftLabel = " " + this.modeBadge + " ";
+            const right = this.statusRight();
+            const rightLabel = right ? ` ${right} ` : "";
+            const fill = innerW - (0, tui_1.visualWidth)(leftLabel) - (0, tui_1.visualWidth)(rightLabel);
+            frame.push(B("├") + leftLabel + B("─".repeat(Math.max(0, fill))) + rightLabel + B("┤"));
+        }
+        // ── palette overlay (replaces tail viewport rows visually — drawn over input-adjacent rows) ──
+        // (kept simple: palette renders inside the viewport's final rows via paint order below)
+        // ── input row ──
+        let cursorPos = null;
+        {
+            let content;
+            if (this.modal) {
+                content = " " + chalk_1.default.yellow("⚠ ") + cutVisual(this.modal.text, innerW - 14) + chalk_1.default.bold(" 允许? ") + chalk_1.default.dim("[y/N]");
+                cursorPos = { row: rows - 2, col: Math.min(innerW, (0, tui_1.visualWidth)(content) + 1) };
+            }
+            else {
+                const promptStr = chalk_1.default.hex(t.hex)(` ${t.symbol} `) + chalk_1.default.hex(theme_1.PALETTE.inkLight)("❯ ");
+                const promptW = (0, tui_1.visualWidth)(promptStr);
+                const avail = innerW - promptW - 1;
+                // horizontal scroll window around the cursor
+                const glyphs = this.inputGlyphs;
+                let beforeW = 0;
+                for (let i = 0; i < this.cursor; i++)
+                    beforeW += (0, tui_1.charWidth)(glyphs[i].codePointAt(0));
+                let startIdx = 0, skipW = 0;
+                while (beforeW - skipW > avail - 2 && startIdx < glyphs.length) {
+                    skipW += (0, tui_1.charWidth)(glyphs[startIdx].codePointAt(0));
+                    startIdx++;
+                }
+                let shown = "", shownW = 0, cursorCol = promptW + (beforeW - skipW);
+                for (let i = startIdx; i < glyphs.length; i++) {
+                    const cw = (0, tui_1.charWidth)(glyphs[i].codePointAt(0));
+                    if (shownW + cw > avail)
+                        break;
+                    shown += glyphs[i];
+                    shownW += cw;
+                }
+                content = promptStr + shown;
+                cursorPos = { row: rows - 2, col: 1 + cursorCol };
+            }
+            frame.push(B("│") + padAnsi(content, innerW) + B("│"));
+        }
+        // ── bottom border with hints ──
+        {
+            const paletteUp = this.paletteMatches().length > 0 && this.inputGlyphs[0] === "/";
+            const hint = this.busy
+                ? " Ctrl-C 中断本轮 "
+                : paletteUp
+                    ? " ↑↓ 选命令 · Enter 执行 · Tab 补全 · Esc 收起 "
+                    : " / 命令 · PgUp 回看 · Shift+Tab 切模式 · Ctrl-C 退出 ";
+            // └─ hint ───…┘  →  2 + w(hint) + fill + 1 = cols
+            const fill = innerW - (0, tui_1.visualWidth)(hint) - 1;
+            frame.push(B("└─") + chalk_1.default.dim(hint) + B("─".repeat(Math.max(0, fill)) + "┘"));
+        }
+        // ── slash palette: overlay onto the rows just above the divider ──
+        const matches = this.paletteMatches();
+        if (matches.length > 0 && this.inputGlyphs[0] === "/" && !this.modal) {
+            const maxShow = Math.min(8, bodyH - 1);
+            this.paletteIdx = Math.max(0, Math.min(this.paletteIdx, matches.length - 1));
+            // scroll window that keeps the ↑↓ selection visible
+            const start = Math.max(0, Math.min(this.paletteIdx - maxShow + 1, matches.length - maxShow));
+            const show = matches.slice(start, start + maxShow);
+            const baseRow = 1 + SKY_H + bodyH - show.length; // first overlay row index in frame
+            show.forEach(([cmd, desc], i) => {
+                const sel = start + i === this.paletteIdx;
+                const agentCmd = ["/fog", "/rain", "/frost", "/snow", "/dew", "/fair"].includes(cmd.trim());
+                const color = agentCmd ? chalk_1.default.hex((0, theme_1.agentTheme)(cmd.trim().slice(1)).hex) : chalk_1.default.hex(theme_1.PALETTE.inkLight);
+                const mark = sel ? chalk_1.default.hex(t.hex)(" ▸ ") : "   ";
+                const counter = sel && matches.length > maxShow ? chalk_1.default.dim(` ${this.paletteIdx + 1}/${matches.length}`) : "";
+                const lineStr = mark + (sel ? chalk_1.default.bold(color(cmd.padEnd(11))) : color(cmd.padEnd(11))) + chalk_1.default.dim(cutVisual(desc, this.viewW() - 22)) + counter;
+                const row = baseRow + i;
+                frame[row] = B("│") + padAnsi(this.railLines(bodyH)[row - 1 - SKY_H] ?? "", RAIL_W) + B("│") + " " + padAnsi(lineStr, this.viewW()) + B("│");
+            });
+        }
+        this.screen.flush(frame, cursorPos);
+        return frame;
+    }
+}
+exports.LoomUI = LoomUI;
+/** Overlay `top` onto `base` (top's non-space glyphs win), to a fixed width. */
+function overlay(base, top, width) {
+    // Both strings are styled; walk them in parallel by visual column.
+    const cells = (s) => {
+        const out = [];
+        let i = 0;
+        let pending = "";
+        while (i < s.length && out.length < width * 2) {
+            if (s[i] === ESC) {
+                const m = ANSI_RE.exec(s.slice(i));
+                if (m && m.index === 0) {
+                    pending += m[0];
+                    i += m[0].length;
+                    continue;
+                }
+            }
+            const cp = s.codePointAt(i);
+            const ch = String.fromCodePoint(cp);
+            const cw = (0, tui_1.charWidth)(cp);
+            out.push(pending + ch);
+            pending = "";
+            if (cw === 2)
+                out.push(""); // wide glyph occupies two cells
+            i += ch.length;
+        }
+        return out;
+    };
+    const b = cells(base);
+    const t = cells(top);
+    let res = "";
+    for (let x = 0; x < width; x++) {
+        const tc = t[x];
+        const bc = b[x];
+        const topVisible = tc !== undefined && tc.replace(/\x1b\[[0-9;]*m/g, "") !== " " && tc !== "";
+        if (topVisible)
+            res += tc + "\x1b[0m";
+        else if (tc === "")
+            continue; // second cell of a wide top glyph
+        else if (bc !== undefined && bc !== "")
+            res += bc + "\x1b[0m";
+        else if (bc === "")
+            continue;
+        else
+            res += " ";
+    }
+    return padAnsi(res, width);
+}
+//# sourceMappingURL=loom.js.map