@crouton-kit/crouter 0.3.28 → 0.3.29

package/dist/core/__tests__/reset.test.js

@@ -1,14 +1,14 @@
 // Run with: node --import tsx/esm --test src/core/__tests__/reset.test.ts
+//
+// resetRoot now handles ONLY the non-root child `/new` (a session-id refresh).
+// A root's `/new` mints a fresh node via relaunchRoot — see relaunch-root.test.ts.
 import { test, before, after, beforeEach } from 'node:test';
 import assert from 'node:assert/strict';
-import { mkdtempSync, rmSync, existsSync, writeFileSync } from 'node:fs';
+import { mkdtempSync, rmSync } from 'node:fs';
 import { tmpdir } from 'node:os';
 import { join } from 'node:path';
-import { createNode, getNode, subscribe, setStatus, subscriptionsOf, view, } from '../canvas/canvas.js';
-import { openFocusRow, getFocusByNode } from '../canvas/focuses.js';
+import { createNode, getNode, subscribe } from '../canvas/canvas.js';
 import { closeDb } from '../canvas/db.js';
-import { reportsDir, inboxPath } from '../canvas/paths.js';
-import { roadmapPath } from '../runtime/roadmap.js';
 import { resetRoot } from '../runtime/reset.js';
 let home;
 function node(id, over = {}) {
@@ -37,76 +37,29 @@ after(() => {
     rmSync(home, { recursive: true, force: true });
     delete process.env['CRTR_HOME'];
 });
-test('resetRoot empties the root view, reaps descendants, and wipes working state', () => {
-    // root → child → grandchild (mirrors a parent that subscribes to its workers)
-    createNode(node('root', { parent: null, lifecycle: 'resident', mode: 'orchestrator', pi_session_id: 'old-sess' }));
-    createNode(node('child', { parent: 'root' }));
-    createNode(node('grand', { parent: 'child' }));
-    subscribe('root', 'child', true);
-    subscribe('child', 'grand', true);
-    // Root accumulated working state.
-    writeFileSync(roadmapPath('root'), '# Roadmap\nold goal\n');
-    writeFileSync(inboxPath('root'), '{"ts":"x","from":"child","tier":"normal","kind":"update","label":"hi"}\n');
-    writeFileSync(join(reportsDir('root'), '20260101T000000-update.md'), 'stale report');
-    assert.equal(view('root').length, 2, 'precondition: root sees 2 descendants');
-    const res = resetRoot('root', 'new-sess', '/abs/sessions/new.jsonl');
-    assert.equal(res.reset, true);
-    assert.deepEqual(res.detached, ['child'], 'root detaches its direct subscription');
-    assert.deepEqual(res.reaped.sort(), ['child', 'grand'], 'whole sub-DAG reaped');
-    // Graph is empty from the root's view.
-    assert.equal(view('root').length, 0, 'root view is empty after reset');
-    assert.equal(subscriptionsOf('root').length, 0, 'no outgoing edges remain');
-    // Descendants are CANCELED (A5, human-confirmed 2026-06-06): an externally-
-    // reaped node — via reset/relaunch OR close — did not finish its OWN work, so
-    // it unifies on `canceled`; `done` is reserved for finalize. Daemon skips them.
-    assert.equal(getNode('child')?.status, 'canceled');
-    assert.equal(getNode('grand')?.status, 'canceled');
-    // Regression: a reset-reaped descendant ends EXACTLY {canceled, null} — byte-
-    // for-byte identical to the close path (mirrors cascade-close.test.ts's tuple).
-    assert.deepEqual({ status: getNode('grand')?.status, intent: getNode('grand')?.intent ?? null }, { status: 'canceled', intent: null }, 'reset-reaped descendant: (status,intent) === (canceled, null), same as close');
-    // Working state wiped.
-    assert.equal(existsSync(roadmapPath('root')), false, 'roadmap wiped');
-    assert.equal(existsSync(inboxPath('root')), false, 'inbox wiped');
-    // Root reset to a pristine base resident, rebound to the new session id.
-    const root = getNode('root');
-    assert.equal(root?.mode, 'base');
-    assert.equal(root?.lifecycle, 'resident');
-    assert.equal(root?.status, 'active');
-    assert.equal(root?.intent, null);
-    assert.equal(root?.pi_session_id, 'new-sess');
-    assert.equal(root?.pi_session_file, '/abs/sessions/new.jsonl', 'session FILE rebound too');
-    assert.ok(root?.launch, 'a fresh base launch spec was written');
-});
-test('resetRoot on a non-root only refreshes the session id (no reap)', () => {
+test('resetRoot on a non-root child refreshes the session id (no reap, no reset)', () => {
     createNode(node('root', { parent: null }));
     createNode(node('child', { parent: 'root', pi_session_id: 'old' }));
     subscribe('root', 'child', true);
-    subscribe('child', 'root', false); // contrived: ensure child has an outgoing edge
     const res = resetRoot('child', 'fresh', '/abs/sessions/fresh.jsonl');
-    assert.equal(res.reset, false, 'a non-root is not a graph reset');
+    assert.equal(res.reset, false, 'a child `/new` is not a graph reset');
     assert.deepEqual(res.reaped, []);
     assert.deepEqual(res.detached, []);
-    assert.equal(getNode('child')?.pi_session_id, 'fresh', 'session id still refreshed');
+    assert.equal(getNode('child')?.pi_session_id, 'fresh', 'session id refreshed');
     assert.equal(getNode('child')?.pi_session_file, '/abs/sessions/fresh.jsonl', 'session FILE refreshed too');
     assert.equal(getNode('child')?.status, 'active', 'child not reaped');
-    // The root that subscribes to the child is untouched.
-    assert.equal(getNode('root')?.status, 'active');
+    assert.equal(getNode('root')?.status, 'active', 'the subscribing root is untouched');
 });
-test('Step 7: resetRoot reaps a FOCUSED descendant through tearDownNode (closes its focus row + nulls presence)', () => {
-    createNode(node('root', { parent: null, lifecycle: 'resident', mode: 'orchestrator' }));
-    createNode(node('desc', { parent: 'root', pane: '%d' }));
-    subscribe('root', 'desc', true);
-    openFocusRow('fD', '%d', 'Suser', 'desc');
-    resetRoot('root', 'new-sess');
-    // reapDescendants now routes each descendant through tearDownNode, so a focused
-    // descendant's focus row is closed and its LOCATION nulled. Non-vacuous:
-    // pre-Step-7 reap used closeWindow and never touched the focuses table, so
-    // getFocusByNode('desc') would still return fD.
-    assert.equal(getFocusByNode('desc'), null, 'descendant focus row closed by tearDownNode');
-    const d = getNode('desc');
-    assert.equal(d.status, 'canceled', 'descendant reaped (canceled — A5 unified)');
-    assert.equal(d.pane ?? null, null, 'descendant pane nulled');
-    assert.equal(d.tmux_session ?? null, null, 'descendant session nulled');
+test('resetRoot on a ROOT is a no-op (roots route to relaunchRoot, not here)', () => {
+    createNode(node('root', { parent: null, lifecycle: 'resident', pi_session_id: 'keep' }));
+    createNode(node('child', { parent: 'root' }));
+    subscribe('root', 'child', true);
+    const res = resetRoot('root', 'new-sess');
+    assert.equal(res.reset, false);
+    assert.deepEqual(res.reaped, [], 'a root `/new` reaps nothing here');
+    assert.equal(getNode('root')?.status, 'active', 'root left untouched');
+    assert.equal(getNode('root')?.pi_session_id, 'keep', 'a root session id is NOT refreshed here');
+    assert.equal(getNode('child')?.status, 'active', 'descendant left untouched');
 });
 test('resetRoot is a no-op for an unknown node', () => {
     const res = resetRoot('ghost', 'x');
@@ -114,16 +67,3 @@ test('resetRoot is a no-op for an unknown node', () => {
     assert.deepEqual(res.reaped, []);
     assert.deepEqual(res.detached, []);
 });
-test('reaped descendants keep their meta on disk (orphaned, not deleted)', () => {
-    createNode(node('root', { parent: null }));
-    createNode(node('child', { parent: 'root' }));
-    subscribe('root', 'child', true);
-    setStatus('child', 'idle');
-    resetRoot('root', 'new');
-    // The node record persists (we detach + mark canceled, we don't delete the node).
-    const child = getNode('child');
-    assert.ok(child, 'child meta still on disk');
-    assert.equal(child?.status, 'canceled');
-    // It is just unreachable from the root.
-    assert.equal(view('root').length, 0);
-});

package/dist/core/__tests__/steer-note.test.js

@@ -18,16 +18,18 @@ test('an orchestrator (resident) gets the same roadmap/yield steering as a termi
     const r = steerNote(150_000, 'resident', 'orchestrator');
     assert.equal(r, t, 'mode drives the message, not lifecycle');
 });
-test('a terminal BASE worker is steered to promote / push final', () => {
+test('a terminal BASE worker is steered to yield-or-finish, never at a bare promote', () => {
     const msg = steerNote(170_000, 'terminal', 'base');
-    assert.match(msg, /node promote/, 'a base worker is told it can promote');
-    assert.match(msg, /push final/, 'and to finish with push final when nearly done');
-    assert.doesNotMatch(msg, /roadmap\.md/, 'a base worker has no roadmap to checkpoint');
+    assert.match(msg, /node yield/, 'a base worker is told to yield to continue (which auto-promotes under the hood)');
+    assert.match(msg, /push final/, 'and to finish with push final when close');
+    assert.doesNotMatch(msg, /node promote/, 'never the heavy "become an orchestrator" framing that bred yield-avoidance');
+    assert.doesNotMatch(msg, /roadmap\.md/, 'a base worker has no roadmap.md to checkpoint');
 });
-test('a resident BASE root is steered to promote-or-wrap-up, never at a roadmap', () => {
+test('a resident BASE root is steered to yield-or-wrap-up, never at a bare promote or roadmap', () => {
     const msg = steerNote(150_000, 'resident', 'base');
-    assert.match(msg, /node promote/, 'a root growing into a job is told to promote');
-    assert.doesNotMatch(msg, /roadmap\.md/, 'a root has no roadmap to point at');
+    assert.match(msg, /node yield/, 'a root growing into a job is told to yield (which auto-promotes)');
+    assert.doesNotMatch(msg, /node promote/, 'never the heavy "become an orchestrator" framing');
+    assert.doesNotMatch(msg, /roadmap\.md/, 'a root has no roadmap.md to point at');
     assert.doesNotMatch(msg, /push final/, 'a resident node never finishes with push final');
 });
 test('below the first band there is no nudge boundary issue — pushy escalation kicks in at 185k', () => {

package/dist/core/__tests__/tmux-surface.test.js

@@ -3,8 +3,10 @@
 // STEP 2 of the placement/focus migration: guards on the tmux Surface (driver).
 //
 //   1. The §2.2 HARD DRIVER INVARIANT (GREEN now): every create/placement verb
-//      in the driver — new-window / split-window / swap-pane / break-pane /
-//      join-pane / move-pane / respawn-pane — MUST pass an explicit `-t` target.
+//      in the driver — after the broker-host cut gutted the engine-in-pane
+//      relocate verbs (U9 deleted swap-pane/break-pane/join-pane/move-pane),
+//      the survivors are new-window / split-window / respawn-pane — MUST pass an
+//      explicit `-t` target.
 //      Omitting `-t` lets tmux resolve against its GLOBAL current session, which
 //      can leak a pane into a user session — the exact unbidden-window bug this
 //      redesign kills. This guards the bug's blast radius and should pass today.
@@ -21,7 +23,10 @@ import { dirname, join, basename } from 'node:path';
 const __dirname = dirname(fileURLToPath(import.meta.url));
 const SRC_ROOT = join(__dirname, '..', '..'); // .../src
 const TMUX_TS = join(SRC_ROOT, 'core', 'runtime', 'tmux.ts');
-/** The placement verbs the §2.2 invariant governs. */
+/** The placement verbs the §2.2 invariant governs. (swap-pane/break-pane/
+ *  join-pane/move-pane were deleted with the engine-in-pane host in the broker
+ *  cut; kept in the match set so a regression that re-introduces an untargeted
+ *  one is still caught.) */
 const PLACEMENT_VERBS = [
     'new-window',
     'split-window',
@@ -67,8 +72,9 @@ test('§2.2 driver invariant: every placement verb in tmux.ts passes an explicit
             `instance of the unbidden-window bug (§2.2). Offending args array:\n${arr}`);
     }
     // Sanity: the driver really does contain placement verbs (so a refactor that
-    // renames them can't make this assertion vacuously pass).
-    assert.ok(found >= 4, `expected to scan ≥4 placement verbs, saw ${found}`);
+    // renames them can't make this assertion vacuously pass). The broker cut left
+    // three (new-window / split-window / respawn-pane).
+    assert.ok(found >= 3, `expected to scan ≥3 placement verbs, saw ${found}`);
 });
 // ---------------------------------------------------------------------------
 // Lint guard — §5.1, ENFORCED. The driver (tmux.ts) is imported ONLY by
@@ -92,8 +98,8 @@ function allTsFiles(dir) {
 const ALLOWED_IMPORTERS = new Set(['tmux.ts', 'placement.ts', 'tmux-chrome.ts']);
 function importsDriver(file) {
     const src = readFileSync(file, 'utf8');
-    // A specifier whose basename is exactly `tmux.js` (so `tmux-chrome.js` and
-    // `tmux-spread.js` are NOT matched). Covers `from '...'` and `import('...')`.
+    // A specifier whose basename is exactly `tmux.js` (so `tmux-chrome.js` is NOT
+    // matched). Covers `from '...'` and `import('...')`.
     return [...src.matchAll(/(?:from|import\s*\()\s*'([^']+)'/g)].some((m) => basename(m[1]) === 'tmux.js');
 }
 test('§5.1 lint: only placement.ts / tmux-chrome.ts import the tmux driver', () => {

package/dist/core/bootstrap.d.ts

@@ -1,8 +1,5 @@
-import type { RootDef } from './command.js';
 export declare const OFFICIAL_MARKETPLACE_NAME = "crouter-official-marketplace";
 export declare const OFFICIAL_MARKETPLACE_URL = "https://github.com/crouton-labs/crouter-official-marketplace.git";
 export declare const OFFICIAL_MARKETPLACE_REF = "main";
-export declare function ensureBootSkill(argv: string[]): void;
-export declare function ensureSlashCommands(root: RootDef, argv: string[]): void;
 export declare function ensureOfficialMarketplace(argv: string[]): void;
 export declare function ensureProjectScope(argv: string[]): void;

package/dist/core/bootstrap.js

@@ -1,12 +1,10 @@
-import { writeFileSync } from 'node:fs';
 import { homedir } from 'node:os';
 import { join } from 'node:path';
 import { findProjectScopeRoot, resetScopeCache, userScopeRoot } from './scope.js';
-import { ensureDir, pathExists, readText, removePath, nowIso } from './fs-utils.js';
+import { ensureDir, pathExists, removePath, nowIso } from './fs-utils.js';
 import { readConfig, readState, updateConfig, updateState, ensureScopeInitialized } from './config.js';
 import { clone } from './git.js';
 import { readMarketplaceManifest } from './manifest.js';
-import { collectSlashSpecs } from './command.js';
 import { CRTR_DIR_NAME } from '../types.js';
 export const OFFICIAL_MARKETPLACE_NAME = 'crouter-official-marketplace';
 export const OFFICIAL_MARKETPLACE_URL = 'https://github.com/crouton-labs/crouter-official-marketplace.git';
@@ -24,146 +22,6 @@ function shouldSkipForArgv(argv) {
         return true;
     return SKIP_SUBCOMMANDS.has(sub);
 }
-const BOOT_SKILL_NAME = 'crtr-skills';
-const BOOT_SKILL_MARKER = '<!-- crtr-boot-skill v2 -->';
-const BOOT_SKILL_MARKER_PREFIX = '<!-- crtr-boot-skill v';
-function bootSkillBody() {
-    return `---
-name: crtr-skills
-description: 'Author, list, search, and load crtr memory documents (skills, references, preferences) via the crtr CLI. These are durable agent memory — markdown future LLM sessions load on demand. Use when the user wants to remember/save knowledge, build a context primer, or recall a previously saved doc. Triggers: "save", "remember", "build context for", "what skills do we have", "skill for X".'
-argument-hint: [topic or verb]
----
-
-${BOOT_SKILL_MARKER}
-
-# /crtr-skills — crtr memory router
-
-crtr memory documents = durable agent memory (kind: skill, reference, or
-preference). Written for **future LLM sessions**, not the user. \`crtr memory\`
-is the surface — author, discover, and load them.
-
-## Route by intent
-
-- **Capture** ("save", "remember", "build context for", "make a skill"):
-  \`crtr memory write <name> --kind <skill|reference|preference>\` with the
-  body piped on stdin — e.g.
-  \`crtr memory write $ARGUMENTS --kind skill <<'EOF' … EOF\`. Run
-  \`crtr memory write -h\` for the full frontmatter schema
-  (--when-and-why-to-read, --short-form, --scope, visibility rungs), then
-  \`crtr memory lint\` to validate what you wrote.
-- **Find** ("what do we have on X"): \`crtr memory find "$ARGUMENTS"\` →
-  \`crtr memory read <name>\` on the best hit (add --body/--grep to search
-  bodies).
-- **Load by name**: \`crtr memory read <name>\`.
-- **List all**: \`crtr memory list\`.
-
-If \`$ARGUMENTS\` is empty, ask the user what they want before running.
-
-## Rules
-
-- CLI stdout is the prompt — act on it, don't paraphrase to the user.
-- Append \`-h\` at any leaf (\`crtr memory write -h\`) for its full schema
-  before authoring.
-- If \`crtr\` is not on PATH, tell the user and stop.
-`;
-}
-export function ensureBootSkill(argv) {
-    try {
-        if (process.env.CRTR_NO_BOOT_SKILL === '1')
-            return;
-        if (shouldSkipForArgv(argv))
-            return;
-        const claudeSkillsRoot = join(homedir(), '.claude', 'skills');
-        // Only install if the user actually uses Claude Code (the dir exists or is
-        // creatable). We won't create ~/.claude itself; that's not our directory.
-        if (!pathExists(join(homedir(), '.claude')))
-            return;
-        const skillDir = join(claudeSkillsRoot, BOOT_SKILL_NAME);
-        const skillFile = join(skillDir, 'SKILL.md');
-        if (pathExists(skillFile)) {
-            const existing = readText(skillFile);
-            // If the user customized (no boot-skill marker at all), don't clobber.
-            if (!existing.includes(BOOT_SKILL_MARKER_PREFIX))
-                return;
-            // Any marker version present → roll forward to current. Skip if identical.
-            if (existing === bootSkillBody())
-                return;
-        }
-        ensureDir(skillDir);
-        writeFileSync(skillFile, bootSkillBody(), 'utf8');
-    }
-    catch (e) {
-        if (process.env.CRTR_DEBUG === '1') {
-            const msg = e instanceof Error ? e.message : String(e);
-            process.stderr.write(`crtr: boot-skill error: ${msg}\n`);
-        }
-    }
-}
-// ---------------------------------------------------------------------------
-// Slash commands (editor prompt templates) auto-installed for opted-in nodes.
-//
-// Any command that declares a `slash` SlashSpec is rendered to a markdown
-// template and dropped into the host's command dirs on each crtr run — pi reads
-// `~/.pi/agent/prompts/<name>.md`, Claude Code reads `~/.claude/commands/<name>.md`,
-// so `/name` becomes available. Marker-guarded (never clobbers a user-edited
-// file) and version-rolled like the boot skill. Kill switch: CRTR_NO_MODE_CMDS=1.
-// ---------------------------------------------------------------------------
-const SLASH_CMD_MARKER = '<!-- crtr-mode-cmd v1 -->';
-const SLASH_CMD_MARKER_PREFIX = '<!-- crtr-mode-cmd v';
-/** Render a SlashSpec to a full template file (frontmatter + marker + body). */
-function renderSlashTemplate(spec) {
-    const hint = spec.argumentHint !== undefined
-        ? `argument-hint: ${JSON.stringify(spec.argumentHint)}\n`
-        : '';
-    return `---\ndescription: ${spec.description}\n${hint}---\n\n${SLASH_CMD_MARKER}\n\n${spec.body}\n`;
-}
-/** Write `content` to `file` unless a user-customized file is already there.
- *  Rolls forward our own (marker-bearing) versions; skips if identical. */
-function writeSlashFileIfOurs(dir, name, content) {
-    const file = join(dir, `${name}.md`);
-    if (pathExists(file)) {
-        const existing = readText(file);
-        if (!existing.includes(SLASH_CMD_MARKER_PREFIX))
-            return; // user's own file
-        if (existing === content)
-            return; // already current
-    }
-    ensureDir(dir);
-    writeFileSync(file, content, 'utf8');
-}
-export function ensureSlashCommands(root, argv) {
-    try {
-        if (process.env.CRTR_NO_MODE_CMDS === '1')
-            return;
-        if (shouldSkipForArgv(argv))
-            return;
-        const specs = collectSlashSpecs(root);
-        if (specs.length === 0)
-            return;
-        // Target each host's command dir, but only when that host is actually in use
-        // (its root dir exists). We never create ~/.pi or ~/.claude ourselves.
-        const targets = [];
-        if (pathExists(join(homedir(), '.pi', 'agent'))) {
-            targets.push(join(homedir(), '.pi', 'agent', 'prompts'));
-        }
-        if (pathExists(join(homedir(), '.claude'))) {
-            targets.push(join(homedir(), '.claude', 'commands'));
-        }
-        if (targets.length === 0)
-            return;
-        for (const spec of specs) {
-            const content = renderSlashTemplate(spec);
-            for (const dir of targets)
-                writeSlashFileIfOurs(dir, spec.name, content);
-        }
-    }
-    catch (e) {
-        if (process.env.CRTR_DEBUG === '1') {
-            const msg = e instanceof Error ? e.message : String(e);
-            process.stderr.write(`crtr: slash-command error: ${msg}\n`);
-        }
-    }
-}
 export function ensureOfficialMarketplace(argv) {
     try {
         if (process.env.CRTR_NO_BOOTSTRAP === '1')

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

@@ -1,6 +1,6 @@
 import { test } from 'node:test';
 import assert from 'node:assert/strict';
-import { buildTree, flatten, fuzzyMatch, tabPredicate, TABS } from '../model.js';
+import { buildTree, flatten, fuzzyMatch, tabPredicate, TABS, attentionTier, attentionMtime } from '../model.js';
 // ── Fixture canvas ───────────────────────────────────────────────────────────
 //   root1 (active)            ← rank 0
 //     child-a (idle)
@@ -12,6 +12,9 @@ import { buildTree, flatten, fuzzyMatch, tabPredicate, TABS } from '../model.js'
 function row(node_id, name, status, asks = 0) {
     return { node_id, name, status, kind: 'general', mode: 'base', ctx_tokens: 0, asks, cwd: '/tmp/proj', created: '2026-01-01T00:00:00.000Z' };
 }
+function lrow(node_id, name, status, lifecycle) {
+    return { ...row(node_id, name, status), lifecycle };
+}
 const ROWS = [
     row('root1', 'root-one', 'active'),
     row('child-a', 'child-a', 'idle'),
@@ -140,3 +143,85 @@ test('flatten: query with no matches yields nothing', () => {
     const v = flatten(tree(), { collapsed: allCollapsed(), tab: 'All', query: 'zzzznope' });
     assert.deepEqual(v, []);
 });
+// ── flatten: residentsOnly fold-reveal ───────────────────────────────────────
+//   resident-root → terminal-worker (child) → terminal-grand (grandchild)
+//   resident-only must hide the terminals from the TOP LEVEL + flat search, yet
+//   still reveal them once you expand the resident fold that owns them.
+const RES_ROWS = [
+    lrow('res-root', 'resident-root', 'idle', 'resident'),
+    lrow('term-a', 'worker-a', 'active', 'terminal'),
+    lrow('term-g', 'worker-grand', 'active', 'terminal'),
+    lrow('term-root', 'lone-worker', 'active', 'terminal'), // pure-terminal root
+];
+const RES_CHILDREN = { 'res-root': ['term-a'], 'term-a': ['term-g'] };
+function resTree() {
+    return buildTree(RES_ROWS, ['res-root', 'term-root'], (id) => RES_CHILDREN[id] ?? []);
+}
+test('flatten: residentsOnly hides terminal top-level rows (incl. terminal roots)', () => {
+    // Everything collapsed → only the resident root shows; the lone terminal root
+    // and the worker subtree are hidden at the top level.
+    const v = flatten(resTree(), { collapsed: new Set(['res-root', 'term-a']), tab: 'All', query: '', residentsOnly: true });
+    assert.deepEqual(v.map((r) => r.id), ['res-root']);
+});
+test('flatten: residentsOnly reveals terminal children once their fold is expanded', () => {
+    // Expand the resident root → its terminal worker appears (still collapsed, so
+    // its own terminal grandchild stays hidden).
+    const v1 = flatten(resTree(), { collapsed: new Set(['term-a']), tab: 'All', query: '', residentsOnly: true });
+    assert.deepEqual(v1.map((r) => r.id), ['res-root', 'term-a']);
+    // Expand the worker too → the terminal grandchild is revealed.
+    const v2 = flatten(resTree(), { collapsed: new Set(), tab: 'All', query: '', residentsOnly: true });
+    assert.deepEqual(v2.map((r) => r.id), ['res-root', 'term-a', 'term-g']);
+});
+test('flatten: residentsOnly keeps terminals out of flat (relevance) search results', () => {
+    // A query that matches the workers must not surface them in the flat search —
+    // resident-only de-clutters search even though the fold would reveal them.
+    const v = flatten(resTree(), { collapsed: new Set(), tab: 'All', query: 'worker', residentsOnly: true, sort: 'relevance' });
+    assert.deepEqual(v.map((r) => r.id), []);
+});
+test('flatten: residentsOnly off shows every lifecycle at the top level', () => {
+    // Roots are live-first: term-root (active) ranks ahead of res-root (idle).
+    const v = flatten(resTree(), { collapsed: new Set(['res-root', 'term-a']), tab: 'All', query: '', residentsOnly: false });
+    assert.deepEqual(v.map((r) => r.id), ['term-root', 'res-root']);
+});
+function arow(node_id, status, opts) {
+    return { ...row(node_id, node_id, status), ...opts };
+}
+test('attentionTier: classifies each cheap-field combination', () => {
+    assert.equal(attentionTier(arow('x', 'active', { viewed: true, streaming: true })), 0);
+    assert.equal(attentionTier(arow('x', 'active', { viewed: true })), 1);
+    assert.equal(attentionTier(arow('x', 'active', { streaming: true, viewed: false })), 2);
+    assert.equal(attentionTier(arow('x', 'active', {})), 3);
+    assert.equal(attentionTier(arow('x', 'idle', {})), 3);
+    assert.equal(attentionTier(arow('x', 'done', {})), 4);
+    assert.equal(attentionTier(arow('x', 'dead', {})), 4);
+    assert.equal(attentionTier(arow('x', 'canceled', {})), 4);
+});
+test('attentionMtime: prefers mtimeMs, falls back to created', () => {
+    assert.equal(attentionMtime(arow('x', 'active', { mtimeMs: 1234 })), 1234);
+    // No mtimeMs → epoch-ms of the ISO `created` (fixture is 2026-01-01T00:00:00Z).
+    assert.equal(attentionMtime(arow('x', 'active', {})), Date.parse('2026-01-01T00:00:00.000Z'));
+});
+test('flatten: attention sort tiers rows (attached/streaming/live first)', () => {
+    // One row per tier, deliberately shuffled in input order.
+    const rows = [
+        arow('dormant', 'done', { mtimeMs: 100 }), // T4
+        arow('live', 'active', { mtimeMs: 100 }), // T3
+        arow('streaming', 'active', { streaming: true, mtimeMs: 100 }), // T2
+        arow('attached', 'idle', { viewed: true, mtimeMs: 100 }), // T1
+        arow('both', 'active', { viewed: true, streaming: true, mtimeMs: 100 }), // T0
+    ];
+    const t = buildTree(rows, [], () => []);
+    const v = flatten(t, { collapsed: new Set(), tab: 'All', query: '', sort: 'attention' });
+    assert.deepEqual(v.map((r) => r.id), ['both', 'attached', 'streaming', 'live', 'dormant']);
+});
+test('flatten: attention sort orders newest-message-first WITHIN a tier', () => {
+    // All dormant (T4) → ordering is purely by mtime, newest first.
+    const rows = [
+        arow('old', 'done', { mtimeMs: 1000 }),
+        arow('newest', 'done', { mtimeMs: 3000 }),
+        arow('mid', 'done', { mtimeMs: 2000 }),
+    ];
+    const t = buildTree(rows, [], () => []);
+    const v = flatten(t, { collapsed: new Set(), tab: 'All', query: '', sort: 'attention' });
+    assert.deepEqual(v.map((r) => r.id), ['newest', 'mid', 'old']);
+});

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

@@ -55,7 +55,8 @@ test('color on: each status glyph carries its hue, glyph kept', () => {
 });
 test('color on: ctx ≥100k row is red; asks are bright-yellow', () => {
     const out = renderFrame(state({ cursor: -1 }), SIZE, ON);
-    assert.ok(out.includes(`${ESC}31m120k`), 'ctx ≥100k → red');
+    // 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');
 });