@north-light/crouter 0.3.173 → 0.3.175

package/dist/core/canvas/browse/__tests__/rebuild-coalescer.test.js

@@ -1,134 +0,0 @@
-// rebuild-coalescer.test.ts — proves `createCoalescedRebuilder` (`../rebuild-coalescer.ts`)
-// collapses a burst of triggers into ONE rebuild call, and single-flights a
-// trigger that lands while a rebuild is already in flight into exactly one
-// trailing rebuild rather than a second overlapping one. This is the fix for
-// the N+1-per-event amplification `canvas browse`'s remote SSE path used to
-// have (see app.ts) — WITHOUT the coalescer (i.e. calling `rebuild()` directly
-// on every trigger), these assertions fail: a burst of 5 triggers would count
-// 5 rebuild calls, not 1.
-import { test } from 'node:test';
-import assert from 'node:assert/strict';
-import { createCoalescedRebuilder } from '../rebuild-coalescer.js';
-import { wireEventStreamRebuild } from '../app.js';
-function deferred() {
-    let resolve;
-    const promise = new Promise((r) => { resolve = r; });
-    return { promise, resolve };
-}
-test('a burst of triggers within the debounce window collapses into ONE rebuild call', async () => {
-    let calls = 0;
-    const rebuilder = createCoalescedRebuilder(async () => { calls += 1; }, 30);
-    // Five triggers fired synchronously, well inside the debounce window.
-    for (let i = 0; i < 5; i++)
-        rebuilder.trigger();
-    await new Promise((r) => setTimeout(r, 100));
-    assert.equal(calls, 1, 'a burst of 5 triggers must produce exactly 1 rebuild, not 5');
-});
-test('a trigger landing while a rebuild is in flight coalesces into exactly one trailing rebuild', async () => {
-    let calls = 0;
-    const gate = deferred();
-    const rebuilder = createCoalescedRebuilder(async () => {
-        calls += 1;
-        if (calls === 1)
-            await gate.promise; // hold the first rebuild "in flight"
-    }, 10);
-    rebuilder.trigger();
-    await new Promise((r) => setTimeout(r, 30)); // let the debounce fire and the first rebuild start
-    assert.equal(calls, 1, 'the first rebuild should now be in flight');
-    // A burst of events lands WHILE the rebuild is running — must coalesce into
-    // exactly one trailing rebuild, never one overlapping rebuild per event.
-    rebuilder.trigger();
-    rebuilder.trigger();
-    rebuilder.trigger();
-    await new Promise((r) => setTimeout(r, 30));
-    assert.equal(calls, 1, 'events during an in-flight rebuild must not start an overlapping rebuild yet');
-    gate.resolve(); // let the first rebuild finish
-    await new Promise((r) => setTimeout(r, 30));
-    assert.equal(calls, 2, 'exactly one trailing rebuild must run after the in-flight one finished — not 3');
-});
-test('stop() cancels a pending debounce timer so no rebuild fires', async () => {
-    let calls = 0;
-    const rebuilder = createCoalescedRebuilder(async () => { calls += 1; }, 20);
-    rebuilder.trigger();
-    rebuilder.stop();
-    await new Promise((r) => setTimeout(r, 60));
-    assert.equal(calls, 0, 'stop() must cancel the debounced rebuild before it fires');
-});
-// Integration-shaped proof: drive the coalescer with a rebuild function that
-// actually hits a remote-canvas-shaped mock server (the same shelling contract
-// RemoteCanvasSource uses), and count SERVER request rounds — not just JS call
-// counts — across a burst of SSE-style triggers.
-test('a burst of SSE-style triggers produces ONE round of remote requests, not N', async () => {
-    const { createServer } = await import('node:http');
-    const { RemoteCanvasSource } = await import('../../remote-canvas-source.js');
-    let hits = 0;
-    const server = createServer((req, res) => {
-        const chunks = [];
-        req.on('data', (c) => chunks.push(c));
-        req.on('end', () => {
-            hits += 1;
-            res.writeHead(200, { 'content-type': 'application/json' });
-            res.end(JSON.stringify({ ok: true, exitCode: 0, stdout: JSON.stringify({ nodes: [] }), stderr: '' }));
-        });
-    });
-    // The server MUST close in a `finally` — a listening TCP server keeps its
-    // process's event loop non-empty forever. Under `node --test`, every test
-    // file is its own child process; if an assertion in this test throws before
-    // the old inline `server.close()` at the end of the function ran, the
-    // server (and the process) never exited, wedging one `--test-concurrency`
-    // slot permanently and hanging the whole suite (see the CI-hang postmortem).
-    try {
-        await new Promise((r) => server.listen(0, '127.0.0.1', r));
-        const addr = server.address();
-        const port = typeof addr === 'object' && addr !== null ? addr.port : 0;
-        const source = new RemoteCanvasSource(`http://127.0.0.1:${port}`, 'tok');
-        const rebuilder = createCoalescedRebuilder(async () => {
-            source.invalidate();
-            await source.listNodes(); // one round of remote requests, mirroring app.ts's rebuildSnapshot
-        }, 20);
-        for (let i = 0; i < 6; i++)
-            rebuilder.trigger();
-        // Poll for the request to land instead of sleeping a fixed duration —
-        // deterministic under CI's variable CPU load, and doesn't slow down the
-        // common case (returns as soon as the debounce + request round trip land).
-        const deadline = Date.now() + 2000;
-        while (hits < 1 && Date.now() < deadline) {
-            await new Promise((r) => setTimeout(r, 10));
-        }
-        assert.equal(hits, 1, 'a burst of 6 SSE events must produce ONE round of remote requests, not 6');
-    }
-    finally {
-        server.closeAllConnections();
-        await new Promise((r) => server.close(() => r()));
-    }
-});
-// Integration proof for browse/app.ts's ACTUAL wiring — not the coalescer
-// helper in isolation. Every test above instantiates `createCoalescedRebuilder`
-// directly, which would stay green even if `app.ts` invoked a per-event
-// rebuild without ever calling the coalescer. This test instead drives
-// `wireEventStreamRebuild`, the exported function `runBrowse` calls to set up
-// its SSE handler, with a fake event stream shaped like the real
-// `RemoteEventStream` (subscribe/start only, no network) — if
-// `wireEventStreamRebuild` is ever changed to call `rebuild` directly per
-// event instead of routing through the coalescer, this test goes red.
-test('wireEventStreamRebuild (the exported app.ts SSE handler) routes a burst of events through the coalescer, not one rebuild per event', async () => {
-    let calls = 0;
-    const listeners = new Set();
-    const fakeEventStream = {
-        subscribe: (fn) => {
-            listeners.add(fn);
-            return () => listeners.delete(fn);
-        },
-        start: () => { },
-    };
-    const { unsubscribe } = wireEventStreamRebuild(fakeEventStream, async () => { calls += 1; });
-    // A burst of 6 simulated SSE events, well inside the coalescer's debounce
-    // window (default 200ms) — must collapse into ONE rebuild round.
-    for (let i = 0; i < 6; i++) {
-        for (const fn of listeners)
-            fn('nodes');
-    }
-    await new Promise((r) => setTimeout(r, 260));
-    assert.equal(calls, 1, 'a burst of 6 events through the app.ts wiring must produce exactly 1 rebuild, not 6 — if this fails, app.ts stopped routing SSE events through the coalescer');
-    unsubscribe();
-});

package/dist/core/canvas/browse/__tests__/render.test.d.ts

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

package/dist/core/canvas/browse/__tests__/render.test.js

@@ -1,111 +0,0 @@
-import { test } from 'node:test';
-import assert from 'node:assert/strict';
-import { buildTree, flatten } from '../model.js';
-import { renderFrame, detectColorCaps } from '../render.js';
-// ── Fixture ───────────────────────────────────────────────────────────────────
-function row(node_id, name, status, opts = {}) {
-    return { node_id, name, status, kind: 'general', mode: 'base', ctx_tokens: 0, asks: 0, cwd: '/tmp/proj', created: '2026-01-01T00:00:00.000Z', ...opts };
-}
-const ROWS = [
-    row('root1', 'alpha', 'active'),
-    row('idle1', 'bravo', 'idle'),
-    row('done1', 'charlie', 'done', { ctx_tokens: 120_000 }), // ≥100k → red ctx
-    row('dead1', 'delta', 'dead'),
-    row('canc1', 'echo', 'canceled', { asks: 3 }),
-];
-const ROOT_IDS = ['root1', 'idle1', 'done1', 'dead1', 'canc1'];
-const childIdsOf = () => [];
-function tree() {
-    return buildTree(ROWS, ROOT_IDS, childIdsOf);
-}
-const SIZE = { cols: 100, rows: 24 };
-const ON = { color: true, color256: true };
-const OFF = { color: false, color256: false };
-function state(over = {}) {
-    const t = tree();
-    const visible = flatten(t, { collapsed: new Set(), tab: 'All', query: over.query ?? '' });
-    return {
-        tree: t,
-        visible,
-        tab: 'All',
-        cursor: 0,
-        scrollOffset: 0,
-        query: '',
-        search: false,
-        totalNodes: t.nodes.size,
-        cwdScope: null,
-        profileScope: undefined,
-        sort: 'tree',
-        preview: false,
-        residentsOnly: false,
-        pinned: new Set(),
-        ...over,
-    };
-}
-const ESC = '\x1b[';
-/** Any hue (color) SGR: fg 30–37/90–97, bg 40–47/100–107, or 256/truecolor sel. */
-const HUE_RE = /\x1b\[(3\d|4\d|9\d|10\d|38;|48;)/;
-// ── (a) color enabled → status hue present, glyph still there ──────────────────
-test('all-dirs view retains the project column while profile scope is active', () => {
-    const out = renderFrame(state({ profileScope: 'crouter-12345678', cwdScope: null, cursor: -1 }), SIZE, OFF);
-    assert.ok(out.includes('PROJECT'), 'all-dirs column header remains visible');
-    assert.ok(out.includes('~proj'), 'each row retains its cwd basename');
-});
-test('color on: each status glyph carries its hue, glyph kept', () => {
-    // cursor off the rows we assert so lineBase doesn't wrap the glyph code.
-    const out = renderFrame(state({ cursor: -1 }), SIZE, ON);
-    assert.ok(out.includes(`${ESC}32m●`), 'active → green ●');
-    assert.ok(out.includes(`${ESC}33m○`), 'idle → yellow ○');
-    assert.ok(out.includes(`${ESC}36m✓`), 'done → cyan ✓');
-    assert.ok(out.includes(`${ESC}31m✗`), 'dead → red ✗');
-    assert.ok(out.includes(`${ESC}90m⊘`), 'canceled → gray ⊘');
-});
-test('color on: ctx ≥100k row is red; asks are bright-yellow', () => {
-    const out = renderFrame(state({ cursor: -1 }), SIZE, ON);
-    // ctx is a right-aligned fixed-width column now, so the red span carries padding.
-    assert.ok(out.includes(`${ESC}31m`) && out.includes('120k'), 'ctx ≥100k → red');
-    assert.ok(out.includes(`${ESC}93m`), 'asks → bright-yellow');
-    assert.ok(out.includes('⚑3'), 'flag glyph kept');
-});
-test('color on: cursor row uses a 256-color background (not full reverse)', () => {
-    const out = renderFrame(state({ cursor: 0 }), SIZE, ON);
-    assert.ok(out.includes(`${ESC}48;5;236m`), 'subtle dark-gray cursor bg');
-    // and the status glyph hue still reads on the selected row
-    assert.ok(out.includes(`${ESC}32m●`), 'glyph hue survives on cursor row');
-});
-// ── (b) NO_COLOR → no hue SGR, but the glyphs (the real encoding) remain ───────
-test('color off: no hue SGR emitted, but every status glyph remains', () => {
-    const out = renderFrame(state({ cursor: -1 }), SIZE, OFF);
-    assert.ok(!HUE_RE.test(out), `expected no color SGR, got: ${JSON.stringify(out.match(HUE_RE))}`);
-    for (const g of ['●', '○', '✓', '✗', '⊘']) {
-        assert.ok(out.includes(g), `glyph ${g} kept without color`);
-    }
-    assert.ok(out.includes('⚑3'), 'flag glyph kept without color');
-    // structural SGR is still allowed (dim separators/footer, reverse cursor).
-    assert.ok(out.includes(`${ESC}2m`), 'dim (structural) still used');
-});
-test('color off: cursor row falls back to reverse (structural, no hue)', () => {
-    const out = renderFrame(state({ cursor: 0 }), SIZE, OFF);
-    assert.ok(out.includes(`${ESC}7m`), 'reverse cursor fallback');
-    assert.ok(!HUE_RE.test(out), 'still no hue under no-color');
-});
-// ── (c) query → the matched substring is highlighted ───────────────────────────
-test('color on: matched chars in a row name get the bright-cyan highlight', () => {
-    // query 'lph' matches 'alpha' (a-LPH-a). The matched run is highlighted.
-    const out = renderFrame(state({ query: 'lph', cursor: -1 }), SIZE, ON);
-    assert.ok(out.includes(`${ESC}96mlph`), 'matched substring → bright-cyan');
-});
-test('color off: match highlight degrades to bold (no hue), name intact', () => {
-    const out = renderFrame(state({ query: 'lph', cursor: -1 }), SIZE, OFF);
-    assert.ok(!HUE_RE.test(out), 'no hue under no-color even with a query');
-    assert.ok(out.includes(`${ESC}1mlph`), 'matched chars bold as the no-color affordance');
-});
-// ── detectColorCaps gate ───────────────────────────────────────────────────────
-test('detectColorCaps: honors NO_COLOR, TERM=dumb, and non-TTY', () => {
-    assert.deepEqual(detectColorCaps({ isTTY: true }, { TERM: 'xterm-256color', COLORTERM: 'truecolor' }), { color: true, color256: true });
-    assert.equal(detectColorCaps({ isTTY: true }, { TERM: 'xterm-256color', NO_COLOR: '1' }).color, false);
-    assert.equal(detectColorCaps({ isTTY: true }, { TERM: 'dumb' }).color, false);
-    assert.equal(detectColorCaps({ isTTY: false }, { TERM: 'xterm-256color' }).color, false);
-    // basic color but no 256 → color on, color256 off (reverse cursor fallback).
-    assert.deepEqual(detectColorCaps({ isTTY: true }, { TERM: 'xterm' }), { color: true, color256: false });
-});

package/dist/core/canvas/browse/rebuild-coalescer.d.ts

@@ -1,7 +0,0 @@
-export interface CoalescedRebuilder {
-    /** Called on every SSE event. Cheap — only schedules/marks work. */
-    trigger: () => void;
-    /** Cancels any pending debounce timer (does not abort an in-flight rebuild). */
-    stop: () => void;
-}
-export declare function createCoalescedRebuilder(rebuild: () => Promise<void>, debounceMs?: number): CoalescedRebuilder;

package/dist/core/canvas/browse/rebuild-coalescer.js

@@ -1,61 +0,0 @@
-// rebuild-coalescer.ts — single-flight + debounce coalescing for a burst of
-// SSE-triggered rebuilds (`canvas browse`'s remote path — see app.ts).
-//
-// A remote `RemoteEventStream` `nodes`/`inbox` event means "invalidate + re-pull
-// the tree", which for a remote source costs one `node inspect list` plus N
-// `node inspect show` round trips. A burst of events (several nodes changing at
-// once) must NOT fan into one overlapping rebuild per event — it must collapse
-// to one rebuild per burst. This module is the pure, TTY-free coalescing policy
-// so it can be unit-tested without the raw-mode stdin loop in app.ts:
-//
-//   - `trigger()` debounces a burst into ONE rebuild call after `debounceMs` of
-//     quiet.
-//   - if a rebuild is already in flight when the debounce fires (or another
-//     trigger lands mid-rebuild), it does NOT launch an overlapping rebuild —
-//     it marks exactly one trailing rebuild to run immediately after the
-//     in-flight one finishes.
-//
-// Net effect: N events in a burst → 1 rebuild (or, if the burst spans an
-// in-flight rebuild, 2: the one already running + one trailing catch-up) —
-// never N overlapping rebuilds.
-export function createCoalescedRebuilder(rebuild, debounceMs = 200) {
-    let timer;
-    let inFlight = false;
-    let pending = false;
-    const run = () => {
-        inFlight = true;
-        void rebuild().finally(() => {
-            inFlight = false;
-            if (pending) {
-                // A trailing catch-up was armed while this rebuild ran — fire it
-                // immediately (no further debounce: the just-finished rebuild WAS the
-                // quiet period), collapsing every event that landed mid-flight into
-                // exactly one follow-up rebuild, not one per event.
-                pending = false;
-                run();
-            }
-        });
-    };
-    const trigger = () => {
-        if (inFlight) {
-            // Already rebuilding — mark one trailing catch-up instead of starting a
-            // second overlapping rebuild or re-arming the debounce timer (which
-            // would keep pushing the catch-up back on every further event).
-            pending = true;
-            return;
-        }
-        if (timer !== undefined)
-            return; // already debounced in this quiet window
-        timer = setTimeout(() => {
-            timer = undefined;
-            run();
-        }, debounceMs);
-    };
-    const stop = () => {
-        if (timer !== undefined) {
-            clearTimeout(timer);
-            timer = undefined;
-        }
-    };
-    return { trigger, stop };
-}

package/dist/core/canvas/remote-event-stream.d.ts

@@ -1,24 +0,0 @@
-export type RemoteEventKind = 'nodes' | 'inbox';
-export interface RemoteEventStreamOptions {
-    /** Initial reconnect backoff (ms). Default 1000; injectable so tests don't
-     *  have to wait out the production backoff window. */
-    initialBackoffMs?: number;
-    /** Reconnect backoff cap (ms). Default 30_000. */
-    backoffCapMs?: number;
-}
-export declare class RemoteEventStream {
-    private readonly previewEndpoint;
-    private readonly relayToken;
-    private controller;
-    private stopped;
-    private readonly listeners;
-    private readonly initialBackoffMs;
-    private backoffMs;
-    private readonly BACKOFF_CAP_MS;
-    private reconnectTimer;
-    constructor(previewEndpoint: string, relayToken: string, opts?: RemoteEventStreamOptions);
-    subscribe(fn: (kind: RemoteEventKind) => void): () => void;
-    start(): void;
-    stop(): void;
-    private loop;
-}

package/dist/core/canvas/remote-event-stream.js

@@ -1,94 +0,0 @@
-// remote-event-stream.ts — a Node SSE client over a remote canvas's
-// `/__crtr/events` endpoint, driving cache invalidation + re-render for a
-// remote-backed `canvas browse`/viewer. No new npm dependency: Node 18+
-// `fetch` returns a web-standard `ReadableStream` body, read manually with
-// `getReader()` + `TextDecoder` and split on the SSE `\n\n` event delimiter.
-export class RemoteEventStream {
-    previewEndpoint;
-    relayToken;
-    controller;
-    stopped = false;
-    listeners = new Set();
-    initialBackoffMs;
-    backoffMs;
-    BACKOFF_CAP_MS;
-    reconnectTimer;
-    constructor(previewEndpoint, relayToken, opts = {}) {
-        this.previewEndpoint = previewEndpoint;
-        this.relayToken = relayToken;
-        this.initialBackoffMs = opts.initialBackoffMs ?? 1000;
-        this.backoffMs = this.initialBackoffMs;
-        this.BACKOFF_CAP_MS = opts.backoffCapMs ?? 30_000;
-    }
-    subscribe(fn) {
-        this.listeners.add(fn);
-        return () => this.listeners.delete(fn);
-    }
-    start() {
-        this.stopped = false;
-        void this.loop();
-    }
-    stop() {
-        this.stopped = true;
-        this.controller?.abort();
-        if (this.reconnectTimer !== undefined) {
-            clearTimeout(this.reconnectTimer);
-            this.reconnectTimer = undefined;
-        }
-    }
-    async loop() {
-        while (!this.stopped) {
-            this.controller = new AbortController();
-            try {
-                const res = await fetch(new URL('/__crtr/events', this.previewEndpoint), {
-                    headers: { authorization: `Bearer ${this.relayToken}` },
-                    signal: this.controller.signal,
-                });
-                if (!res.ok || !res.body)
-                    throw new Error(`events ${res.status}`);
-                this.backoffMs = this.initialBackoffMs; // reset on a successful connect
-                const reader = res.body.getReader();
-                const decoder = new TextDecoder();
-                let buf = '';
-                while (true) {
-                    const { done, value } = await reader.read();
-                    if (done)
-                        break;
-                    buf += decoder.decode(value, { stream: true });
-                    let idx;
-                    while ((idx = buf.indexOf('\n\n')) >= 0) {
-                        const rawEvent = buf.slice(0, idx);
-                        buf = buf.slice(idx + 2);
-                        for (const line of rawEvent.split('\n')) {
-                            if (!line.startsWith('data:'))
-                                continue; // skip comments (: ping, : connected)
-                            try {
-                                const payload = JSON.parse(line.slice(5).trim());
-                                if (payload.kind === 'nodes' || payload.kind === 'inbox') {
-                                    for (const l of this.listeners)
-                                        l(payload.kind);
-                                }
-                                // unknown kind → silently ignored (forward-compat)
-                            }
-                            catch {
-                                // malformed data line — ignore
-                            }
-                        }
-                    }
-                }
-            }
-            catch {
-                // connection error/abort — fall through to backoff+retry unless stopped
-            }
-            if (this.stopped)
-                return;
-            await new Promise((resolve) => {
-                this.reconnectTimer = setTimeout(() => {
-                    this.reconnectTimer = undefined;
-                    resolve();
-                }, this.backoffMs);
-            });
-            this.backoffMs = Math.min(this.backoffMs * 2, this.BACKOFF_CAP_MS);
-        }
-    }
-}

package/dist/core/feed/__tests__/coalesce-human.test.d.ts

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

package/dist/core/feed/__tests__/coalesce-human.test.js

@@ -1,36 +0,0 @@
-import { test } from 'node:test';
-import assert from 'node:assert/strict';
-import { coalesce } from '../inbox.js';
-// Guards the contract that a human typing directly into a node's box is a
-// CONVERSATION TURN, not a notification: coalesce() delivers those words
-// verbatim (no "From … — N updates" digest header, no `[message]` kind tag),
-// so the dormant wake path reads identically to the live path. Every other
-// sender keeps the digest framing.
-function entry(over) {
-    return {
-        entry_id: '0'.repeat(31) + '1',
-        operation_id: 'op',
-        ts: '2026-01-01T00:00:00.000Z',
-        from: null,
-        tier: 'normal',
-        kind: 'message',
-        label: 'hi',
-        ...over,
-    };
-}
-test('a lone human message renders verbatim — no digest framing', () => {
-    const out = coalesce([entry({ from: 'human', label: 'hi', data: { body: 'hi' } })]);
-    assert.equal(out, 'hi');
-    assert.doesNotMatch(out, /From human/);
-    assert.doesNotMatch(out, /update/);
-    assert.doesNotMatch(out, /\[message\]/);
-});
-test('a multi-line human message keeps its body verbatim', () => {
-    const body = 'first line\n\nsecond paragraph';
-    const out = coalesce([entry({ from: 'human', label: 'first line', data: { body } })]);
-    assert.equal(out, body);
-});
-test('a non-human sender still gets the digest header', () => {
-    const out = coalesce([entry({ from: 'mqifzplr-0753bde3', label: 'go', data: { body: 'go' } })]);
-    assert.match(out, /^From mqifzplr-0753bde3 — 1 update:/);
-});

package/dist/core/feed/__tests__/empty-node-guard.test.d.ts

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

package/dist/core/feed/__tests__/empty-node-guard.test.js

@@ -1,45 +0,0 @@
-// Regression: a report/skeleton write for an EMPTY node id used to resolve
-// reportsDir('') → `nodes/reports` and silently mint a stray non-node sibling
-// under nodes/. That stray entry broke the full-tier test harness's node-dir
-// counter (`expected exactly 1 new node dir, got [<id>, reports]` — the rare
-// flake on CI run 27459304455). The boundary now refuses an empty node id loudly
-// instead of writing garbage. This locks that in.
-import { test } from 'node:test';
-import assert from 'node:assert/strict';
-import { mkdtempSync, existsSync, rmSync } from 'node:fs';
-import { join } from 'node:path';
-import { tmpdir } from 'node:os';
-import { push } from '../feed.js';
-import { ensureNodeDirs, nodesRoot } from '../../canvas/paths.js';
-test('push() rejects an empty nodeId and creates no stray nodes/reports dir', async () => {
-    const home = mkdtempSync(join(tmpdir(), 'crtr-emptyguard-'));
-    const orig = process.env['CRTR_HOME'];
-    process.env['CRTR_HOME'] = home;
-    try {
-        await assert.rejects(() => push('', { kind: 'update', body: 'orphan report' }), /empty nodeId/);
-        assert.equal(existsSync(join(nodesRoot(), 'reports')), false, 'no stray nodes/reports dir was created');
-    }
-    finally {
-        if (orig === undefined)
-            delete process.env['CRTR_HOME'];
-        else
-            process.env['CRTR_HOME'] = orig;
-        rmSync(home, { recursive: true, force: true });
-    }
-});
-test('ensureNodeDirs() rejects an empty nodeId and creates no stray skeleton dirs', () => {
-    const home = mkdtempSync(join(tmpdir(), 'crtr-emptyguard-'));
-    const orig = process.env['CRTR_HOME'];
-    process.env['CRTR_HOME'] = home;
-    try {
-        assert.throws(() => ensureNodeDirs(''), /non-empty path segment/);
-        assert.equal(existsSync(join(nodesRoot(), 'reports')), false, 'no stray nodes/reports dir was created');
-    }
-    finally {
-        if (orig === undefined)
-            delete process.env['CRTR_HOME'];
-        else
-            process.env['CRTR_HOME'] = orig;
-        rmSync(home, { recursive: true, force: true });
-    }
-});

package/dist/core/host-exports/__tests__/export-prunes-boot-skill.test.d.ts

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

package/dist/core/host-exports/__tests__/export-prunes-boot-skill.test.js

@@ -1,84 +0,0 @@
-// Regression: crouter must not leave its old generated `crtr-skills` Agent Skill
-// installed in pi/Claude host skill dirs after memory became the first-class
-// guidance surface. The legacy bundle caused pi to inject an <available_skills>
-// block that described SKILL.md as current crouter behavior.
-//
-// Run: node --import tsx/esm --test src/core/host-exports/__tests__/export-prunes-boot-skill.test.ts
-import { test, beforeEach, afterEach } from 'node:test';
-import assert from 'node:assert/strict';
-import { mkdtempSync, rmSync, mkdirSync, writeFileSync, existsSync, readFileSync } from 'node:fs';
-import { tmpdir } from 'node:os';
-import { join } from 'node:path';
-import { defineBranch, defineLeaf, defineRoot } from '../../command.js';
-import { provisionExports, pruneLegacyExports } from '../export.js';
-let home;
-let prevHome;
-let prevNoExports;
-beforeEach(() => {
-    prevHome = process.env.HOME;
-    prevNoExports = process.env.CRTR_NO_EXPORTS;
-    home = mkdtempSync(join(tmpdir(), 'crtr-export-prune-'));
-    process.env.HOME = home;
-    delete process.env.CRTR_NO_EXPORTS;
-    mkdirSync(join(home, '.pi', 'agent', 'skills', 'crtr-skills'), { recursive: true });
-    mkdirSync(join(home, '.claude', 'skills', 'crtr-skills'), { recursive: true });
-    writeFileSync(join(home, '.pi', 'agent', 'skills', 'crtr-skills', 'SKILL.md'), '---\nname: crtr-skills\n---\n\n<!-- crtr-boot-skill v2 -->\n', 'utf8');
-    writeFileSync(join(home, '.claude', 'skills', 'crtr-skills', 'SKILL.md'), '---\nname: crtr-skills\n---\n\nuser-customized, no crtr marker\n', 'utf8');
-});
-afterEach(() => {
-    if (prevHome === undefined)
-        delete process.env.HOME;
-    else
-        process.env.HOME = prevHome;
-    if (prevNoExports === undefined)
-        delete process.env.CRTR_NO_EXPORTS;
-    else
-        process.env.CRTR_NO_EXPORTS = prevNoExports;
-    rmSync(home, { recursive: true, force: true });
-});
-const root = defineRoot({
-    tagline: 'fixture',
-    globals: [],
-    subtrees: [
-        defineBranch({
-            name: 'fixture',
-            help: { name: 'fixture', summary: 'fixture' },
-            rootEntry: { concept: 'fixture', desc: 'fixture', useWhen: 'fixture' },
-            children: [
-                defineLeaf({
-                    name: 'demo',
-                    help: {
-                        name: 'fixture demo',
-                        summary: 'demo',
-                        output: [],
-                        outputKind: 'object',
-                        effects: ['None. Read-only.'],
-                    },
-                    slash: {
-                        name: 'demo',
-                        description: 'demo command',
-                        body: 'run demo',
-                    },
-                    run: async () => ({}),
-                }),
-            ],
-        }),
-    ],
-});
-test('provisionExports prunes marker-bearing legacy boot skills and still writes slash commands', () => {
-    // cli.ts calls both, in this order, on any non-bare invocation.
-    pruneLegacyExports(['node', 'crtr', 'fixture']);
-    provisionExports(root, ['node', 'crtr', 'fixture']);
-    assert.equal(existsSync(join(home, '.pi', 'agent', 'skills', 'crtr-skills', 'SKILL.md')), false, 'marker-bearing pi crtr-skills bundle should be removed');
-    assert.equal(existsSync(join(home, '.claude', 'skills', 'crtr-skills', 'SKILL.md')), true, 'markerless user-owned Claude skill should not be removed');
-    assert.match(readFileSync(join(home, '.pi', 'agent', 'prompts', 'demo.md'), 'utf8'), /<!-- crtr-mode-cmd v1 -->/, 'pi slash-command export should still be provisioned');
-    assert.match(readFileSync(join(home, '.claude', 'commands', 'demo.md'), 'utf8'), /<!-- crtr-mode-cmd v1 -->/, 'Claude slash-command export should still be provisioned');
-});
-test('bare front-door argv prunes legacy boot skills before pi can start', () => {
-    // Bare `crtr`: cli.ts prunes BEFORE the front door boots, and the write pass
-    // (which runs only after the front door declines) is a no-op for bare argv.
-    pruneLegacyExports(['node', 'crtr']);
-    provisionExports(root, ['node', 'crtr']);
-    assert.equal(existsSync(join(home, '.pi', 'agent', 'skills', 'crtr-skills', 'SKILL.md')), false, 'bare crtr must remove stale pi crtr-skills before booting pi');
-    assert.equal(existsSync(join(home, '.pi', 'agent', 'prompts', 'demo.md')), false, 'bare front-door pruning must not provision slash-command prompts');
-});

package/dist/core/human/__tests__/visible-paths.test.d.ts

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

package/dist/core/human/__tests__/visible-paths.test.js

@@ -1,28 +0,0 @@
-import assert from 'node:assert/strict';
-import { mkdtempSync, writeFileSync } from 'node:fs';
-import { tmpdir } from 'node:os';
-import { join } from 'node:path';
-import test from 'node:test';
-import { checkReviewableFile, extractFilePaths } from '../visible-paths.js';
-test('extractFilePaths finds existing paths, strips positions, and deduplicates', () => {
-    const root = mkdtempSync(join(tmpdir(), 'crtr-visible-paths-'));
-    const file = join(root, 'example.ts');
-    writeFileSync(file, 'export {};\n');
-    assert.deepEqual(extractFilePaths([`${file}:12:3 and again ${file}`], root), [file]);
-});
-test('checkReviewableFile rejects non-files and binary text', () => {
-    const root = mkdtempSync(join(tmpdir(), 'crtr-reviewable-file-'));
-    const binary = join(root, 'binary.dat');
-    writeFileSync(binary, Buffer.from([0x61, 0, 0x62]));
-    assert.deepEqual(checkReviewableFile(root), { ok: false, reason: 'not a file' });
-    assert.deepEqual(checkReviewableFile(binary), { ok: false, reason: 'file is not UTF-8 text' });
-});
-test('checkReviewableFile admits a newline-terminated document at the 5,000-line limit and rejects 5,001', () => {
-    const root = mkdtempSync(join(tmpdir(), 'crtr-reviewable-limit-'));
-    const atLimit = join(root, 'at-limit.md');
-    const overLimit = join(root, 'over-limit.md');
-    writeFileSync(atLimit, 'line\n'.repeat(5000));
-    writeFileSync(overLimit, 'line\n'.repeat(5001));
-    assert.deepEqual(checkReviewableFile(atLimit), { ok: true });
-    assert.deepEqual(checkReviewableFile(overLimit), { ok: false, reason: 'file is too long to review (5,000 line limit)' });
-});

package/dist/core/keybindings/__tests__/inbox-affordance.test.d.ts

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