mindweave 0.0.1 → 2.1.2

package/dist/cli/modes.js

@@ -0,0 +1,90 @@
+/**
+ * modes.ts — the interaction modes shown under the chat, cycled with shift-tab.
+ *
+ * A mode is how much rein Mindweave has this turn. It's a CLIENT concept: the engine
+ * never sees "Architect" or a name — it only sees the behavioral flags a mode
+ * implies (today just `readOnly`, tomorrow Sentinel's confirm-before-acting), set
+ * onto the ToolContext when the mode changes. That keeps the layering clean: the
+ * UI owns the labels/icons/colors, the engine owns the behavior.
+ *
+ * Pure and tiny on purpose (unit-tested): the cycle skips modes that aren't
+ * enabled yet, so a not-yet-built mode (Sentinel) can sit in the list as a clean
+ * seam without ever landing in the rotation.
+ */
+/**
+ * The modes, in cycle order. Lightning (auto-accept, today's behavior) is the
+ * default and first stop; Architect (read-only planning) is the second; Sentinel
+ * (ask before each mutating action) is the third.
+ */
+export const MODES = [
+    {
+        id: "lightning",
+        name: "Lightning",
+        icon: "↯",
+        color: "yellow",
+        descriptor: "auto-accept",
+        readOnly: false,
+        guarded: false,
+        enabled: true,
+    },
+    {
+        id: "architect",
+        name: "Architect",
+        icon: "△",
+        color: "magenta",
+        descriptor: "read-only · plan",
+        readOnly: true,
+        guarded: false,
+        enabled: true,
+    },
+    {
+        id: "sentinel",
+        name: "Sentinel",
+        icon: "❖",
+        color: "cyan",
+        descriptor: "ask before acting",
+        readOnly: false,
+        guarded: true,
+        enabled: true,
+    },
+];
+/** The mode a fresh session starts in. Architect is deliberately never sticky —
+ *  you should never open a session and silently be unable to edit. */
+export const DEFAULT_MODE = "lightning";
+/** Look up a mode by id (falls back to the default — an unknown id can't wedge). */
+export function modeById(id) {
+    return MODES.find((m) => m.id === id) ?? modeById(DEFAULT_MODE);
+}
+/**
+ * Which mode a set of behaviour flags amounts to (pure).
+ *
+ * The reverse of what `applyMode` does, and it exists because the flags can now move
+ * without the user pressing anything: approving a plan lifts `planMode` mid-turn and
+ * the engine restores it when the turn ends. The indicator has to be able to name
+ * whatever state it finds rather than only what it last set.
+ *
+ * Reading flags rather than being told a name is what keeps modes a client concept —
+ * nothing below this file knows the word "Architect". `planMode` wins over `guarded`
+ * because a read-only turn cannot act, so there is nothing left to confirm.
+ */
+export function modeFromFlags(flags) {
+    if (flags.planMode)
+        return "architect";
+    if (flags.guarded)
+        return "sentinel";
+    return "lightning";
+}
+/**
+ * The next mode when the user presses shift-tab: the following ENABLED mode in
+ * list order, wrapping around. Disabled modes (Sentinel, for now) are skipped, so
+ * the rotation is only over what actually exists.
+ */
+export function nextMode(current) {
+    const rotation = MODES.filter((m) => m.enabled);
+    const at = rotation.findIndex((m) => m.id === current);
+    // If the current mode isn't in the rotation (e.g. a disabled mode was forced),
+    // start the cycle from the first enabled mode.
+    const next = rotation[(at + 1) % rotation.length] ?? rotation[0];
+    return next.id;
+}
+//# sourceMappingURL=modes.js.map

package/dist/cli/modes.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"modes.js","sourceRoot":"","sources":["../../src/cli/modes.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AA+BH;;;;GAIG;AACH,MAAM,CAAC,MAAM,KAAK,GAAoB;IACpC;QACE,EAAE,EAAE,WAAW;QACf,IAAI,EAAE,WAAW;QACjB,IAAI,EAAE,GAAG;QACT,KAAK,EAAE,QAAQ;QACf,UAAU,EAAE,aAAa;QACzB,QAAQ,EAAE,KAAK;QACf,OAAO,EAAE,KAAK;QACd,OAAO,EAAE,IAAI;KACd;IACD;QACE,EAAE,EAAE,WAAW;QACf,IAAI,EAAE,WAAW;QACjB,IAAI,EAAE,GAAG;QACT,KAAK,EAAE,SAAS;QAChB,UAAU,EAAE,kBAAkB;QAC9B,QAAQ,EAAE,IAAI;QACd,OAAO,EAAE,KAAK;QACd,OAAO,EAAE,IAAI;KACd;IACD;QACE,EAAE,EAAE,UAAU;QACd,IAAI,EAAE,UAAU;QAChB,IAAI,EAAE,GAAG;QACT,KAAK,EAAE,MAAM;QACb,UAAU,EAAE,mBAAmB;QAC/B,QAAQ,EAAE,KAAK;QACf,OAAO,EAAE,IAAI;QACb,OAAO,EAAE,IAAI;KACd;CACF,CAAC;AAEF;sEACsE;AACtE,MAAM,CAAC,MAAM,YAAY,GAAW,WAAW,CAAC;AAEhD,oFAAoF;AACpF,MAAM,UAAU,QAAQ,CAAC,EAAU;IACjC,OAAO,KAAK,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,EAAE,KAAK,EAAE,CAAC,IAAI,QAAQ,CAAC,YAAY,CAAC,CAAC;AAClE,CAAC;AAED;;;;;;;;;;;GAWG;AACH,MAAM,UAAU,aAAa,CAAC,KAAgD;IAC5E,IAAI,KAAK,CAAC,QAAQ;QAAE,OAAO,WAAW,CAAC;IACvC,IAAI,KAAK,CAAC,OAAO;QAAE,OAAO,UAAU,CAAC;IACrC,OAAO,WAAW,CAAC;AACrB,CAAC;AAED;;;;GAIG;AACH,MAAM,UAAU,QAAQ,CAAC,OAAe;IACtC,MAAM,QAAQ,GAAG,KAAK,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,OAAO,CAAC,CAAC;IAChD,MAAM,EAAE,GAAG,QAAQ,CAAC,SAAS,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,EAAE,KAAK,OAAO,CAAC,CAAC;IACvD,+EAA+E;IAC/E,+CAA+C;IAC/C,MAAM,IAAI,GAAG,QAAQ,CAAC,CAAC,EAAE,GAAG,CAAC,CAAC,GAAG,QAAQ,CAAC,MAAM,CAAC,IAAI,QAAQ,CAAC,CAAC,CAAE,CAAC;IAClE,OAAO,IAAI,CAAC,EAAE,CAAC;AACjB,CAAC"}

package/dist/cli/mouse.js

@@ -0,0 +1,78 @@
+/**
+ * mouse.ts — wheel scrolling in the alternate screen.
+ *
+ * The alternate screen has no scrollback of its own, so the terminal's own wheel
+ * does nothing: the rows on screen are all there is, and reaching for the wheel
+ * to look back at what scrolled away simply does not respond. Keyboard paging is
+ * not a substitute either — on Windows consoles those keys are frequently
+ * consumed by the console host before the app ever sees them.
+ *
+ * So the app asks the terminal to report wheel events, and scrolls itself.
+ *
+ * The catch, and it is the whole reason `stripMouse` exists: once reporting is
+ * on, those reports arrive as ordinary stdin bytes. They reach the wheel reader
+ * AND Ink's key parser, which has no notion of a mouse report and passes the
+ * bytes along as though they had been typed — so every scroll dumped
+ * `[<64;25;26M` into the prompt. Anything reading typed input must strip them
+ * first.
+ *
+ * The trade this makes, stated plainly: while wheel reporting is on, dragging to
+ * select text is captured by the app instead of the terminal. Every terminal
+ * worth using keeps selection available on Shift+drag, the same deal vim, htop,
+ * and every other full-screen tool strikes.
+ */
+import { MOUSE_OFF } from "./terminalRestore.js";
+/** Report wheel/button presses (1000) using SGR encoding (1006), the only
+ *  encoding that stays correct past column 223. */
+const MOUSE_ON = "\x1b[?1000h\x1b[?1006h";
+/**
+ * An SGR mouse report: `ESC [ < button ; col ; row (M|m)`.
+ *
+ * The ESC is optional because the same bytes reach us two ways: raw off stdin
+ * with the ESC intact, and again through Ink's key parser, which strips it. Both
+ * spellings have to match or the stripped one lands in the input box.
+ */
+const SGR = /\x1b?\[<(\d+);(\d+);(\d+)([Mm])/g;
+/**
+ * Every wheel event in a chunk of terminal input, in order (pure).
+ *
+ * A single flick can deliver several reports in one chunk, and each is a notch
+ * the user turned — dropping the extras makes scrolling feel like it is ignoring
+ * you, so they are all returned rather than collapsed.
+ */
+export function readWheel(data) {
+    const out = [];
+    for (const match of data.matchAll(SGR)) {
+        const button = Number(match[1]);
+        // Bit 6 (64) marks a wheel event; bit 0 then separates up (0) from down (1).
+        if ((button & 64) === 0)
+            continue;
+        out.push((button & 1) === 0 ? "up" : "down");
+    }
+    return out;
+}
+/**
+ * The same input with every mouse report removed (pure).
+ *
+ * Used by anything that treats stdin as typed text. Also drops a trailing
+ * fragment of a report — a chunk boundary can split one, and half a report is
+ * still not something the user typed.
+ */
+export function stripMouse(data) {
+    return data.replace(SGR, "").replace(/\x1b?\[<[\d;]*$/, "");
+}
+/** Turn wheel reporting on, returning a function that turns it back off.
+ *  A no-op off a TTY, matching how altScreen.ts gates itself. */
+export function enableMouse() {
+    if (!process.stdout.isTTY)
+        return () => { };
+    process.stdout.write(MOUSE_ON);
+    let done = false;
+    return () => {
+        if (done)
+            return;
+        done = true;
+        process.stdout.write(MOUSE_OFF);
+    };
+}
+//# sourceMappingURL=mouse.js.map

package/dist/cli/mouse.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"mouse.js","sourceRoot":"","sources":["../../src/cli/mouse.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;GAsBG;AAEH,OAAO,EAAE,SAAS,EAAE,MAAM,sBAAsB,CAAC;AAEjD;mDACmD;AACnD,MAAM,QAAQ,GAAG,wBAAwB,CAAC;AAE1C;;;;;;GAMG;AACH,MAAM,GAAG,GAAG,kCAAkC,CAAC;AAI/C;;;;;;GAMG;AACH,MAAM,UAAU,SAAS,CAAC,IAAY;IACpC,MAAM,GAAG,GAAqB,EAAE,CAAC;IACjC,KAAK,MAAM,KAAK,IAAI,IAAI,CAAC,QAAQ,CAAC,GAAG,CAAC,EAAE,CAAC;QACvC,MAAM,MAAM,GAAG,MAAM,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC;QAChC,6EAA6E;QAC7E,IAAI,CAAC,MAAM,GAAG,EAAE,CAAC,KAAK,CAAC;YAAE,SAAS;QAClC,GAAG,CAAC,IAAI,CAAC,CAAC,MAAM,GAAG,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,MAAM,CAAC,CAAC;IAC/C,CAAC;IACD,OAAO,GAAG,CAAC;AACb,CAAC;AAED;;;;;;GAMG;AACH,MAAM,UAAU,UAAU,CAAC,IAAY;IACrC,OAAO,IAAI,CAAC,OAAO,CAAC,GAAG,EAAE,EAAE,CAAC,CAAC,OAAO,CAAC,iBAAiB,EAAE,EAAE,CAAC,CAAC;AAC9D,CAAC;AAED;iEACiE;AACjE,MAAM,UAAU,WAAW;IACzB,IAAI,CAAC,OAAO,CAAC,MAAM,CAAC,KAAK;QAAE,OAAO,GAAG,EAAE,GAAE,CAAC,CAAC;IAC3C,OAAO,CAAC,MAAM,CAAC,KAAK,CAAC,QAAQ,CAAC,CAAC;IAC/B,IAAI,IAAI,GAAG,KAAK,CAAC;IACjB,OAAO,GAAG,EAAE;QACV,IAAI,IAAI;YAAE,OAAO;QACjB,IAAI,GAAG,IAAI,CAAC;QACZ,OAAO,CAAC,MAAM,CAAC,KAAK,CAAC,SAAS,CAAC,CAAC;IAClC,CAAC,CAAC;AACJ,CAAC"}

package/dist/cli/pasteAssembler.js

@@ -0,0 +1,44 @@
+/**
+ * pasteAssembler.ts — reassembles a bracketed paste that the terminal delivers as
+ * several input chunks.
+ *
+ * When bracketed paste is enabled (`\x1b[?2004h`), a paste is wrapped in `\x1b[200~`
+ * … `\x1b[201~` markers. A large paste still arrives split across several `input`
+ * events (~1KB each), with the start marker on the first chunk and the end marker on
+ * the last — so we must track state across chunks and accumulate until the end.
+ *
+ * Ink's `parseKeypress` mangles the markers: it strips a leading ESC from a
+ * start-of-chunk sequence, so `\x1b[200~` reaches us as `[200~`, while a mid-chunk
+ * `\x1b[201~` keeps its ESC. We therefore match both markers ESC-optionally.
+ *
+ * This module is pure and synchronous so the state machine can be unit-tested without
+ * mounting the terminal UI. The timing-based fallback for terminals that lack
+ * bracketed paste stays in the component (it needs real timers).
+ */
+// Match the paste markers whether or not Ink left the leading ESC on.
+export const PASTE_START_RE = /\x1b?\[200~/;
+export const PASTE_END_RE = /\x1b?\[201~/;
+export function initPasteState() {
+    return { active: false, buf: "" };
+}
+/**
+ * Feed one raw input chunk. Returns what the caller should do. On `flush` the caller
+ * inserts `text` (as a chip if large); the state should be reset afterward.
+ */
+export function feedPasteChunk(state, input) {
+    const starting = PASTE_START_RE.test(input);
+    if (!state.active && !starting) {
+        return { kind: "passthrough" };
+    }
+    // Strip a start marker (only present on the first chunk) and detect the end marker.
+    let text = input.replace(PASTE_START_RE, "");
+    const ending = PASTE_END_RE.test(text);
+    text = text.replace(PASTE_END_RE, "");
+    const buf = state.buf + text;
+    if (ending) {
+        // A split end marker can leave a stray trailing ESC; drop it.
+        return { kind: "flush", text: buf.replace(/\x1b$/, "") };
+    }
+    return { kind: "buffering", state: { active: true, buf } };
+}
+//# sourceMappingURL=pasteAssembler.js.map

package/dist/cli/pasteAssembler.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"pasteAssembler.js","sourceRoot":"","sources":["../../src/cli/pasteAssembler.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;GAgBG;AAEH,sEAAsE;AACtE,MAAM,CAAC,MAAM,cAAc,GAAG,aAAa,CAAC;AAC5C,MAAM,CAAC,MAAM,YAAY,GAAG,aAAa,CAAC;AAiB1C,MAAM,UAAU,cAAc;IAC5B,OAAO,EAAE,MAAM,EAAE,KAAK,EAAE,GAAG,EAAE,EAAE,EAAE,CAAC;AACpC,CAAC;AAED;;;GAGG;AACH,MAAM,UAAU,cAAc,CAAC,KAAiB,EAAE,KAAa;IAC7D,MAAM,QAAQ,GAAG,cAAc,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;IAC5C,IAAI,CAAC,KAAK,CAAC,MAAM,IAAI,CAAC,QAAQ,EAAE,CAAC;QAC/B,OAAO,EAAE,IAAI,EAAE,aAAa,EAAE,CAAC;IACjC,CAAC;IACD,oFAAoF;IACpF,IAAI,IAAI,GAAG,KAAK,CAAC,OAAO,CAAC,cAAc,EAAE,EAAE,CAAC,CAAC;IAC7C,MAAM,MAAM,GAAG,YAAY,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;IACvC,IAAI,GAAG,IAAI,CAAC,OAAO,CAAC,YAAY,EAAE,EAAE,CAAC,CAAC;IACtC,MAAM,GAAG,GAAG,KAAK,CAAC,GAAG,GAAG,IAAI,CAAC;IAC7B,IAAI,MAAM,EAAE,CAAC;QACX,8DAA8D;QAC9D,OAAO,EAAE,IAAI,EAAE,OAAO,EAAE,IAAI,EAAE,GAAG,CAAC,OAAO,CAAC,OAAO,EAAE,EAAE,CAAC,EAAE,CAAC;IAC3D,CAAC;IACD,OAAO,EAAE,IAAI,EAAE,WAAW,EAAE,KAAK,EAAE,EAAE,MAAM,EAAE,IAAI,EAAE,GAAG,EAAE,EAAE,CAAC;AAC7D,CAAC"}

package/dist/cli/pathComplete.js

@@ -0,0 +1,39 @@
+/**
+ * pathComplete.ts — file completion for the `@mention` picker.
+ *
+ * Given what's been typed after `@` (e.g. `src/co`), list matching files and
+ * folders under the project root, shell-style: split off the directory part,
+ * match the trailing fragment against that directory's entries, return full
+ * relative paths (folders keep a trailing `/` so you can keep drilling in).
+ * Scoped to the primary root — dragging a file still handles any other path.
+ */
+import { promises as fs } from "node:fs";
+import { resolve } from "node:path";
+import { DEFAULT_IGNORES } from "../tools/walk.js";
+const MAX_RESULTS = 12;
+export async function completePath(cwd, prefix) {
+    const norm = prefix.split("\\").join("/");
+    const slash = norm.lastIndexOf("/");
+    const dirPart = slash >= 0 ? norm.slice(0, slash) : "";
+    const fragment = (slash >= 0 ? norm.slice(slash + 1) : norm).toLowerCase();
+    let entries;
+    try {
+        entries = await fs.readdir(resolve(cwd, dirPart), { withFileTypes: true });
+    }
+    catch {
+        return [];
+    }
+    return entries
+        .filter((e) => e.name.toLowerCase().startsWith(fragment))
+        .filter((e) => !(e.isDirectory() && DEFAULT_IGNORES.has(e.name)))
+        // Hide dotfiles unless the user is explicitly typing a dot.
+        .filter((e) => !e.name.startsWith(".") || fragment.startsWith("."))
+        .sort((a, b) => {
+        const ad = a.isDirectory() ? 0 : 1;
+        const bd = b.isDirectory() ? 0 : 1;
+        return ad !== bd ? ad - bd : a.name.localeCompare(b.name);
+    })
+        .slice(0, MAX_RESULTS)
+        .map((e) => (dirPart ? `${dirPart}/` : "") + e.name + (e.isDirectory() ? "/" : ""));
+}
+//# sourceMappingURL=pathComplete.js.map

package/dist/cli/pathComplete.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"pathComplete.js","sourceRoot":"","sources":["../../src/cli/pathComplete.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AACH,OAAO,EAAE,QAAQ,IAAI,EAAE,EAAE,MAAM,SAAS,CAAC;AACzC,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AACpC,OAAO,EAAE,eAAe,EAAE,MAAM,kBAAkB,CAAC;AAEnD,MAAM,WAAW,GAAG,EAAE,CAAC;AAEvB,MAAM,CAAC,KAAK,UAAU,YAAY,CAAC,GAAW,EAAE,MAAc;IAC5D,MAAM,IAAI,GAAG,MAAM,CAAC,KAAK,CAAC,IAAI,CAAC,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC;IAC1C,MAAM,KAAK,GAAG,IAAI,CAAC,WAAW,CAAC,GAAG,CAAC,CAAC;IACpC,MAAM,OAAO,GAAG,KAAK,IAAI,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC,EAAE,KAAK,CAAC,CAAC,CAAC,CAAC,EAAE,CAAC;IACvD,MAAM,QAAQ,GAAG,CAAC,KAAK,IAAI,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC,KAAK,CAAC,KAAK,GAAG,CAAC,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,WAAW,EAAE,CAAC;IAE3E,IAAI,OAAO,CAAC;IACZ,IAAI,CAAC;QACH,OAAO,GAAG,MAAM,EAAE,CAAC,OAAO,CAAC,OAAO,CAAC,GAAG,EAAE,OAAO,CAAC,EAAE,EAAE,aAAa,EAAE,IAAI,EAAE,CAAC,CAAC;IAC7E,CAAC;IAAC,MAAM,CAAC;QACP,OAAO,EAAE,CAAC;IACZ,CAAC;IAED,OAAO,OAAO;SACX,MAAM,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,IAAI,CAAC,WAAW,EAAE,CAAC,UAAU,CAAC,QAAQ,CAAC,CAAC;SACxD,MAAM,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,CAAC,CAAC,WAAW,EAAE,IAAI,eAAe,CAAC,GAAG,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC;QACjE,4DAA4D;SAC3D,MAAM,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC,UAAU,CAAC,GAAG,CAAC,IAAI,QAAQ,CAAC,UAAU,CAAC,GAAG,CAAC,CAAC;SAClE,IAAI,CAAC,CAAC,CAAC,EAAE,CAAC,EAAE,EAAE;QACb,MAAM,EAAE,GAAG,CAAC,CAAC,WAAW,EAAE,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;QACnC,MAAM,EAAE,GAAG,CAAC,CAAC,WAAW,EAAE,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;QACnC,OAAO,EAAE,KAAK,EAAE,CAAC,CAAC,CAAC,EAAE,GAAG,EAAE,CAAC,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC,aAAa,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC;IAC5D,CAAC,CAAC;SACD,KAAK,CAAC,CAAC,EAAE,WAAW,CAAC;SACrB,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,OAAO,CAAC,CAAC,CAAC,GAAG,OAAO,GAAG,CAAC,CAAC,CAAC,EAAE,CAAC,GAAG,CAAC,CAAC,IAAI,GAAG,CAAC,CAAC,CAAC,WAAW,EAAE,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC;AACxF,CAAC"}

package/dist/cli/perfLog.js

@@ -0,0 +1,90 @@
+/**
+ * perfLog.ts — frame timings from the REAL terminal, on the user's machine.
+ *
+ * Every performance number this UI has been tuned against so far came from a probe
+ * writing to a fake stdout, where the terminal write costs exactly zero and Yoga runs
+ * on a machine that is not the one complaining. That is how a fix got shipped twice
+ * that measured beautifully and felt no different: the probe could not see the part
+ * that was slow.
+ *
+ * So this writes what actually happened, to a file, from the running app:
+ *
+ *   - how long the terminal took to accept each write, and how big it was
+ *   - how many blocks exist versus how many were handed to the renderer, which is the
+ *     one fact that says whether virtualization is engaging at all
+ *   - the gap between frames, which is what the user actually perceives as lag
+ *
+ * Off unless `MINDWEAVE_PERF` is set, and when off it costs one boolean read per frame
+ * and touches nothing else. It must never write to stdout: this is an alt-screen TUI,
+ * and a stray line would corrupt the frame it is trying to measure.
+ */
+import { appendFileSync, mkdirSync } from "node:fs";
+import { dirname } from "node:path";
+const PATH = process.env.MINDWEAVE_PERF ?? "";
+const ON = PATH !== "" && PATH !== "0";
+/** Whether frame instrumentation is on. */
+export function perfEnabled() {
+    return ON;
+}
+let buffer = [];
+let flushTimer = null;
+/**
+ * Record one line. Buffered and flushed on a timer rather than written immediately —
+ * a synchronous file write per frame would itself become the slowest thing in the
+ * frame, and an instrument that changes what it measures is worse than none.
+ */
+export function perf(line) {
+    if (!ON)
+        return;
+    buffer.push(`${Date.now()} ${line}`);
+    if (flushTimer)
+        return;
+    flushTimer = setTimeout(flush, 1000);
+    flushTimer.unref?.();
+}
+/** Write everything buffered so far. Safe to call when there is nothing to write. */
+export function flush() {
+    if (flushTimer) {
+        clearTimeout(flushTimer);
+        flushTimer = null;
+    }
+    if (!ON || buffer.length === 0)
+        return;
+    const lines = buffer;
+    buffer = [];
+    try {
+        mkdirSync(dirname(PATH), { recursive: true });
+        appendFileSync(PATH, `${lines.join("\n")}\n`, "utf8");
+    }
+    catch {
+        // An instrument must never take the app down with it.
+    }
+}
+/**
+ * Wrap `stdout.write` so every frame the renderer emits is timed and sized.
+ *
+ * This is the measurement that no probe could make. Ink erases and rewrites the drawn
+ * region on every state change, and how long the terminal takes to accept that is a
+ * property of the terminal — conhost, Windows Terminal, VS Code's, WSL — not of the
+ * code. If this number is large, no amount of layout work will fix the lag and the
+ * answer is to write less, less often.
+ */
+export function instrumentStdout(stream) {
+    if (!ON)
+        return;
+    const original = stream.write.bind(stream);
+    let n = 0;
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    stream.write = (chunk, ...rest) => {
+        const t0 = performance.now();
+        const result = original(chunk, ...rest);
+        const ms = performance.now() - t0;
+        const size = typeof chunk === "string" ? chunk.length : (chunk?.length ?? 0);
+        // Only the frames worth looking at. A TUI emits many tiny cursor moves and
+        // logging every one buries the writes that actually cost something.
+        if (size > 200 || ms > 1)
+            perf(`write bytes=${size} ms=${ms.toFixed(2)} n=${++n}`);
+        return result;
+    };
+}
+//# sourceMappingURL=perfLog.js.map

package/dist/cli/perfLog.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"perfLog.js","sourceRoot":"","sources":["../../src/cli/perfLog.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;GAmBG;AACH,OAAO,EAAE,cAAc,EAAE,SAAS,EAAE,MAAM,SAAS,CAAC;AACpD,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AAEpC,MAAM,IAAI,GAAG,OAAO,CAAC,GAAG,CAAC,cAAc,IAAI,EAAE,CAAC;AAC9C,MAAM,EAAE,GAAG,IAAI,KAAK,EAAE,IAAI,IAAI,KAAK,GAAG,CAAC;AAEvC,2CAA2C;AAC3C,MAAM,UAAU,WAAW;IACzB,OAAO,EAAE,CAAC;AACZ,CAAC;AAED,IAAI,MAAM,GAAa,EAAE,CAAC;AAC1B,IAAI,UAAU,GAA0B,IAAI,CAAC;AAE7C;;;;GAIG;AACH,MAAM,UAAU,IAAI,CAAC,IAAY;IAC/B,IAAI,CAAC,EAAE;QAAE,OAAO;IAChB,MAAM,CAAC,IAAI,CAAC,GAAG,IAAI,CAAC,GAAG,EAAE,IAAI,IAAI,EAAE,CAAC,CAAC;IACrC,IAAI,UAAU;QAAE,OAAO;IACvB,UAAU,GAAG,UAAU,CAAC,KAAK,EAAE,IAAI,CAAC,CAAC;IACrC,UAAU,CAAC,KAAK,EAAE,EAAE,CAAC;AACvB,CAAC;AAED,qFAAqF;AACrF,MAAM,UAAU,KAAK;IACnB,IAAI,UAAU,EAAE,CAAC;QACf,YAAY,CAAC,UAAU,CAAC,CAAC;QACzB,UAAU,GAAG,IAAI,CAAC;IACpB,CAAC;IACD,IAAI,CAAC,EAAE,IAAI,MAAM,CAAC,MAAM,KAAK,CAAC;QAAE,OAAO;IACvC,MAAM,KAAK,GAAG,MAAM,CAAC;IACrB,MAAM,GAAG,EAAE,CAAC;IACZ,IAAI,CAAC;QACH,SAAS,CAAC,OAAO,CAAC,IAAI,CAAC,EAAE,EAAE,SAAS,EAAE,IAAI,EAAE,CAAC,CAAC;QAC9C,cAAc,CAAC,IAAI,EAAE,GAAG,KAAK,CAAC,IAAI,CAAC,IAAI,CAAC,IAAI,EAAE,MAAM,CAAC,CAAC;IACxD,CAAC;IAAC,MAAM,CAAC;QACP,sDAAsD;IACxD,CAAC;AACH,CAAC;AAED;;;;;;;;GAQG;AACH,MAAM,UAAU,gBAAgB,CAAC,MAA0B;IACzD,IAAI,CAAC,EAAE;QAAE,OAAO;IAChB,MAAM,QAAQ,GAAG,MAAM,CAAC,KAAK,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC;IAC3C,IAAI,CAAC,GAAG,CAAC,CAAC;IACV,8DAA8D;IAC7D,MAAc,CAAC,KAAK,GAAG,CAAC,KAAU,EAAE,GAAG,IAAW,EAAE,EAAE;QACrD,MAAM,EAAE,GAAG,WAAW,CAAC,GAAG,EAAE,CAAC;QAC7B,MAAM,MAAM,GAAG,QAAQ,CAAC,KAAK,EAAE,GAAG,IAAI,CAAC,CAAC;QACxC,MAAM,EAAE,GAAG,WAAW,CAAC,GAAG,EAAE,GAAG,EAAE,CAAC;QAClC,MAAM,IAAI,GAAG,OAAO,KAAK,KAAK,QAAQ,CAAC,CAAC,CAAC,KAAK,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,KAAK,EAAE,MAAM,IAAI,CAAC,CAAC,CAAC;QAC7E,2EAA2E;QAC3E,oEAAoE;QACpE,IAAI,IAAI,GAAG,GAAG,IAAI,EAAE,GAAG,CAAC;YAAE,IAAI,CAAC,eAAe,IAAI,OAAO,EAAE,CAAC,OAAO,CAAC,CAAC,CAAC,MAAM,EAAE,CAAC,EAAE,CAAC,CAAC;QACnF,OAAO,MAAM,CAAC;IAChB,CAAC,CAAC;AACJ,CAAC"}

package/dist/cli/reveal.js

@@ -0,0 +1,32 @@
+/**
+ * reveal.ts — the pure decision for HOW to reveal a tool row.
+ *
+ * The old behavior revealed a tool the instant it started (a bare `● Run(cmd)`
+ * header) and only expanded its output — the `⎿` block — later, when the result
+ * landed. That reads as a two-step "header, then pop": jarring, and worse in a
+ * burst where every header shows first and every body expands at once.
+ *
+ * Instead we prefer to reveal a row ALREADY RESOLVED (header + output together, in
+ * one step). A just-started tool is held for a short grace window: if it finishes
+ * within it, the row appears complete; only a genuinely slower tool (still running
+ * after the grace) falls back to a running header so it never looks frozen. This
+ * function is the whole policy — pure, so it can be unit-tested away from timers.
+ */
+/** How long to hold a just-started tool before showing a running header, giving a
+ *  fast tool the chance to finish so its row can appear already-resolved. Tunable. */
+export const TOOL_GRACE_MS = 350;
+/**
+ * Decide how to reveal a tool row.
+ *  - result already available → "resolved" (the row appears complete at once).
+ *  - flushing (Esc: drain with no pacing) and not resolved → "running" now.
+ *  - still within the grace window → "hold" (come back once it resolves or grace ends).
+ *  - grace elapsed and still running → "running" (a running header, expands later).
+ */
+export function planToolReveal(endAvailable, heldMs, graceMs, flush) {
+    if (endAvailable)
+        return "resolved";
+    if (flush)
+        return "running";
+    return heldMs >= graceMs ? "running" : "hold";
+}
+//# sourceMappingURL=reveal.js.map

package/dist/cli/reveal.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"reveal.js","sourceRoot":"","sources":["../../src/cli/reveal.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AAEH;sFACsF;AACtF,MAAM,CAAC,MAAM,aAAa,GAAG,GAAG,CAAC;AAOjC;;;;;;GAMG;AACH,MAAM,UAAU,cAAc,CAC5B,YAAqB,EACrB,MAAc,EACd,OAAe,EACf,KAAc;IAEd,IAAI,YAAY;QAAE,OAAO,UAAU,CAAC;IACpC,IAAI,KAAK;QAAE,OAAO,SAAS,CAAC;IAC5B,OAAO,MAAM,IAAI,OAAO,CAAC,CAAC,CAAC,SAAS,CAAC,CAAC,CAAC,MAAM,CAAC;AAChD,CAAC"}

package/dist/cli/revealPace.js

@@ -0,0 +1,59 @@
+/**
+ * revealPace.ts — the tempo the transcript reveals at.
+ *
+ * A turn's events arrive in bursts, and this once held every block that appeared to a
+ * three-second beat so a burst of tool calls did not land at once. The reasoning was
+ * about perceived effort: a wait that shows work happening reads as deliberate rather
+ * than slow.
+ *
+ * IT DOES NOT. Used in anger it reads as an animation — words arriving with motion,
+ * the chat still moving after the work is done — which is the opposite of the
+ * impression it was aiming for. That was always the one thing here no test could
+ * settle, and the file said so: change it and re-run. It has now been run.
+ *
+ * The terminal agents that feel fastest pace nothing at all: no reveal delay, no
+ * typewriter, no gap between a block arriving and being painted. A tool that is quick
+ * should look quick.
+ *
+ * The mechanism is kept because it still SERIALISES: blocks reveal in order, one pump
+ * at a time, and Esc still flushes. Only the wait is gone.
+ */
+/**
+ * The beat, in milliseconds. Zero: content appears when it arrives.
+ *
+ * Left as a named constant rather than deleted along with the arithmetic, because the
+ * question it answers is a real one and a future change here should be a number, not a
+ * re-derivation. Anything above zero is visible as animation — that is measured by use,
+ * not by a test.
+ */
+export const REVEAL_GAP_MS = 0;
+/**
+ * How long to hold before revealing the next block.
+ *
+ * Time already spent counts toward the beat, so a model that took four seconds
+ * between two tool calls pays nothing here — the rhythm was already right.
+ */
+export function revealWait({ now, lastRevealAt, flush }) {
+    if (flush)
+        return 0;
+    return Math.max(0, REVEAL_GAP_MS - (now - lastRevealAt));
+}
+/**
+ * Whether unsealed narration is waiting, and would actually become a visible block.
+ *
+ * Streamed text accumulates silently and renders nothing until it seals (whole-block
+ * reveal, see transcript.ts), and `toolStart` seals it as part of its own action. So
+ * a sentence and the tool row it introduces reach the terminal in the SAME paint,
+ * landing together as one clump — the thing the beat exists to prevent, happening in
+ * the one place the pacer could not see.
+ *
+ * Sealing it on its own beat first lets the sentence land alone and be read before
+ * the row arrives under it. That is worth a beat only when a block will actually
+ * appear, which is why `narrated` is checked here: the narration budget is one line
+ * per TURN, so a second sentence seals to nothing (sealAssistant's `suppressed`) and
+ * pausing for it would buy an empty three seconds.
+ */
+export function narrationPending(s) {
+    return s.openAsstId !== null && !s.narrated && s.raw.trim().length > 0;
+}
+//# sourceMappingURL=revealPace.js.map

package/dist/cli/revealPace.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"revealPace.js","sourceRoot":"","sources":["../../src/cli/revealPace.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;GAmBG;AAEH;;;;;;;GAOG;AACH,MAAM,CAAC,MAAM,aAAa,GAAG,CAAC,CAAC;AAW/B;;;;;GAKG;AACH,MAAM,UAAU,UAAU,CAAC,EAAE,GAAG,EAAE,YAAY,EAAE,KAAK,EAAa;IAChE,IAAI,KAAK;QAAE,OAAO,CAAC,CAAC;IACpB,OAAO,IAAI,CAAC,GAAG,CAAC,CAAC,EAAE,aAAa,GAAG,CAAC,GAAG,GAAG,YAAY,CAAC,CAAC,CAAC;AAC3D,CAAC;AAED;;;;;;;;;;;;;;GAcG;AACH,MAAM,UAAU,gBAAgB,CAAC,CAAgE;IAC/F,OAAO,CAAC,CAAC,UAAU,KAAK,IAAI,IAAI,CAAC,CAAC,CAAC,QAAQ,IAAI,CAAC,CAAC,GAAG,CAAC,IAAI,EAAE,CAAC,MAAM,GAAG,CAAC,CAAC;AACzE,CAAC"}

package/dist/cli/sessionCarry.js

@@ -0,0 +1,19 @@
+/**
+ * Move the parts of `from` that belong to the folder rather than to the conversation
+ * onto `to`, in place.
+ *
+ * Deliberately NOT carried, each for its own reason:
+ *   - `reads` / working set — the new conversation has told the model nothing, so a
+ *     ledger claiming files are already in context would make it skip reading them.
+ *   - `backgroundShells` — they belong to the old context and nothing in the new one
+ *     could reach or stop them; the caller kills them and says how many.
+ *   - `todos` — a task list for work the model can no longer see.
+ *   - `mcp` / `chassisByRoot` — real child processes, already disposed and rebuilt.
+ */
+export function carryAcrossFreshSession(from, to) {
+    // The instance itself, not a copy: it holds file bytes keyed by path, and a
+    // half-copied undo stack is worse than none.
+    if (from.checkpoints)
+        to.checkpoints = from.checkpoints;
+}
+//# sourceMappingURL=sessionCarry.js.map

package/dist/cli/sessionCarry.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"sessionCarry.js","sourceRoot":"","sources":["../../src/cli/sessionCarry.ts"],"names":[],"mappings":"AAoBA;;;;;;;;;;;GAWG;AACH,MAAM,UAAU,uBAAuB,CAAC,IAAiB,EAAE,EAAe;IACxE,4EAA4E;IAC5E,6CAA6C;IAC7C,IAAI,IAAI,CAAC,WAAW;QAAE,EAAE,CAAC,WAAW,GAAG,IAAI,CAAC,WAAW,CAAC;AAC1D,CAAC"}

package/dist/cli/smoothScroll.js

@@ -0,0 +1,74 @@
+/**
+ * smoothScroll.ts — the scroll travels to where it was sent, instead of teleporting.
+ *
+ * A wheel notch used to move the transcript three lines in a single frame. Mechanically
+ * correct, and it reads as a jerk: the eye has nothing to track between the two
+ * positions, so a flick of the wheel becomes a stack of discrete jumps rather than
+ * movement. Gemini CLI's ScrollableList solves it the same way this does, with the same
+ * numbers — an ease-in-out cubic run over ~200ms at ~30fps, driving the same `scrollTo`
+ * the instant version called.
+ *
+ * This module is only the arithmetic, deliberately: no timers, no state, no React. The
+ * caller owns the clock and asks "where should the scroll be at this instant", which is
+ * what makes the easing testable without rendering anything or waiting for real time.
+ *
+ * NOTE ON WHY THIS IS NOT A REGRESSION OF THE FROZEN SCROLL MECHANISM. It does not
+ * change where the scroll ends up, ever — `target` is exactly the value the old code
+ * assigned directly, and the animation always terminates on it (`progress >= 1` returns
+ * `to` itself, not an interpolation that might land a fraction short). All it changes is
+ * the values passed through on the way there.
+ */
+/** Total travel time for one scroll, in milliseconds. */
+export const SCROLL_ANIM_MS = 200;
+/** Interval between animation frames, in milliseconds — about 30fps. Matching Ink's
+ *  own ~32ms render throttle: asking for frames faster than the renderer will draw
+ *  them buys nothing and costs a timer wakeup each time. */
+export const SCROLL_FRAME_MS = 33;
+/**
+ * Ease-in-out cubic.
+ *
+ * Slow at both ends and quickest through the middle, which is what makes the movement
+ * read as one gesture rather than a start and a stop. Linear interpolation was tried
+ * first and is visibly worse: it begins and ends abruptly, so it looks like a jump with
+ * extra steps.
+ */
+export function ease(t) {
+    const p = Math.min(1, Math.max(0, t));
+    return p < 0.5 ? 4 * p * p * p : 1 - Math.pow(-2 * p + 2, 3) / 2;
+}
+/**
+ * Where the scroll should be at `now`, in lines.
+ *
+ * Returns a whole number of lines because the transcript can only be offset by whole
+ * rows — a fractional offset would be rounded by the renderer anyway, and rounding here
+ * means the caller can compare against the current value and skip a render when the
+ * frame would be identical.
+ */
+export function scrollAt(anim, now) {
+    const elapsed = now - anim.startedAt;
+    // Land exactly on the target rather than on an interpolation of it. Guarantees the
+    // animation cannot finish a line short of where it was sent, which over a few flicks
+    // would drift the view somewhere the user never scrolled to.
+    if (elapsed >= SCROLL_ANIM_MS)
+        return anim.to;
+    if (elapsed <= 0)
+        return anim.from;
+    return Math.round(anim.from + (anim.to - anim.from) * ease(elapsed / SCROLL_ANIM_MS));
+}
+/** Whether the animation has reached its target and the timer can stop. */
+export function scrollDone(anim, now) {
+    return now - anim.startedAt >= SCROLL_ANIM_MS;
+}
+/**
+ * Start (or redirect) an animation towards `to`.
+ *
+ * A wheel flick sends several notches in quick succession, and each one must extend the
+ * gesture rather than restart it: the new animation begins from where the previous one
+ * had actually reached, so the movement stays continuous instead of snapping back to an
+ * older position and re-running. This is the whole reason `current` is a parameter
+ * rather than being read from the previous animation's `from`.
+ */
+export function retarget(current, to, now) {
+    return { from: current, to, startedAt: now };
+}
+//# sourceMappingURL=smoothScroll.js.map

package/dist/cli/smoothScroll.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"smoothScroll.js","sourceRoot":"","sources":["../../src/cli/smoothScroll.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;GAmBG;AAEH,yDAAyD;AACzD,MAAM,CAAC,MAAM,cAAc,GAAG,GAAG,CAAC;AAElC;;4DAE4D;AAC5D,MAAM,CAAC,MAAM,eAAe,GAAG,EAAE,CAAC;AAElC;;;;;;;GAOG;AACH,MAAM,UAAU,IAAI,CAAC,CAAS;IAC5B,MAAM,CAAC,GAAG,IAAI,CAAC,GAAG,CAAC,CAAC,EAAE,IAAI,CAAC,GAAG,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC;IACtC,OAAO,CAAC,GAAG,GAAG,CAAC,CAAC,CAAC,CAAC,GAAG,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,CAAC,GAAG,IAAI,CAAC,GAAG,CAAC,CAAC,CAAC,GAAG,CAAC,GAAG,CAAC,EAAE,CAAC,CAAC,GAAG,CAAC,CAAC;AACnE,CAAC;AAUD;;;;;;;GAOG;AACH,MAAM,UAAU,QAAQ,CAAC,IAAgB,EAAE,GAAW;IACpD,MAAM,OAAO,GAAG,GAAG,GAAG,IAAI,CAAC,SAAS,CAAC;IACrC,mFAAmF;IACnF,qFAAqF;IACrF,6DAA6D;IAC7D,IAAI,OAAO,IAAI,cAAc;QAAE,OAAO,IAAI,CAAC,EAAE,CAAC;IAC9C,IAAI,OAAO,IAAI,CAAC;QAAE,OAAO,IAAI,CAAC,IAAI,CAAC;IACnC,OAAO,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,IAAI,GAAG,CAAC,IAAI,CAAC,EAAE,GAAG,IAAI,CAAC,IAAI,CAAC,GAAG,IAAI,CAAC,OAAO,GAAG,cAAc,CAAC,CAAC,CAAC;AACxF,CAAC;AAED,2EAA2E;AAC3E,MAAM,UAAU,UAAU,CAAC,IAAgB,EAAE,GAAW;IACtD,OAAO,GAAG,GAAG,IAAI,CAAC,SAAS,IAAI,cAAc,CAAC;AAChD,CAAC;AAED;;;;;;;;GAQG;AACH,MAAM,UAAU,QAAQ,CAAC,OAAe,EAAE,EAAU,EAAE,GAAW;IAC/D,OAAO,EAAE,IAAI,EAAE,OAAO,EAAE,EAAE,EAAE,SAAS,EAAE,GAAG,EAAE,CAAC;AAC/C,CAAC"}