@north-light/crouter 0.3.183 → 0.3.184

package/dist/core/canvas/nav-model.d.ts

@@ -1,13 +1,6 @@
 import { type FlatRow, type FoldState, type SubtreeActivity } from './nav-render.js';
-import type { NodeMeta, SubscriptionRef } from './index.js';
+import type { NodeMeta } from './index.js';
 export { PI_MAX_WIDGET_LINES, VIEWPORT_FALLBACK_ROWS, ESC, RESET, BOLD, DIM, REVERSE, BG_ATTACHED, GREEN, RED, YELLOW, CYAN, GRAY, nodeGlyph, visibleWidth, truncate, fillWidth, fillBar, readTelemetry, fmtTokens, tokensCell, activityCell, cycleBadge, navLabel, shortId, askBadge, liveBelowBadge, isAttached, hasBrokerViewers, fetchAsksMap, graphWidgetBudget, GRAPH_HINT, type Telemetry, type FlatRow, type FoldState, type SubtreeActivity, } from './nav-render.js';
-export declare function beginFrame(): void;
-/** getNode memoized for the current frame (meta.json read + sqlite row). */
-export declare function cNode(id: string): NodeMeta | null;
-/** subscriptionsOf (a node's reports) memoized for the current frame. */
-export declare function cSubscriptions(id: string): SubscriptionRef[];
-/** subscribersOf (a node's managers) memoized for the current frame. */
-export declare function cSubscribers(id: string): SubscriptionRef[];
 /** First manager (by created) — the UP step for the ancestry spine. */
 export declare function managerOf(id: string): string | undefined;
 /** A kind:'human' node is a control-plane ASK (a deck on the human's

package/dist/core/canvas/nav-model.js

@@ -15,74 +15,45 @@ import { activeFaultForDisplay } from './render.js';
 import { readFault } from '../runtime/fault.js';
 import { faultSummary } from './status-glyph.js';
 import { statusRank } from './node-order.js';
-import { beginFrameTelem, nodeGlyph, navLabel, shortId, tokensCell, activityCell, cycleBadge, askBadge, liveBelowBadge, truncate, fillBar, fillWidth, isAttached, BOLD, DIM, RESET, REVERSE, BG_ATTACHED, } from './nav-render.js';
+import { nodeGlyph, navLabel, shortId, tokensCell, activityCell, cycleBadge, askBadge, liveBelowBadge, truncate, fillBar, fillWidth, isAttached, BOLD, DIM, RESET, REVERSE, BG_ATTACHED, } from './nav-render.js';
 // Re-export the pure render/telemetry half so existing nav-model importers
 // (chrome/canvas-panels, overlays/graph, resume) keep resolving these here.
 export { PI_MAX_WIDGET_LINES, VIEWPORT_FALLBACK_ROWS, ESC, RESET, BOLD, DIM, REVERSE, BG_ATTACHED, GREEN, RED, YELLOW, CYAN, GRAY, nodeGlyph, visibleWidth, truncate, fillWidth, fillBar, readTelemetry, fmtTokens, tokensCell, activityCell, cycleBadge, navLabel, shortId, askBadge, liveBelowBadge, isAttached, hasBrokerViewers, fetchAsksMap, graphWidgetBudget, GRAPH_HINT, } from './nav-render.js';
 // ---------------------------------------------------------------------------
-// Per-frame read cache
+// Read primitives — UNCACHED, deliberately
 //
-// One render fans the SAME handful of nodes out 5-10× each: computeSubtreeActivity
-// walks the whole tree (getNode + subscriptions per node), buildGraphModel walks it
-// again (climbRoot, sortedChildIds), then every visible row re-reads getNode +
-// telemetry + subscriptions for its badges. getNode alone is an fs.readFileSync of
-// meta.json plus a sqlite row read, and readTelemetry another readFileSync — so on a
-// modest graph a single 'j' keystroke fanned out to DOZENS of redundant disk reads.
-// That redundancy is the GRAPH view's open/scroll lag.
+// These once memoized into module-global Maps that a `beginFrame()` cleared at
+// the top of each TUI render. That cache is gone. Nothing in this module is
+// frame-scoped any more: the GRAPH overlay reads the canvas through crtrd's
+// remote CanvasSource (clients/attach/overlays/graph.ts) and never imports this
+// file, while the one live consumer left — crtrd's `GET /v1/nodes?under=` via
+// `subtreeIds` — is a daemon that runs for HOURS between restarts.
 //
-// Each render is a synchronous snapshot, so we memoize the read primitives for the
-// duration of one frame and clear at the top of render(): the next keystroke (or the
-// ask-poll / inbox render) re-reads fresh, so a killed node, a new spawn, or a status
-// flip all surface on the very next frame. Nothing here writes, so a stale entry can
-// at worst be one frame old — and render() always reruns immediately after any action.
-// The telemetry cache lives in nav-render (readTelemetry); beginFrame clears it too.
+// A process-lifetime memo there is not "at worst one frame stale", it is
+// permanent: the first `?under=X` request that lands before X has spawned any
+// children pinned `[]` under X and every later request returned it. Correctness
+// on the daemon outranks a render amortization no caller asks for, so each read
+// goes straight to the canvas db. The only frame cache still in play is
+// nav-render's telemetry memo, whose TUI callers clear it themselves via
+// `beginFrameTelem()`.
 // ---------------------------------------------------------------------------
-const frameNodes = new Map();
-const frameSubs = new Map();
-const frameMgrs = new Map();
-export function beginFrame() {
-    frameNodes.clear();
-    frameSubs.clear();
-    frameMgrs.clear();
-    beginFrameTelem();
-}
-/** getNode memoized for the current frame (meta.json read + sqlite row). */
-export function cNode(id) {
-    if (frameNodes.has(id))
-        return frameNodes.get(id) ?? null;
-    const v = getNode(id);
-    frameNodes.set(id, v);
-    return v;
-}
-/** subscriptionsOf (a node's reports) memoized for the current frame. */
-export function cSubscriptions(id) {
-    const hit = frameSubs.get(id);
-    if (hit !== undefined)
-        return hit;
-    let v;
+/** subscriptionsOf (a node's reports); an unreadable row reads as no edges. */
+function subsOf(id) {
     try {
-        v = subscriptionsOf(id);
+        return subscriptionsOf(id);
     }
     catch {
-        v = [];
+        return [];
     }
-    frameSubs.set(id, v);
-    return v;
 }
-/** subscribersOf (a node's managers) memoized for the current frame. */
-export function cSubscribers(id) {
-    const hit = frameMgrs.get(id);
-    if (hit !== undefined)
-        return hit;
-    let v;
+/** subscribersOf (a node's managers); an unreadable row reads as no edges. */
+function mgrsOf(id) {
     try {
-        v = subscribersOf(id);
+        return subscribersOf(id);
     }
     catch {
-        v = [];
+        return [];
     }
-    frameMgrs.set(id, v);
-    return v;
 }
 // ---------------------------------------------------------------------------
 // Attachment — is a human currently WATCHING a node? A separate axis from
@@ -100,7 +71,7 @@ export function cSubscribers(id) {
 // ---------------------------------------------------------------------------
 /** First manager (by created) — the UP step for the ancestry spine. */
 export function managerOf(id) {
-    return cSubscribers(id)[0]?.node_id;
+    return mgrsOf(id)[0]?.node_id;
 }
 /** A kind:'human' node is a control-plane ASK (a deck on the human's
  *  screen), NOT a pi conversation — it has no session, so focusing/reviving it
@@ -110,17 +81,17 @@ export function managerOf(id) {
  *  own. Drop it from every navigable list (the tree, BASE reports, child counts,
  *  subtree expansion) so it can never be selected. */
 export function isHumanAsk(id) {
-    return cNode(id)?.kind === 'human';
+    return getNode(id)?.kind === 'human';
 }
 /** A node's direct children that are navigable conversations — human-ask nodes
  *  dropped. The one place the nav chrome enumerates children. */
 export function convoChildIds(id) {
-    return cSubscriptions(id).map((s) => s.node_id).filter((cid) => !isHumanAsk(cid));
+    return subsOf(id).map((s) => s.node_id).filter((cid) => !isHumanAsk(cid));
 }
 /** Live reports (active|idle) of a node — the DOWN set in BASE. */
 export function liveReports(id) {
     return convoChildIds(id).filter((cid) => {
-        const st = cNode(cid)?.status;
+        const st = getNode(cid)?.status;
         return st === 'active' || st === 'idle';
     });
 }
@@ -175,7 +146,7 @@ export function childBadge(node) {
  *  the tree and when stepping into a subtree (`l`). Array.sort is stable, so
  *  equal-status siblings keep their creation order. */
 export function sortedChildIds(id) {
-    return convoChildIds(id).sort((a, b) => statusRank(cNode(a)?.status) - statusRank(cNode(b)?.status));
+    return convoChildIds(id).sort((a, b) => statusRank(getNode(a)?.status) - statusRank(getNode(b)?.status));
 }
 // ---------------------------------------------------------------------------
 // GRAPH model — flatten the local graph fold-aware. Rebuilt every render (cheap
@@ -189,7 +160,7 @@ export function computeSubtreeActivity(root, self) {
     // Returns the count of active nodes in subtree(id) INCLUDING id, and whether
     // that subtree is worth revealing (holds an active node or self).
     const visit = (id) => {
-        const selfActive = cNode(id)?.status === 'active';
+        const selfActive = getNode(id)?.status === 'active';
         if (seen.has(id))
             return { active: selfActive ? 1 : 0, reveal: selfActive || id === self };
         seen.add(id);
@@ -254,7 +225,7 @@ export function renderGraphRow(r, isCursor, focused, activeBelow, asks) {
         const line = `${r.branch}  ${DIM}↺ ${shortId(r.id)}${RESET}`;
         return wrap(line, false);
     }
-    const node = cNode(r.id);
+    const node = getNode(r.id);
     const dot = nodeGlyph(node);
     const rawName = navLabel(node, r.id);
     const name = r.isSelf ? `${BOLD}${rawName}${RESET}` : rawName;

package/dist/core/canvas/nav-render.d.ts

@@ -50,8 +50,8 @@ export declare function fillWidth(): number;
  *  bar; the visible width is padded out to `width`; the line closes with a real
  *  RESET so the style never bleeds into the editor below. */
 export declare function fillBar(content: string, width: number, open: string): string;
-/** Clear the per-frame telemetry cache. Called from nav-model's beginFrame so
- *  the graph half and the render half share one frame boundary. */
+/** Clear the per-frame telemetry cache. Every render pass calls this first, so
+ *  one keystroke re-reads each node's telemetry exactly once. */
 export declare function beginFrameTelem(): void;
 export interface Telemetry {
     /** Live context-window size (pi's getContextUsage) — the figure pi's own footer

package/dist/core/canvas/nav-render.js

@@ -130,14 +130,16 @@ export function fillBar(content, width, open) {
     return `${open}${reasserted}${' '.repeat(pad)}${RESET}`;
 }
 // ---------------------------------------------------------------------------
-// Per-frame telemetry cache. Cleared at the top of each render pass (nav-model's
-// beginFrame calls beginFrameTelem) so token/activity cells read fresh once per
-// frame instead of once per row. Nothing here writes, so a stale entry can at
-// worst be one frame old.
+// Per-frame telemetry cache. Its callers are TUI render passes ONLY (the GRAPH
+// overlay and the canvas panels), each of which calls beginFrameTelem() at the
+// top of the pass, so token/activity cells read fresh once per frame instead of
+// once per row and a stale entry can at worst be one frame old. Never memoize a
+// canvas read for a caller that is not a render pass: crtrd lives for hours, and
+// a memo it never clears is permanent, not per-frame.
 // ---------------------------------------------------------------------------
 const frameTelem = new Map();
-/** Clear the per-frame telemetry cache. Called from nav-model's beginFrame so
- *  the graph half and the render half share one frame boundary. */
+/** Clear the per-frame telemetry cache. Every render pass calls this first, so
+ *  one keystroke re-reads each node's telemetry exactly once. */
 export function beginFrameTelem() {
     frameTelem.clear();
 }

package/dist/daemon/__tests__/subtree-filter-freshness.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/daemon/__tests__/subtree-filter-freshness.test.js

@@ -0,0 +1,63 @@
+// Regression: crtrd served a PERMANENTLY stale `GET /v1/nodes?under=<id>`.
+//
+// `handleList`'s subtree scope came from nav-model's `subtreeIds`, whose reads
+// memoized into module-global Maps that only a `beginFrame()` cleared — and
+// `beginFrame()` had no call sites anywhere. In a TUI that re-renders, a memo is
+// one frame stale; in crtrd, which lives for hours, it is forever. The first
+// `?under=X` request that arrived BEFORE X had spawned children pinned `[]`
+// under X, and every later request returned that `[]` — Northlight's onboarding
+// progress bar sat at 0/100 for the life of the daemon while the unfiltered list
+// showed all 23 children with correct parents.
+//
+// This drives the real route handler against a real canvas db in exactly that
+// order: list the subtree while it is genuinely empty, THEN spawn children, then
+// list again. Nothing here would have failed with a hand-checked subtree walk —
+// only the request-order sequence catches it.
+import { test, before, after, beforeEach } from 'node:test';
+import assert from 'node:assert/strict';
+import { mkdtempSync, rmSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import { createNode, subscribe } from '../../core/canvas/canvas.js';
+import { closeDb } from '../../core/canvas/db.js';
+import { nodeRoutes } from '../api/handlers/nodes.js';
+let home;
+function node(id, parent) {
+    return {
+        node_id: id, name: id, created: new Date().toISOString(), cwd: '/tmp/work',
+        kind: 'general', mode: 'base', lifecycle: 'terminal', status: 'active',
+        ...(parent !== undefined ? { parent } : {}),
+    };
+}
+/** GET /v1/nodes?under=<id> through the registered route, as crtrd serves it. */
+async function listUnder(id) {
+    const route = nodeRoutes.find((r) => r.method === 'GET' && r.pattern === '/v1/nodes');
+    const ctx = {
+        method: 'GET', path: '/v1/nodes', params: {},
+        query: new URLSearchParams({ under: id }), body: undefined,
+    };
+    const res = (await route.handler(ctx));
+    assert.equal(res.status, 200);
+    return res.body.map((r) => r.node_id);
+}
+before(() => { home = mkdtempSync(join(tmpdir(), 'crtr-subtree-')); process.env['CRTR_HOME'] = home; });
+beforeEach(() => { closeDb(); rmSync(home, { recursive: true, force: true }); });
+after(() => { closeDb(); rmSync(home, { recursive: true, force: true }); delete process.env['CRTR_HOME']; });
+test('a subtree query answered before any child exists does not poison later queries on the same daemon process', async () => {
+    const coordinator = 'coordinator';
+    createNode(node(coordinator));
+    // The poisoning request: the gateway polls within a second of the coordinator
+    // being created, before it has spawned anything.
+    assert.deepEqual(await listUnder(coordinator), [], 'an empty subtree is genuinely empty');
+    // The coordinator now spawns its children (parent subscribes_to child).
+    createNode(node('research-gmail', coordinator));
+    createNode(node('research-misc', coordinator));
+    subscribe(coordinator, 'research-gmail');
+    subscribe(coordinator, 'research-misc');
+    assert.deepEqual((await listUnder(coordinator)).sort(), ['research-gmail', 'research-misc'], 'the same long-lived process must see children spawned after its first subtree query');
+    // A grandchild spawned later still surfaces — the walk is re-read at every
+    // level, not just the root's direct edges.
+    createNode(node('writer-connectivity', 'research-gmail'));
+    subscribe('research-gmail', 'writer-connectivity');
+    assert.deepEqual((await listUnder(coordinator)).sort(), ['research-gmail', 'research-misc', 'writer-connectivity'], 'a grandchild spawned after an earlier query surfaces too');
+});

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@north-light/crouter",
-  "version": "0.3.183",
+  "version": "0.3.184",
   "description": "crtr — agent runtime with memory, plugins, and marketplaces",
   "type": "module",
   "main": "dist/index.js",

package/runtime.lock.json

@@ -1,12 +1,12 @@
 {
   "name": "@north-light/crouter",
-  "version": "0.3.183",
+  "version": "0.3.184",
   "lockfileVersion": 3,
   "requires": true,
   "packages": {
     "": {
       "name": "@north-light/crouter",
-      "version": "0.3.183",
+      "version": "0.3.184",
       "hasInstallScript": true,
       "license": "MIT",
       "dependencies": {