@cruxy/cli 1.11.3 → 1.11.4

package/dist/cli/commands/run.js

@@ -359,15 +359,16 @@ export async function executeRun(promptParts, opts) {
     }) ?? undefined;
     // The TUI sidebar lists the same tree the `--resume` picker reads (P2).
     //
-    // A FRESH SESSION IS NOT IN ITS OWN SIDEBAR UNTIL TURN 1 (#257). This used to
-    // be populated after the log was opened precisely so the running session
-    // listed itself; the meta line is buffered now, so there is nothing on disk
-    // to list until something is said. That is the more honest reading — the
-    // sidebar and the `--resume` picker show the same tree, and a session with no
-    // conversation in it is not one the picker would offer either. The active id
-    // is still passed, so the row marks itself the moment it appears.
+    // A PROBE, NOT A LIST (cli#300). A fresh session is not on disk until its
+    // first turn — the meta line is buffered (#257) — so a list read here could
+    // never contain the session the user is in, and with no later caller the
+    // sidebar stayed exactly as stale as that first read for the whole run. The
+    // renderer re-runs this probe after every turn, off its paint path, so the
+    // running session appears the moment it lands and the tree keeps following
+    // what this and any other cruxy write. The active id marks the row when it
+    // shows; the sidebar and the picker still read the same ten.
     if (renderer instanceof TuiRenderer) {
-        renderer.setSessions(listSessions(primaryRoot, SIDEBAR_SESSIONS), sessionId);
+        renderer.attachSessions(() => listSessions(primaryRoot, SIDEBAR_SESSIONS), sessionId);
     }
     // ONE key reader for the whole TUI session (P5): the input loop and the
     // approval prompt's modal both lease it, so the two can never be live on

package/dist/tui/renderer.js

@@ -219,14 +219,21 @@ export class TuiRenderer {
     /**
      * Saved sessions shown in the sidebar (P2), and which one is running.
      *
-     * Populated only by {@link setSessions}, never at construction. The running
-     * session has to be listed, and its meta line does not exist until the
-     * session log is open — which happens after the renderer is built. A
-     * constructor argument could therefore only ever carry the list from BEFORE
-     * this run, i.e. a sidebar missing the very session the user is in.
+     * Populated by {@link setSessions} or by the probe {@link attachSessions}
+     * installs, never at construction: the list is read from disk, the renderer
+     * is built before the session log exists, and a constructor argument could
+     * only ever carry the tree from BEFORE this run.
+     *
+     * THE LIST IS RE-READ AFTER EVERY TURN (cli#300). It used to be read once at
+     * startup, and since a fresh session's meta line is buffered until its first
+     * turn (#257), that one read could never include the session the user was
+     * in — the row the active id exists to mark. Re-probing on `endTurn`, the
+     * same trigger the git cache and the views use, is what lets it appear.
      */
     sessions = [];
     activeSessionId;
+    /** Re-reads the session tree; installed by {@link attachSessions}. */
+    sessionsProbe;
     constructor(caps, out, opts = {}) {
         this.caps = caps;
         this.out = out;
@@ -573,9 +580,9 @@ export class TuiRenderer {
     }
     // ── app-owned surfaces ────────────────────────────────────────────────────
     /**
-     * Replace the sidebar's session list (P2). Called once the session log is
-     * open, so the running session is itself listed; a live refresh later (P3)
-     * is the same call.
+     * Replace the sidebar's session list (P2) with one the caller already holds.
+     * The primitive {@link attachSessions} and {@link refreshSessions} both land
+     * on; a caller with no probe to install (tests, a static list) uses it alone.
      */
     setSessions(sessions, activeSessionId) {
         if (this.closed)
@@ -584,6 +591,46 @@ export class TuiRenderer {
         this.activeSessionId = activeSessionId;
         this.schedulePaint();
     }
+    /**
+     * Install the probe that reads the session tree, and read it once now
+     * (cli#300). From here on {@link endTurn} re-runs it, so the list follows the
+     * tree as this and other cruxys write to it — and so the running session
+     * shows up the moment its first turn puts it on disk.
+     *
+     * THE PROBE NEVER RUNS ON THE PAINT PATH. It reads one meta line per file
+     * for at most ten files, which is cheap, and cheap is not the discipline:
+     * `viewModel` reads `this.sessions` and nothing else, exactly as it reads
+     * the git cache's last answer rather than running `git status`. A paint
+     * that touched the disk would do so on every streaming frame.
+     */
+    attachSessions(probe, activeSessionId) {
+        if (this.closed)
+            return;
+        this.sessionsProbe = probe;
+        this.activeSessionId = activeSessionId;
+        this.refreshSessions();
+    }
+    /**
+     * Re-read the session tree through the installed probe, off the paint path,
+     * and repaint if it answered. A probe that throws leaves the last list
+     * standing: the sidebar is a status surface, and a transient read error must
+     * never blank it or take the shell down. No probe → nothing to do, and the
+     * list set by {@link setSessions} stays as it was.
+     */
+    refreshSessions() {
+        const probe = this.sessionsProbe;
+        if (probe === undefined || this.closed)
+            return;
+        let sessions;
+        try {
+            sessions = probe();
+        }
+        catch {
+            return;
+        }
+        this.sessions = sessions;
+        this.schedulePaint();
+    }
     /** Set the input line's rendered text (prompt + buffer + caret). */
     setInput(line) {
         if (this.closed)
@@ -865,6 +912,10 @@ export class TuiRenderer {
         this.refreshGit();
         this.refreshLimits();
         this.refreshViews();
+        // AFTER the turn's final paint, like the three above: the frame that
+        // closes the turn is composed from state already in hand, and the tree
+        // read lands in the next scheduled paint rather than delaying this one.
+        this.refreshSessions();
     }
     /**
      * REPAINT the headroom panel once the turn's reading lands (P9) — no longer

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cruxy/cli",
-  "version": "1.11.3",
+  "version": "1.11.4",
   "description": "an agentic coding CLI",
   "type": "module",
   "bin": {