mindweave 2.3.1 → 2.4.0

package/dist/cli/livePad.js

@@ -0,0 +1,53 @@
+/**
+ * livePad.ts — keeping the inline shell's prompt at the bottom of the screen.
+ *
+ * ## What goes wrong without it
+ *
+ * The inline shell re-renders only its live region: the tail, the status line, the input,
+ * whatever sits under it. Ink draws that region by erasing the rows it drew last time and
+ * writing the new ones in their place.
+ *
+ * Opening the command palette makes that region a dozen rows taller. There is no room
+ * below it — a working session is always at the bottom of the screen — so the TERMINAL
+ * SCROLLS to make room, and everything above moves up. That part is fine and expected.
+ *
+ * Closing it again is where it breaks. Ink erases the tall region and writes the short
+ * one starting at the top of where the tall one was, so the prompt lands a dozen rows
+ * higher than the bottom of the screen with nothing beneath it. And it cannot simply be
+ * moved back down: the rows that scrolled off went into the terminal's scrollback, and no
+ * escape sequence pulls them back. The scroll is one-way.
+ *
+ * ## What this does instead
+ *
+ * RESERVES the rows the palette will need, from the start, and fills them with blanks
+ * until it needs them. The region is then one constant height whether the palette is open
+ * or closed: the terminal never scrolls for it, so there is never a scroll to compensate
+ * for, and the prompt never moves at all.
+ *
+ * The version before this held the rows back only AFTER the palette had taken them, and
+ * released them on the next committed message. That was wrong in a way that only showed on
+ * the second use: releasing assumed real output refills what the palette borrowed, and one
+ * line of output does not refill five rows — so the pad vanished while the scroll it was
+ * compensating for was still there, and the gap opened under the prompt.
+ */
+/** How tall the live region may be padded to, as a fraction of the visible rows.
+ *
+ *  A ceiling matters because the pad is inserted, not measured: a resize, a terminal that
+ *  reports its size late, or a palette taller than the window could otherwise ask for more
+ *  blank rows than there are rows, and the region would push its own prompt off screen. */
+const MAX_PAD_FRACTION = 0.6;
+/**
+ * Blank rows to insert above the live content (pure).
+ *
+ * @param contentRows  the region's height right now, WITHOUT any pad
+ * @param highWater    the tallest it has been since the last commit
+ * @param viewportRows the terminal's height
+ */
+export function livePad(contentRows, highWater, viewportRows) {
+    if (!Number.isFinite(contentRows) || !Number.isFinite(highWater))
+        return 0;
+    const wanted = Math.max(0, Math.floor(highWater) - Math.floor(contentRows));
+    const ceiling = Math.max(0, Math.floor(viewportRows * MAX_PAD_FRACTION));
+    return Math.min(wanted, ceiling);
+}
+//# sourceMappingURL=livePad.js.map

package/dist/cli/livePad.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"livePad.js","sourceRoot":"","sources":["../../src/cli/livePad.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+BG;AAEH;;;;2FAI2F;AAC3F,MAAM,gBAAgB,GAAG,GAAG,CAAC;AAE7B;;;;;;GAMG;AACH,MAAM,UAAU,OAAO,CAAC,WAAmB,EAAE,SAAiB,EAAE,YAAoB;IAClF,IAAI,CAAC,MAAM,CAAC,QAAQ,CAAC,WAAW,CAAC,IAAI,CAAC,MAAM,CAAC,QAAQ,CAAC,SAAS,CAAC;QAAE,OAAO,CAAC,CAAC;IAC3E,MAAM,MAAM,GAAG,IAAI,CAAC,GAAG,CAAC,CAAC,EAAE,IAAI,CAAC,KAAK,CAAC,SAAS,CAAC,GAAG,IAAI,CAAC,KAAK,CAAC,WAAW,CAAC,CAAC,CAAC;IAC5E,MAAM,OAAO,GAAG,IAAI,CAAC,GAAG,CAAC,CAAC,EAAE,IAAI,CAAC,KAAK,CAAC,YAAY,GAAG,gBAAgB,CAAC,CAAC,CAAC;IACzE,OAAO,IAAI,CAAC,GAAG,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;AACnC,CAAC"}

package/dist/cli/memoryTuning.js

@@ -0,0 +1,31 @@
+/**
+ * memoryTuning.ts — bias V8 toward a smaller footprint.
+ *
+ * A coding agent spends almost all of its time waiting: for a keystroke, for a model, for
+ * a command. It is I/O-bound, not compute-bound, so the CPU that V8's speed-first defaults
+ * buy is spent on nothing here, while the memory those defaults reserve is real and shows
+ * up in every process listing.
+ *
+ * `--optimize-for-size` flips that trade: V8 prefers memory over speed in its garbage
+ * collection and code-generation heuristics from this point on. It is applied at runtime
+ * rather than as a launch flag on purpose — the alternative is re-executing the process
+ * with the flag set, and re-exec on a program that owns a terminal is a real hazard (the
+ * child inherits a raw-mode stdin and an alternate screen mid-handoff). Setting it in
+ * process is the same effect without that risk.
+ *
+ * Gated by an env var so a machine that would rather have the speed can opt out, and so a
+ * measurement can compare the two without editing code.
+ */
+import { setFlagsFromString } from "node:v8";
+/** Apply the footprint bias unless `MINDWEAVE_NO_MEM_TUNING` is set. Best-effort. */
+export function tuneMemory() {
+    if (process.env["MINDWEAVE_NO_MEM_TUNING"])
+        return;
+    try {
+        setFlagsFromString("--optimize-for-size");
+    }
+    catch {
+        // A build of Node that does not accept the flag at runtime; nothing to do.
+    }
+}
+//# sourceMappingURL=memoryTuning.js.map

package/dist/cli/memoryTuning.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"memoryTuning.js","sourceRoot":"","sources":["../../src/cli/memoryTuning.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;GAiBG;AACH,OAAO,EAAE,kBAAkB,EAAE,MAAM,SAAS,CAAC;AAE7C,qFAAqF;AACrF,MAAM,UAAU,UAAU;IACxB,IAAI,OAAO,CAAC,GAAG,CAAC,yBAAyB,CAAC;QAAE,OAAO;IACnD,IAAI,CAAC;QACH,kBAAkB,CAAC,qBAAqB,CAAC,CAAC;IAC5C,CAAC;IAAC,MAAM,CAAC;QACP,2EAA2E;IAC7E,CAAC;AACH,CAAC"}

package/dist/cli/messageQueue.js

@@ -22,15 +22,75 @@
  * the drain batches. Kept deliberately as pure functions
  * over a plain array — the queue is small, always local to one App, and every rule in
  * it is worth a test.
+ *
+ * ## Two drains, because there are two moments
+ *
+ * A fourth thing was missing for longer than the other three: the queue only ever
+ * emptied when the turn was completely over. A message typed twenty seconds into a four
+ * minute task was not read for four minutes, and by then it was a comment on finished
+ * work rather than a correction to work in progress. Waiting is the wrong default for
+ * the only kind of message anyone types while watching an agent run.
+ *
+ * So `takeSteerable` hands what it can to the turn that is ALREADY RUNNING, at its next
+ * step boundary, and `drain` keeps the turn-boundary behaviour for what cannot be handed
+ * over — commands, and anything typed in the gap before the turn ended. The rules for
+ * which is which are on each function.
  */
 /** Rows of queue the footer will show before collapsing the rest into a count. */
 export const MAX_VISIBLE_QUEUED = 3;
-/** Whether this entry runs as a command rather than being said to the model. */
+/** Whether this text runs as a command rather than being said to the model. */
 export function isCommand(text) {
     return text.trimStart().startsWith("/");
 }
 /**
- * What to send next, and what stays queued.
+ * Queue a message, deciding when it may go.
+ *
+ * `interrupting` is true when the user has already pressed Esc and the turn is still
+ * winding down. Without it the message would be steered into the turn they just
+ * stopped — Esc, then a fast correction, and the correction lands in the dying turn as
+ * if the stop had never happened. There is no mode field beyond this: a slash command
+ * is recognised by its own syntax, the same way the send path recognises it, so the
+ * queue cannot disagree with the thing that eventually runs it.
+ */
+export function queueMessage(text, opts = {}) {
+    if (isCommand(text))
+        return { text, priority: "later" };
+    return { text, priority: opts.interrupting ? "now" : "next" };
+}
+/**
+ * What may be delivered INTO a turn that is already running, and what stays queued.
+ *
+ * A message typed while Mindweave is working is almost always about the work in
+ * progress. Held until the turn ends, it arrives after the thing it was about is
+ * finished, which is the wrong moment for every message worth typing — a correction
+ * lands too late to correct anything. So prose is handed to the running turn at its next
+ * step boundary and the model changes course.
+ *
+ * Only `next` is eligible, and only the unbroken run of it at the FRONT.
+ *
+ * A slash command (`later`) is not something to say to the model, it is something to DO,
+ * and doing it needs the turn to be over: `/model` mid-flight would change models
+ * between two calls of one conversation.
+ *
+ * A message typed after Esc (`now`) is not eligible either, and that one is easy to get
+ * wrong. The user stopped the turn; feeding them back into it would carry out their
+ * correction inside the very turn they cancelled.
+ *
+ * Stopping at the FIRST ineligible entry is what keeps the order honest. Someone who
+ * types a message, then `/model`, then another message meant the last one to come after
+ * the switch; steering it would run the three in an order they were never typed in.
+ */
+export function takeSteerable(queue) {
+    let i = 0;
+    while (i < queue.length && queue[i].priority === "next")
+        i++;
+    return { send: queue.slice(0, i), rest: queue.slice(i) };
+}
+/**
+ * What to send next as its OWN turn, and what stays queued.
+ *
+ * The turn-boundary drain. What reaches it is what could not be steered: slash commands,
+ * and anything typed in the gap between the last step boundary and the turn ending.
  *
  * Consecutive plain messages go out TOGETHER, as one turn. Someone who types three
  * sentences while waiting meant them as one thought, and answering the first without
@@ -41,19 +101,28 @@ export function isCommand(text) {
  * A slash command always goes alone. It is not something to say to the model, it is
  * something to DO — merging `/model` into the prose around it would send the literal
  * word to the model instead of switching anything.
+ *
+ * Messages batch only with others of the SAME priority, which in practice means only
+ * `next` with `next`. A message typed after Esc is put to the model differently — it
+ * says the user stopped the work to send it — and merging one into the prose around it
+ * would apply that to text it was not true of.
  */
 export function drain(queue) {
     if (queue.length === 0)
         return undefined;
     const first = queue[0];
-    if (isCommand(first))
-        return { send: first, rest: queue.slice(1) };
+    if (first.priority !== "next")
+        return { send: first.text, priority: first.priority, rest: queue.slice(1) };
     let i = 0;
-    while (i < queue.length && !isCommand(queue[i]))
+    while (i < queue.length && queue[i].priority === "next")
         i++;
     // A blank line between them, not a bare newline: these were separate messages, and
     // run together they read as one rambling paragraph.
-    return { send: queue.slice(0, i).join("\n\n"), rest: queue.slice(i) };
+    return {
+        send: queue.slice(0, i).map((q) => q.text).join("\n\n"),
+        priority: "next",
+        rest: queue.slice(i),
+    };
 }
 /**
  * Pull the whole queue back into the input for editing.
@@ -71,7 +140,7 @@ export function drain(queue) {
 export function popAll(queue, currentInput, currentCursor) {
     if (queue.length === 0)
         return undefined;
-    const queuedText = queue.join("\n");
+    const queuedText = queue.map((q) => q.text).join("\n");
     if (currentInput === "")
         return { text: queuedText, cursor: queuedText.length };
     return {

package/dist/cli/messageQueue.js.map

@@ -1 +1 @@
-{"version":3,"file":"messageQueue.js","sourceRoot":"","sources":["../../src/cli/messageQueue.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AAEH,kFAAkF;AAClF,MAAM,CAAC,MAAM,kBAAkB,GAAG,CAAC,CAAC;AASpC,gFAAgF;AAChF,MAAM,UAAU,SAAS,CAAC,IAAY;IACpC,OAAO,IAAI,CAAC,SAAS,EAAE,CAAC,UAAU,CAAC,GAAG,CAAC,CAAC;AAC1C,CAAC;AAED;;;;;;;;;;;;GAYG;AACH,MAAM,UAAU,KAAK,CAAC,KAAwB;IAC5C,IAAI,KAAK,CAAC,MAAM,KAAK,CAAC;QAAE,OAAO,SAAS,CAAC;IACzC,MAAM,KAAK,GAAG,KAAK,CAAC,CAAC,CAAE,CAAC;IACxB,IAAI,SAAS,CAAC,KAAK,CAAC;QAAE,OAAO,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,CAAC,KAAK,CAAC,CAAC,CAAC,EAAE,CAAC;IAEnE,IAAI,CAAC,GAAG,CAAC,CAAC;IACV,OAAO,CAAC,GAAG,KAAK,CAAC,MAAM,IAAI,CAAC,SAAS,CAAC,KAAK,CAAC,CAAC,CAAE,CAAC;QAAE,CAAC,EAAE,CAAC;IACtD,mFAAmF;IACnF,oDAAoD;IACpD,OAAO,EAAE,IAAI,EAAE,KAAK,CAAC,KAAK,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,IAAI,CAAC,MAAM,CAAC,EAAE,IAAI,EAAE,KAAK,CAAC,KAAK,CAAC,CAAC,CAAC,EAAE,CAAC;AACxE,CAAC;AASD;;;;;;;;;;;;GAYG;AACH,MAAM,UAAU,MAAM,CACpB,KAAwB,EACxB,YAAoB,EACpB,aAAqB;IAErB,IAAI,KAAK,CAAC,MAAM,KAAK,CAAC;QAAE,OAAO,SAAS,CAAC;IACzC,MAAM,UAAU,GAAG,KAAK,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;IACpC,IAAI,YAAY,KAAK,EAAE;QAAE,OAAO,EAAE,IAAI,EAAE,UAAU,EAAE,MAAM,EAAE,UAAU,CAAC,MAAM,EAAE,CAAC;IAChF,OAAO;QACL,IAAI,EAAE,GAAG,UAAU,KAAK,YAAY,EAAE;QACtC,8CAA8C;QAC9C,MAAM,EAAE,UAAU,CAAC,MAAM,GAAG,CAAC,GAAG,aAAa;KAC9C,CAAC;AACJ,CAAC;AAED;;;;;;GAMG;AACH,MAAM,UAAU,YAAY,CAAC,KAAwB;IACnD,OAAO;QACL,IAAI,EAAE,KAAK,CAAC,KAAK,CAAC,CAAC,EAAE,kBAAkB,CAAC;QACxC,MAAM,EAAE,IAAI,CAAC,GAAG,CAAC,CAAC,EAAE,KAAK,CAAC,MAAM,GAAG,kBAAkB,CAAC;KACvD,CAAC;AACJ,CAAC"}
+{"version":3,"file":"messageQueue.js","sourceRoot":"","sources":["../../src/cli/messageQueue.ts"],"names":[],"mappings":"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"}

package/dist/cli/mouse.js

@@ -16,15 +16,23 @@
  * `[<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.
+ * The trade this makes, stated plainly: while reporting is on, the terminal stops
+ * selecting text for us, because it has handed the mouse to the app. That is not a
+ * setting that can be had both ways — a terminal either owns the mouse or the app
+ * does. So the app owns it and does the selecting itself; see selection.ts.
  */
 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";
+/**
+ * Report button presses AND movement while a button is held (1002), using SGR encoding
+ * (1006), the only encoding that stays correct past column 223.
+ *
+ * 1002 rather than 1000 because 1000 reports only the press and the release. A drag is
+ * the movement BETWEEN them, so under 1000 a selection could only ever be told where it
+ * started and where it stopped, and nothing could be highlighted while the button was
+ * still down. 1002 is the narrower of the two motion modes: it stays quiet until a
+ * button is held, where 1003 reports every idle mouse movement across the window.
+ */
+const MOUSE_ON = "\x1b[?1002h\x1b[?1006h";
 /**
  * An SGR mouse report: `ESC [ < button ; col ; row (M|m)`.
  *
@@ -51,6 +59,31 @@ export function readWheel(data) {
     }
     return out;
 }
+/**
+ * Every left-button pointer event in a chunk of terminal input, in order (pure).
+ *
+ * Only the left button, because that is the one that selects. The wheel is read
+ * separately by `readWheel`, and the two never collide: a wheel report sets bit 6, which
+ * is checked for and skipped here.
+ */
+export function readMouse(data) {
+    const out = [];
+    for (const match of data.matchAll(SGR)) {
+        const button = Number(match[1]);
+        if ((button & 64) !== 0)
+            continue; // a wheel notch, not a button
+        // Bits 0-1 name the button. A RELEASE under SGR reports the button that was let go,
+        // so this stays correct for both ends of a drag.
+        if ((button & 3) !== 0)
+            continue; // middle or right button
+        const x = Number(match[2]) - 1;
+        const y = Number(match[3]) - 1;
+        // Bit 5 marks movement; the final `m` (rather than `M`) marks a release.
+        const kind = match[4] === "m" ? "release" : (button & 32) !== 0 ? "drag" : "press";
+        out.push({ kind, x, y });
+    }
+    return out;
+}
 /**
  * The same input with every mouse report removed (pure).
  *

package/dist/cli/mouse.js.map

@@ -1 +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"}
+{"version":3,"file":"mouse.js","sourceRoot":"","sources":["../../src/cli/mouse.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;GAsBG;AAEH,OAAO,EAAE,SAAS,EAAE,MAAM,sBAAsB,CAAC;AAEjD;;;;;;;;;GASG;AACH,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;AAaD;;;;;;GAMG;AACH,MAAM,UAAU,SAAS,CAAC,IAAY;IACpC,MAAM,GAAG,GAAiB,EAAE,CAAC;IAC7B,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,IAAI,CAAC,MAAM,GAAG,EAAE,CAAC,KAAK,CAAC;YAAE,SAAS,CAAC,8BAA8B;QACjE,oFAAoF;QACpF,iDAAiD;QACjD,IAAI,CAAC,MAAM,GAAG,CAAC,CAAC,KAAK,CAAC;YAAE,SAAS,CAAC,yBAAyB;QAC3D,MAAM,CAAC,GAAG,MAAM,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC;QAC/B,MAAM,CAAC,GAAG,MAAM,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC;QAC/B,yEAAyE;QACzE,MAAM,IAAI,GAAc,KAAK,CAAC,CAAC,CAAC,KAAK,GAAG,CAAC,CAAC,CAAC,SAAS,CAAC,CAAC,CAAC,CAAC,MAAM,GAAG,EAAE,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,OAAO,CAAC;QAC9F,GAAG,CAAC,IAAI,CAAC,EAAE,IAAI,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC;IAC3B,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/quietConsole.js

@@ -0,0 +1,50 @@
+/**
+ * quietConsole.ts — nothing but the renderer writes to the screen while the UI is up.
+ *
+ * A full-screen terminal app owns every cell of the terminal, and the framebuffer owns
+ * the record of what is in them. Anything that prints outside that record — a dependency
+ * logging a warning, a stray `console.log`, Node announcing a deprecation — lands on the
+ * screen the renderer believes it already knows, and at the bottom row it SCROLLS: every
+ * row moves up one, and the model now describes a screen that no longer exists.
+ *
+ * What that looks like is a single character stranded in the middle of an unrelated line,
+ * because a scrolled row is only visible where the new content is shorter than the old.
+ * A tool row reading `● Tools(sessions)` picks up the last surviving letter of whatever
+ * used to be above it.
+ *
+ * Ink's own answer, `patchConsole`, is worse rather than better: it routes console output
+ * INTO the frame stream, where the framebuffer parses it as a frame and writes the foreign
+ * text into the model itself. A wrong cell in the model is never revisited, because as far
+ * as a diff can see nothing about it changed, so that one survives every later frame.
+ * Written straight to the terminal it at least heals on the next full repaint.
+ *
+ * So neither: while the UI is mounted the console goes nowhere. Errors reach the user
+ * through the app's own surfaces, which can render them where they belong.
+ */
+/** The methods that print. `assert` and `trace` print too, and both go through `error`. */
+const SILENCED = ["log", "info", "warn", "error", "debug", "trace", "dir", "table", "group", "groupEnd"];
+/**
+ * Silence the console, returning a function that puts it back.
+ *
+ * Restoring matters as much as silencing: `/update` hands the terminal over to an
+ * installer after the UI unmounts, and a crash report is printed after the alternate
+ * screen has been left. Both need a console again.
+ */
+export function silenceConsole(target = console) {
+    const saved = new Map();
+    for (const name of SILENCED) {
+        if (typeof target[name] !== "function")
+            continue;
+        saved.set(name, target[name]);
+        target[name] = () => { };
+    }
+    let restored = false;
+    return () => {
+        if (restored)
+            return;
+        restored = true;
+        for (const [name, fn] of saved)
+            target[name] = fn;
+    };
+}
+//# sourceMappingURL=quietConsole.js.map

package/dist/cli/quietConsole.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"quietConsole.js","sourceRoot":"","sources":["../../src/cli/quietConsole.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;GAsBG;AAEH,2FAA2F;AAC3F,MAAM,QAAQ,GAAG,CAAC,KAAK,EAAE,MAAM,EAAE,MAAM,EAAE,OAAO,EAAE,OAAO,EAAE,OAAO,EAAE,KAAK,EAAE,OAAO,EAAE,OAAO,EAAE,UAAU,CAAU,CAAC;AAIlH;;;;;;GAMG;AACH,MAAM,UAAU,cAAc,CAAC,SAA6C,OAAO;IACjF,MAAM,KAAK,GAAG,IAAI,GAAG,EAAqB,CAAC;IAC3C,KAAK,MAAM,IAAI,IAAI,QAAQ,EAAE,CAAC;QAC5B,IAAI,OAAO,MAAM,CAAC,IAAI,CAAC,KAAK,UAAU;YAAE,SAAS;QACjD,KAAK,CAAC,GAAG,CAAC,IAAI,EAAE,MAAM,CAAC,IAAI,CAAC,CAAC,CAAC;QAC9B,MAAM,CAAC,IAAI,CAAC,GAAG,GAAG,EAAE,GAAE,CAAC,CAAC;IAC1B,CAAC;IACD,IAAI,QAAQ,GAAG,KAAK,CAAC;IACrB,OAAO,GAAG,EAAE;QACV,IAAI,QAAQ;YAAE,OAAO;QACrB,QAAQ,GAAG,IAAI,CAAC;QAChB,KAAK,MAAM,CAAC,IAAI,EAAE,EAAE,CAAC,IAAI,KAAK;YAAE,MAAM,CAAC,IAAI,CAAC,GAAG,EAAE,CAAC;IACpD,CAAC,CAAC;AACJ,CAAC"}

package/dist/cli/screenMode.js

@@ -0,0 +1,118 @@
+/**
+ * screenMode.ts — which shell the app is wearing.
+ *
+ * The same transcript, the same blocks, the same streaming. Two ways of putting them on
+ * a terminal, and they are opposites about one thing: who owns the screen.
+ *
+ * ## fullscreen
+ *
+ * We do. The alternate screen buffer, every cell ours to paint, the input pinned to the
+ * bottom, our own scrolling, our own selection, our own cursor. Nothing leaks into the
+ * user's scrollback. The cost is that every one of those is something we have to be good
+ * at, and the bill grows with the length of the session: a frame costs what is on screen,
+ * and scrolling means rebuilding it.
+ *
+ * ## inline
+ *
+ * The terminal does. Finished blocks are printed ONCE, into the terminal's own
+ * scrollback, and never touched again; only the live tail is re-rendered. Scrolling is
+ * the terminal's scrollbar. Selecting and copying is the terminal's selection. Both are
+ * native, instant, and cost us nothing at all — and a frame costs what is happening now
+ * rather than what has happened all session, so a four-hour conversation renders exactly
+ * as fast as a four-minute one.
+ *
+ * What is given up is everything that needs the screen back: the pinned prompt scrolls
+ * away like a shell prompt, there is no mouse, no click-to-place-caret, no drag-select of
+ * our own, and a row that has been printed is final. It also works in places fullscreen
+ * cannot — over a poor ssh link, inside a multiplexer that eats mouse reporting, in a
+ * terminal with no alternate screen at all.
+ *
+ * Neither is the "real" one. `/screen` switches, and the choice is remembered for the
+ * project, so it is made once rather than at the start of every session.
+ */
+/**
+ * Which shell a session opens in.
+ *
+ * The env var wins, so a single laggy ssh session can be started inline without changing
+ * anything the project keeps. Below it is the saved choice: the shell is a decision about
+ * how you want to work, not about one sitting, and having to make it again at the start
+ * of every session is the same decision being asked repeatedly. Neither present means
+ * fullscreen.
+ */
+export function startupMode(env = process.env["MINDWEAVE_SCREEN"], saved) {
+    const fromEnv = env?.trim().toLowerCase();
+    if (fromEnv === "inline")
+        return "inline";
+    if (fromEnv === "fullscreen")
+        return "fullscreen";
+    return saved ?? "fullscreen";
+}
+/** A stored value read back off disk, which may be anything at all. */
+export function parseSavedMode(raw) {
+    return raw === "inline" || raw === "fullscreen" ? raw : null;
+}
+/**
+ * What `/screen <arg>` names: an explicit mode, or nothing it can act on.
+ *
+ * `full` and `fs` are here because they are what people type, and a command that only
+ * accepts its own formal spelling is a command that fails for the reason least worth
+ * failing for. Anything unrecognised returns undefined so the caller can say what it
+ * accepts rather than silently picking a mode that was not asked for.
+ *
+ * An EMPTY argument is undefined too, not a toggle. Bare `/screen` opens the chooser,
+ * which is the caller's business and happens before this is reached — the two shells
+ * are not equals any more, and swapping between them without showing what each takes
+ * from the terminal is the thing the chooser exists to stop.
+ */
+export function parseScreenArg(arg) {
+    const word = arg?.trim().toLowerCase() ?? "";
+    if (word === "inline" || word === "normal" || word === "plain")
+        return "inline";
+    if (word === "fullscreen" || word === "full" || word === "fs")
+        return "fullscreen";
+    return undefined;
+}
+/** One line naming the mode and what it means, for the transcript after a switch. */
+export function screenNotice(mode) {
+    return mode === "inline"
+        ? "inline — the terminal scrolls and selects, and the prompt scrolls with it"
+        : "fullscreen — the prompt is pinned, and scrolling and selection are the app's";
+}
+/**
+ * The inline shell is BETA, and the label is not a disclaimer for its own sake.
+ *
+ * Keeping the prompt pinned while the terminal scrolls means taking the mouse, and a
+ * terminal hands over the whole mouse or none of it. So while an inline session runs,
+ * the terminal's own wheel, scrollbar and drag-to-select all stop responding — the app
+ * is holding them. Fullscreen makes the same trade, but there it is the point: the app
+ * owns the screen and does the scrolling and selecting itself. Inline is meant to be the
+ * shell that leaves those to the terminal, so here the same trade is a real loss, and
+ * one a chooser deserves to be told about before picking rather than after.
+ */
+export const SCREEN_BETA = "inline";
+/**
+ * Both shells, for the chooser (pure).
+ *
+ * Fullscreen is listed FIRST and that is deliberate: a list is read top down, and the
+ * settled shell belongs above the one still being worked on.
+ *
+ * `current` only marks which is in use. It does not reorder them — a menu whose entries
+ * move depending on where you already are is a menu you have to read every time instead
+ * of learning once.
+ */
+export function screenChoices(current) {
+    const tick = (mode) => (mode === current ? "  ✓" : "");
+    return [
+        {
+            mode: "fullscreen",
+            label: `Fullscreen${tick("fullscreen")}`,
+            description: "the app owns the screen; pinned prompt, its own scrolling and selection",
+        },
+        {
+            mode: "inline",
+            label: `Inline (beta)${tick("inline")}`,
+            description: "prints to scrollback; a work in progress, still has rough edges",
+        },
+    ];
+}
+//# sourceMappingURL=screenMode.js.map

package/dist/cli/screenMode.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"screenMode.js","sourceRoot":"","sources":["../../src/cli/screenMode.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+BG;AAIH;;;;;;;;GAQG;AACH,MAAM,UAAU,WAAW,CAAC,GAAG,GAAG,OAAO,CAAC,GAAG,CAAC,kBAAkB,CAAC,EAAE,KAAyB;IAC1F,MAAM,OAAO,GAAG,GAAG,EAAE,IAAI,EAAE,CAAC,WAAW,EAAE,CAAC;IAC1C,IAAI,OAAO,KAAK,QAAQ;QAAE,OAAO,QAAQ,CAAC;IAC1C,IAAI,OAAO,KAAK,YAAY;QAAE,OAAO,YAAY,CAAC;IAClD,OAAO,KAAK,IAAI,YAAY,CAAC;AAC/B,CAAC;AAED,uEAAuE;AACvE,MAAM,UAAU,cAAc,CAAC,GAAY;IACzC,OAAO,GAAG,KAAK,QAAQ,IAAI,GAAG,KAAK,YAAY,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,IAAI,CAAC;AAC/D,CAAC;AAED;;;;;;;;;;;;GAYG;AACH,MAAM,UAAU,cAAc,CAAC,GAAuB;IACpD,MAAM,IAAI,GAAG,GAAG,EAAE,IAAI,EAAE,CAAC,WAAW,EAAE,IAAI,EAAE,CAAC;IAC7C,IAAI,IAAI,KAAK,QAAQ,IAAI,IAAI,KAAK,QAAQ,IAAI,IAAI,KAAK,OAAO;QAAE,OAAO,QAAQ,CAAC;IAChF,IAAI,IAAI,KAAK,YAAY,IAAI,IAAI,KAAK,MAAM,IAAI,IAAI,KAAK,IAAI;QAAE,OAAO,YAAY,CAAC;IACnF,OAAO,SAAS,CAAC;AACnB,CAAC;AAED,qFAAqF;AACrF,MAAM,UAAU,YAAY,CAAC,IAAgB;IAC3C,OAAO,IAAI,KAAK,QAAQ;QACtB,CAAC,CAAC,2EAA2E;QAC7E,CAAC,CAAC,8EAA8E,CAAC;AACrF,CAAC;AAED;;;;;;;;;;GAUG;AACH,MAAM,CAAC,MAAM,WAAW,GAAe,QAAQ,CAAC;AAShD;;;;;;;;;GASG;AACH,MAAM,UAAU,aAAa,CAAC,OAAmB;IAC/C,MAAM,IAAI,GAAG,CAAC,IAAgB,EAAU,EAAE,CAAC,CAAC,IAAI,KAAK,OAAO,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC;IAC3E,OAAO;QACL;YACE,IAAI,EAAE,YAAY;YAClB,KAAK,EAAE,aAAa,IAAI,CAAC,YAAY,CAAC,EAAE;YACxC,WAAW,EAAE,yEAAyE;SACvF;QACD;YACE,IAAI,EAAE,QAAQ;YACd,KAAK,EAAE,gBAAgB,IAAI,CAAC,QAAQ,CAAC,EAAE;YACvC,WAAW,EAAE,iEAAiE;SAC/E;KACF,CAAC;AACJ,CAAC"}

package/dist/cli/screenShell.js

@@ -0,0 +1,67 @@
+/**
+ * screenShell.ts — putting the terminal into one shell or the other.
+ *
+ * `screenMode.ts` decides WHICH; this does it. Three things move together and the order
+ * they move in is the whole content of this file, because getting it wrong leaves the
+ * terminal in a state that is neither shell: the alternate screen buffer, mouse
+ * reporting, and whether the framebuffer is diffing frames or standing aside.
+ *
+ * ## Going inline, the framebuffer stands down FIRST
+ *
+ * It is the thing between Ink and the terminal. While it is still diffing, every write
+ * is being reinterpreted as a full-screen frame — including the escape that leaves the
+ * alternate screen. Standing it down first means everything after this point reaches the
+ * terminal exactly as Ink wrote it, which is what the inline shell needs and what the
+ * leave sequence itself needs.
+ *
+ * ## Coming back, it goes up LAST
+ *
+ * For the mirror reason. The screen has to be the alternate buffer, and the cursor and
+ * autowrap have to be set, before anything starts diffing against a model of them.
+ * Switching it on also throws that model away (see `setFramebufferEnabled`), because
+ * while it was off the terminal was scrolling on its own and nothing the model remembers
+ * is still true.
+ *
+ * ## Mouse reporting is not optional either way
+ *
+ * On, a terminal sends a report for every movement while a button is held. Nothing reads
+ * them in the inline shell, so they arrive at the input as text: the stray letters and
+ * digits that a mouse press used to leave in the prompt. Off is not a tidy-up, it is
+ * what stops the pointer typing.
+ */
+import { setAltScreen, setCursorVisible } from "./altScreen.js";
+import { setFramebufferEnabled } from "./framebuffer/writer.js";
+import { enableMouse } from "./mouse.js";
+/** Turns mouse reporting off again. Null when it is already off. */
+let mouseOff = null;
+/**
+ * Put the terminal into `mode`. Safe to call with the mode it is already in.
+ *
+ * `enableMouse` is injected so a test can drive the sequence without a terminal; the
+ * default is the real one.
+ */
+export function applyScreenMode(mode, deps = {}) {
+    const alt = deps.setAltScreen ?? setAltScreen;
+    const framebuffer = deps.setFramebufferEnabled ?? setFramebufferEnabled;
+    const mouse = deps.enableMouse ?? enableMouse;
+    const cursor = deps.setCursorVisible ?? setCursorVisible;
+    if (mode === "inline") {
+        framebuffer(false);
+        mouseOff?.();
+        mouseOff = null;
+        alt(false);
+        // Leaving the alternate screen restores the cursor, and the inline shell does not
+        // want it: it draws its own caret in the input, and the real one would sit below
+        // everything as a second one. After the leave, or the restore would undo this.
+        cursor(false);
+        return;
+    }
+    alt(true);
+    mouseOff ??= mouse();
+    framebuffer(true);
+}
+/** Forget any mouse subscription, for a test that runs the sequence more than once. */
+export function resetScreenShell() {
+    mouseOff = null;
+}
+//# sourceMappingURL=screenShell.js.map

package/dist/cli/screenShell.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"screenShell.js","sourceRoot":"","sources":["../../src/cli/screenShell.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8BG;AACH,OAAO,EAAE,YAAY,EAAE,gBAAgB,EAAE,MAAM,gBAAgB,CAAC;AAChE,OAAO,EAAE,qBAAqB,EAAE,MAAM,yBAAyB,CAAC;AAChE,OAAO,EAAE,WAAW,EAAE,MAAM,YAAY,CAAC;AAGzC,oEAAoE;AACpE,IAAI,QAAQ,GAAwB,IAAI,CAAC;AAEzC;;;;;GAKG;AACH,MAAM,UAAU,eAAe,CAC7B,IAAgB,EAChB,OAKI,EAAE;IAEN,MAAM,GAAG,GAAG,IAAI,CAAC,YAAY,IAAI,YAAY,CAAC;IAC9C,MAAM,WAAW,GAAG,IAAI,CAAC,qBAAqB,IAAI,qBAAqB,CAAC;IACxE,MAAM,KAAK,GAAG,IAAI,CAAC,WAAW,IAAI,WAAW,CAAC;IAC9C,MAAM,MAAM,GAAG,IAAI,CAAC,gBAAgB,IAAI,gBAAgB,CAAC;IAEzD,IAAI,IAAI,KAAK,QAAQ,EAAE,CAAC;QACtB,WAAW,CAAC,KAAK,CAAC,CAAC;QACnB,QAAQ,EAAE,EAAE,CAAC;QACb,QAAQ,GAAG,IAAI,CAAC;QAChB,GAAG,CAAC,KAAK,CAAC,CAAC;QACX,kFAAkF;QAClF,iFAAiF;QACjF,+EAA+E;QAC/E,MAAM,CAAC,KAAK,CAAC,CAAC;QACd,OAAO;IACT,CAAC;IAED,GAAG,CAAC,IAAI,CAAC,CAAC;IACV,QAAQ,KAAK,KAAK,EAAE,CAAC;IACrB,WAAW,CAAC,IAAI,CAAC,CAAC;AACpB,CAAC;AAED,uFAAuF;AACvF,MAAM,UAAU,gBAAgB;IAC9B,QAAQ,GAAG,IAAI,CAAC;AAClB,CAAC"}

package/dist/cli/screenStore.js

@@ -0,0 +1,46 @@
+/**
+ * screenStore.ts — remembering which shell a project is worked in.
+ *
+ * Beside the model config, in the project's own directory under `~/.mindweave`, for the
+ * same reason that one lives there: it is a decision about how you work on THIS project,
+ * not a global preference and not something to carry in the repository.
+ *
+ * Its own tiny file rather than a field on the model config, so a write here can never
+ * damage or race the thing that decides which provider answers. Both are best-effort:
+ * failing to remember a preference is worth nothing at all next to failing to start.
+ */
+import { promises as fs } from "node:fs";
+import { join } from "node:path";
+import { projectDir } from "../memory/store.js";
+import { parseSavedMode } from "./screenMode.js";
+function screenPath(projectCwd) {
+    return join(projectDir(projectCwd), "screen.json");
+}
+/**
+ * The shell this project was last left in, or null.
+ *
+ * Null for every reason: never saved, unreadable, corrupt, or holding a word that is not
+ * a mode any more. The caller falls back to the default, which is what someone who has
+ * never chosen would get — the safe direction, because a session that opens in the wrong
+ * shell is fixed by one command, while a session that fails to open is not.
+ */
+export async function loadScreenMode(projectCwd) {
+    try {
+        const raw = await fs.readFile(screenPath(projectCwd), "utf8");
+        return parseSavedMode(JSON.parse(raw).screen);
+    }
+    catch {
+        return null;
+    }
+}
+/** Remember the shell for next time. Best-effort. */
+export async function saveScreenMode(projectCwd, mode) {
+    try {
+        await fs.mkdir(projectDir(projectCwd), { recursive: true });
+        await fs.writeFile(screenPath(projectCwd), JSON.stringify({ screen: mode }, null, 2), "utf8");
+    }
+    catch {
+        /* best-effort */
+    }
+}
+//# sourceMappingURL=screenStore.js.map

package/dist/cli/screenStore.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"screenStore.js","sourceRoot":"","sources":["../../src/cli/screenStore.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AACH,OAAO,EAAE,QAAQ,IAAI,EAAE,EAAE,MAAM,SAAS,CAAC;AACzC,OAAO,EAAE,IAAI,EAAE,MAAM,WAAW,CAAC;AACjC,OAAO,EAAE,UAAU,EAAE,MAAM,oBAAoB,CAAC;AAChD,OAAO,EAAE,cAAc,EAAmB,MAAM,iBAAiB,CAAC;AAElE,SAAS,UAAU,CAAC,UAAkB;IACpC,OAAO,IAAI,CAAC,UAAU,CAAC,UAAU,CAAC,EAAE,aAAa,CAAC,CAAC;AACrD,CAAC;AAED;;;;;;;GAOG;AACH,MAAM,CAAC,KAAK,UAAU,cAAc,CAAC,UAAkB;IACrD,IAAI,CAAC;QACH,MAAM,GAAG,GAAG,MAAM,EAAE,CAAC,QAAQ,CAAC,UAAU,CAAC,UAAU,CAAC,EAAE,MAAM,CAAC,CAAC;QAC9D,OAAO,cAAc,CAAE,IAAI,CAAC,KAAK,CAAC,GAAG,CAA0B,CAAC,MAAM,CAAC,CAAC;IAC1E,CAAC;IAAC,MAAM,CAAC;QACP,OAAO,IAAI,CAAC;IACd,CAAC;AACH,CAAC;AAED,qDAAqD;AACrD,MAAM,CAAC,KAAK,UAAU,cAAc,CAAC,UAAkB,EAAE,IAAgB;IACvE,IAAI,CAAC;QACH,MAAM,EAAE,CAAC,KAAK,CAAC,UAAU,CAAC,UAAU,CAAC,EAAE,EAAE,SAAS,EAAE,IAAI,EAAE,CAAC,CAAC;QAC5D,MAAM,EAAE,CAAC,SAAS,CAAC,UAAU,CAAC,UAAU,CAAC,EAAE,IAAI,CAAC,SAAS,CAAC,EAAE,MAAM,EAAE,IAAI,EAAE,EAAE,IAAI,EAAE,CAAC,CAAC,EAAE,MAAM,CAAC,CAAC;IAChG,CAAC;IAAC,MAAM,CAAC;QACP,iBAAiB;IACnB,CAAC;AACH,CAAC"}