@crouton-kit/crouter 0.3.17 → 0.3.19

package/dist/pi-extensions/canvas-nav.js

@@ -18,9 +18,22 @@
 // alt+c is a tmux display-menu (not a pi key), so prefix chords (m/e/1-9/custom)
 // are tmux menu items that route through `crtr canvas chord`.
 //
-// Two selection signals, both NO_COLOR-safe:
-//   SELF row = reverse video (ESC[7m), full width — an attribute, not a color.
-//   CURSOR   = ▸ + bold on the row. Status stays on the colored dot.
+// Selection / attachment signals:
+//   CURSOR (selected)  = reverse-video bar (ESC[7m), full width — an attribute,
+//                        not a colour, so it reads under NO_COLOR.
+//   ATTACHED (watched) = a coloured background bar — a human is currently
+//                        viewing the node: a `focuses` viewport points at it
+//                        (tmux host) or ≥1 helloed viewer is connected to its
+//                        broker (job/attach.json). Running is a separate axis,
+//                        signaled by the dot glyph alone (● = engine active on
+//                        its host — which may be an unwatched backstage pane
+//                        or a paneless broker).
+//   SELF               = bold name — a quiet "you are here" marker.
+//
+// Folding is auto by default: a branch stays COLLAPSED unless its subtree holds
+// a running ('active') agent or self. h/l override that per-node and persist.
+// A ▸ caret marks an expandable (collapsed-with-kids) row — but NOT the cursor
+// row, whose reverse-video bar already sets it apart.
 //
 // ⚑K pending-asks is PER-NODE, inline on each waiting node's own row (manager,
 // reports, tree rows; self shows a trailing ⚑ line in BASE). ⤳M direct-children
@@ -33,7 +46,7 @@
 import { execFile, execFileSync } from 'node:child_process';
 import { existsSync, readFileSync } from 'node:fs';
 import { join } from 'node:path';
-import { getNode, subscribersOf, subscriptionsOf, jobDir, fullName } from '../core/canvas/index.js';
+import { getNode, subscribersOf, subscriptionsOf, jobDir, fullName, listFocuses } from '../core/canvas/index.js';
 import { readConfig } from '../core/config.js';
 // ---------------------------------------------------------------------------
 // Module-level state — persists across /reload so guards don't stack and fold
@@ -45,10 +58,13 @@ let liveTimer;
  *  exactly one key tap exists (mirrors the liveTimer double-guard). */
 let liveUnsub;
 let view = 'base';
-/** Fold state — node ids whose children are hidden in GRAPH. Survives renders
- *  AND BASE↔GRAPH toggles. Keyed by id so a topology change never corrupts it;
- *  stale ids are harmless (ignored when absent). */
-const collapsed = new Set();
+/** Manual fold OVERRIDES in GRAPH, keyed by id (so a topology change can't
+ *  corrupt them; stale ids are ignored). They override the default policy —
+ *  collapsed UNLESS the subtree holds a running ('active') agent or self (see
+ *  computeDefaultExpanded). `h` collapses → userCollapsed; `l` expands →
+ *  userExpanded. Both survive renders AND BASE↔GRAPH toggles. */
+const userCollapsed = new Set();
+const userExpanded = new Set();
 /** GRAPH cursor (a node id, not an index — indices shift as topology changes). */
 let cursorId;
 /** GRAPH viewport scroll offset (row index of the top visible row). */
@@ -69,16 +85,21 @@ const PI_MAX_WIDGET_LINES = 10;
 const VIEWPORT_FALLBACK_ROWS = 30;
 // ---------------------------------------------------------------------------
 // ANSI styling. pi renders embedded escapes in widget lines and measures width
-// ANSI-aware, so raw escapes are safe and need no pi-tui dependency. Selection
-// uses theme-agnostic ATTRIBUTES (reverse / bold), never colour alone, so it
-// reads under NO_COLOR and on any background; status uses the standard 8 colors
-// on the dot only.
+// ANSI-aware, so raw escapes are safe and need no pi-tui dependency. The cursor
+// (selected row) uses a theme-agnostic ATTRIBUTE (reverse), so it reads under
+// NO_COLOR; the attached-row tint is a background COLOUR, while the dot glyph
+// (●/○/✓/✗) carries the running signal independently, even where colour is
+// stripped.
 // ---------------------------------------------------------------------------
 const ESC = '\x1b[';
 const RESET = `${ESC}0m`;
 const BOLD = `${ESC}1m`;
 const DIM = `${ESC}2m`;
 const REVERSE = `${ESC}7m`;
+/** Dark-green background bar marking an ATTACHED node (a human is currently
+ *  watching it) — distinct from the cursor's reverse-video bar; chosen so
+ *  default-fg text stays readable. */
+const BG_ATTACHED = `${ESC}48;5;22m`;
 const GREEN = `${ESC}32m`;
 const RED = `${ESC}31m`;
 const YELLOW = `${ESC}33m`;
@@ -137,15 +158,16 @@ function truncate(s, max = fillWidth()) {
 function fillWidth() {
     return Math.max(20, Math.min((process.stdout.columns ?? 80) - 2, 180));
 }
-/** Wrap `content` in a full-width reverse-video bar. REVERSE is re-asserted
- *  after every embedded RESET so a colored cell (the status dot) doesn't punch
- *  a hole in the bar; the visible width is padded out to `width`; the line
- *  closes with a real RESET. */
-function reverseFill(content, width) {
+/** Wrap `content` in a full-width background bar opened by `open` (REVERSE for
+ *  the cursor, BG_ATTACHED for a human-watched node). `open` is re-asserted after every
+ *  embedded RESET so a coloured cell (the status dot) can't punch a hole in the
+ *  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. */
+function fillBar(content, width, open) {
     const clipped = truncate(content, width);
-    const reasserted = clipped.replace(/\x1b\[0m/g, `${RESET}${REVERSE}`);
+    const reasserted = clipped.replace(/\x1b\[0m/g, `${RESET}${open}`);
     const pad = Math.max(0, width - visibleWidth(clipped));
-    return `${REVERSE}${reasserted}${' '.repeat(pad)}${RESET}`;
+    return `${open}${reasserted}${' '.repeat(pad)}${RESET}`;
 }
 function readTelemetry(nodeId) {
     try {
@@ -168,6 +190,42 @@ function shortId(id) {
     return id.slice(0, 8);
 }
 // ---------------------------------------------------------------------------
+// Attachment — is a human currently WATCHING a node? A separate axis from
+// running (status 'active' = the engine is live on its host, which may be an
+// unwatched backstage pane or a paneless broker). Two hosts, two signals:
+//   tmux   — a `focuses` row points at the node (one cheap sqlite read per
+//            render pass; pane-existence alone is NOT the signal).
+//   broker — the broker persists its helloed-viewer count to job/attach.json
+//            on every viewer change (src/core/runtime/broker.ts). Trusted only
+//            while the node is 'active': a broker crash can leave a stale file.
+// ---------------------------------------------------------------------------
+/** Node ids currently shown in a tmux focus viewport. Built once per render. */
+function focusedNodeIds() {
+    try {
+        return new Set(listFocuses().map((f) => f.node_id));
+    }
+    catch {
+        return new Set();
+    }
+}
+/** True when a human is watching `id` right now (tmux focus or broker viewer). */
+function isAttached(id, node, focused) {
+    if (focused.has(id))
+        return true;
+    if (node?.status !== 'active')
+        return false; // stale attach.json from a crash
+    try {
+        const p = join(jobDir(id), 'attach.json');
+        if (!existsSync(p))
+            return false;
+        const rec = JSON.parse(readFileSync(p, 'utf8'));
+        return typeof rec.viewers === 'number' && rec.viewers > 0;
+    }
+    catch {
+        return false;
+    }
+}
+// ---------------------------------------------------------------------------
 // Per-node ask counts — ONE shell-out per poll. `crtr canvas attention map`
 // buckets a whole sub-DAG's pending asks by node in a single process, so the
 // timer stays cheap (< 2 s) regardless of how many nodes are visible. --json
@@ -294,21 +352,48 @@ function statusRank(id) {
 function sortedChildIds(id) {
     return convoChildIds(id).sort((a, b) => statusRank(a) - statusRank(b));
 }
+/** Default fold policy: which nodes auto-EXPAND. A node expands only when one
+ *  of its child subtrees holds a running ('active') agent or self — so the path
+ *  to any live agent (and to you) is revealed while quiescent branches stay
+ *  folded. One bottom-up O(N) pass from the ancestry root; cycle-guarded. */
+function computeDefaultExpanded(root, self) {
+    const expand = new Set();
+    const seen = new Set();
+    // Returns whether subtree(id), INCLUDING id, holds an active node or self.
+    const visit = (id) => {
+        if (seen.has(id))
+            return id === self || getNode(id)?.status === 'active';
+        seen.add(id);
+        let childRevealing = false;
+        for (const c of convoChildIds(id))
+            if (visit(c))
+                childRevealing = true;
+        if (childRevealing)
+            expand.add(id); // a descendant is worth revealing → unfold id
+        return childRevealing || id === self || getNode(id)?.status === 'active';
+    };
+    visit(root);
+    return expand;
+}
 function buildGraphModel(self) {
     const rootId = climbRoot(self);
+    const defaultExpanded = computeDefaultExpanded(rootId, self);
+    // userExpanded / userCollapsed override the auto policy; absent → policy decides.
+    const isFolded = (id) => userExpanded.has(id) ? false : userCollapsed.has(id) ? true : !defaultExpanded.has(id);
     const rows = [];
     const visited = new Set();
     const walk = (id, prefix, isRoot, isLast) => {
         if (visited.has(id)) {
             const connector = isRoot ? '' : isLast ? '└─ ' : '├─ ';
-            rows.push({ id, hasKids: false, isSelf: id === self, branch: prefix + connector, cycle: true });
+            rows.push({ id, hasKids: false, isSelf: id === self, branch: prefix + connector, cycle: true, collapsed: false });
             return;
         }
         visited.add(id);
         const kids = sortedChildIds(id);
+        const folded = isFolded(id);
         const connector = isRoot ? '' : isLast ? '└─ ' : '├─ ';
-        rows.push({ id, hasKids: kids.length > 0, isSelf: id === self, branch: prefix + connector, cycle: false });
-        if (collapsed.has(id))
+        rows.push({ id, hasKids: kids.length > 0, isSelf: id === self, branch: prefix + connector, cycle: false, collapsed: folded });
+        if (folded)
             return; // folded — don't descend
         const childPrefix = isRoot ? '' : prefix + (isLast ? '   ' : '│  ');
         for (let i = 0; i < kids.length; i++)
@@ -317,22 +402,32 @@ function buildGraphModel(self) {
     walk(rootId, '', true, true);
     return rows;
 }
-/** Render one GRAPH row. SELF → reverse fill; CURSOR → ▸ + bold caret/name. */
-function renderGraphRow(r, isCursor) {
+/** Render one GRAPH row. CURSOR (selected) → reverse-video bar; an ATTACHED
+ *  (human-watched) node → a coloured background bar; SELF → bold name. The
+ *  cursor outranks the attached tint when both land on the same row. Running
+ *  is signaled by the dot glyph alone (● green = active engine). */
+function renderGraphRow(r, isCursor, focused) {
+    const wrap = (line, attached) => isCursor ? fillBar(line, fillWidth(), REVERSE)
+        : attached ? fillBar(line, fillWidth(), BG_ATTACHED)
+            : truncate(line);
     if (r.cycle) {
         const line = `${r.branch}  ${DIM}↺ ${shortId(r.id)}${RESET}`;
-        return r.isSelf ? reverseFill(line, fillWidth()) : truncate(line);
+        return wrap(line, false);
     }
     const node = getNode(r.id);
     const dot = coloredGlyph(node);
     const rawName = node !== null ? fullName(node) : shortId(r.id);
-    const name = isCursor ? `${BOLD}${rawName}${RESET}` : rawName;
+    const name = r.isSelf ? `${BOLD}${rawName}${RESET}` : rawName;
     const kind = `${DIM}${node?.kind ?? ''}${RESET}`;
     const tokens = `${DIM}${tokensCell(r.id)}${RESET}`;
-    const caret = isCursor ? `${BOLD}▸${RESET} ` : '  ';
-    const fold = r.hasKids && collapsed.has(r.id) ? ` ${DIM}[+${childCount(r.id)}]${RESET}` : '';
+    // ▸ marks an expandable (collapsed-with-kids) row. The cursor row gets no
+    // caret — its reverse-video bar already distinguishes it — so the triangle
+    // reads purely as "this unfolds".
+    const expandable = r.hasKids && r.collapsed;
+    const caret = !isCursor && expandable ? `${DIM}▸${RESET} ` : '  ';
+    const fold = expandable ? ` ${DIM}[+${childCount(r.id)}]${RESET}` : '';
     const line = `${r.branch}${caret}${dot} ${name} ${kind} ${tokens}${childBadge(node)}${fold}${askBadge(r.id)}`;
-    return r.isSelf ? reverseFill(line, fillWidth()) : truncate(line);
+    return wrap(line, isAttached(r.id, node, focused));
 }
 /** Total lines the GRAPH widget may emit. pi hard-caps extension widgets at
  *  MAX_WIDGET_LINES — anything past that pi truncates itself, eating our own
@@ -436,6 +531,10 @@ export function registerCanvasNav(pi) {
     // Captured from session_start; used in every subsequent render.
     let ui;
     let renderScheduled = false;
+    // Run mode captured at session_start. The nav chrome + ask-poll timer are
+    // interactive-only; a headless ('print') broker leaves this non-'tui' so the
+    // timer no-ops (no per-tick `crtr` shell-out) and no chrome is rendered.
+    let liveMode;
     // Cache config once (binds rarely change within a session; readConfig is sync
     // and never throws). prefixKey drives the non-tmux GRAPH toggle shortcut.
     let navConfig;
@@ -531,10 +630,11 @@ export function registerCanvasNav(pi) {
         }
         const end = Math.min(rows.length, scrollTop + viewportH);
         const lines = [];
+        const focused = focusedNodeIds(); // one sqlite read per render pass
         if (scrollTop > 0)
             lines.push(`${DIM}  ↑ ${scrollTop} more${RESET}`);
         for (let i = scrollTop; i < end; i++)
-            lines.push(renderGraphRow(rows[i], i === cursorIdx));
+            lines.push(renderGraphRow(rows[i], i === cursorIdx, focused));
         if (end < rows.length)
             lines.push(`${DIM}  ↓ ${rows.length - end} more${RESET}`);
         const hint = pendingConfirm !== undefined
@@ -677,8 +777,9 @@ export function registerCanvasNav(pi) {
             return { consume: true };
         }
         if (isPlain(data, 'h')) {
-            if (cur !== undefined && cur.hasKids && !collapsed.has(cur.id)) {
-                collapsed.add(cur.id);
+            if (cur !== undefined && cur.hasKids && !cur.collapsed) {
+                userCollapsed.add(cur.id);
+                userExpanded.delete(cur.id);
             }
             else {
                 const p = managerOf(cursorId ?? nodeId);
@@ -689,8 +790,9 @@ export function registerCanvasNav(pi) {
             return { consume: true };
         }
         if (isPlain(data, 'l')) {
-            if (cur !== undefined && collapsed.has(cur.id)) {
-                collapsed.delete(cur.id);
+            if (cur !== undefined && cur.collapsed && cur.hasKids) {
+                userExpanded.add(cur.id);
+                userCollapsed.delete(cur.id);
             }
             else if (cur !== undefined && cur.hasKids) {
                 const c = sortedChildIds(cur.id)[0];
@@ -797,6 +899,12 @@ export function registerCanvasNav(pi) {
     // Event handlers
     // -------------------------------------------------------------------------
     pi.on('session_start', (_event, ctx) => {
+        liveMode = ctx.mode;
+        // The nav chrome (widgets, key taps, the ask-poll timer) is interactive-only.
+        // A headless (print-mode) broker loads this extension but renders no chrome
+        // and must not poll. Under tmux ctx.mode is always 'tui' — byte-identical.
+        if (ctx.mode !== 'tui')
+            return;
         ui = ctx.ui;
         // Fresh session / hot-swap: start in BASE and clear any legacy or
         // inactive-view widgets so nothing stale bleeds through.
@@ -840,6 +948,9 @@ export function registerCanvasNav(pi) {
     if (liveTimer !== undefined)
         clearInterval(liveTimer);
     const timer = setInterval(() => {
+        // Inert in a headless ('print') broker — never shell out to `crtr` per tick.
+        if (liveMode !== 'tui')
+            return;
         try {
             const rootId = climbRoot(nodeId);
             const fresh = fetchAsksMap(rootId);

package/dist/pi-extensions/canvas-stophook.js

@@ -500,14 +500,23 @@ export function registerCanvasStophook(pi) {
             // down; the daemon watches its inbox and revives it (resume) the moment a
             // subscribed worker delivers. An 'attended' root never releases: the human
             // is its wake source, so we keep its window live and dormant.
-            if (decision.reason === 'awaiting') {
-                // AWAITING = F3. transition('release') marks it idle-released. If this
-                // node is FOCUSED its pane FREEZES in place (remain-on-exit, armed at
-                // focus time) so the daemon can respawn-pane -k it back into the SAME
-                // focus pane when a worker pushes; if UNFOCUSED its backstage pane
-                // closes (dormant) and the daemon revives it into the backstage on the
-                // inbox. Both are the same release — tmux's per-window remain-on-exit
-                // decides freeze vs close. NO manager-takeover (awaiting ≠ done).
+            if (decision.reason === 'awaiting' || decision.reason === 'scheduled') {
+                // AWAITING ≠ done (no manager-takeover). What happens next splits on
+                // whether the user is WATCHING this node:
+                //   • FOCUSED → it holds the user's viewport, so keep pi LIVE and
+                //     dormant (exactly like a resident root): do NOT release or shut
+                //     down. The in-process inbox-watcher (still alive) wakes it the
+                //     instant a worker pushes — no respawn, no frozen pane, the pane
+                //     stays interactive. When the user later focuses AWAY, placement's
+                //     retarget reclassifies it as a parked terminal viewer and releases
+                //     it then (transition 'release' + pane reaped), so the kept-alive
+                //     pi is reclaimed on focus-away, never held forever.
+                //   • UNFOCUSED → no one is watching, so holding a live pi for a window
+                //     is waste. Release it (idle + idle-release) and shut pi down; its
+                //     backstage pane closes and the daemon revives it (resume) on the
+                //     next unseen inbox entry.
+                if (focusOf(nodeId) !== null)
+                    return; // focused → stay alive, dormant
                 transition(nodeId, 'release');
                 try {
                     ctx?.shutdown?.();

package/dist/pi-extensions/canvas-view.d.ts

@@ -0,0 +1,21 @@
+interface CommandUI {
+    notify(message: string, type?: 'info' | 'warning' | 'error'): void;
+}
+interface CommandCtx {
+    mode: string;
+    ui: CommandUI;
+}
+interface PiLike {
+    registerCommand?(name: string, options: {
+        description?: string;
+        handler: (args: string, ctx: CommandCtx) => void | Promise<void>;
+    }): void;
+}
+/**
+ * Register the /view command on `pi`.
+ *
+ * Returns immediately when CRTR_NODE_ID is absent — the extension is fully
+ * inert in a non-canvas pi session.
+ */
+export declare function registerCanvasView(pi: PiLike): void;
+export default registerCanvasView;

package/dist/pi-extensions/canvas-view.js

@@ -0,0 +1,75 @@
+// canvas-view.ts — pi extension registering the /view canvas command.
+//
+//   /view          — open the view picker (`crtr view pick`) as a tmux popup:
+//     a raw-ANSI list of every available view; Enter hands off (one-way exec)
+//     to `crtr view run <id>`, which paints the full-screen view inside the
+//     same popup. Quitting the view closes the popup back to THIS pi pane.
+//   /view <name>   — skip the picker and popup `crtr view run <name>` directly.
+//
+//   Views are stateless render surfaces with NO pi session. Unlike /resume-node
+//   this command MUST NOT touch the node-focus / swap-pane / reviveNode path
+//   (spec Decision 8) — there is no pane to return to and no session to revive.
+//   The popup is fire-and-forget: it owns its own screen and closes itself when
+//   the view exits, dropping back to the pi pane on its own.
+//
+// crtr ONLY runs inside tmux (see crouter/CLAUDE.md) — there is no non-tmux
+// fallback picker. Outside tmux the command notifies and no-ops.
+//
+// INERT when CRTR_NODE_ID is absent (a plain pi session, not a canvas node).
+//
+// Plain TS-with-types — no imports from @earendil-works/* so this compiles
+// inside crouter's own tsc build without a dep on the pi packages (mirrors
+// canvas-resume.ts / canvas-nav.ts / canvas-commands.ts).
+import { execFile } from 'node:child_process';
+/** Single-quote a string for safe interpolation into a `sh -c` command line —
+ *  tmux runs the display-popup trailing string through the shell, so a view
+ *  name with spaces or quotes must be escaped. */
+function shellQuote(s) {
+    return `'${s.replace(/'/g, `'\\''`)}'`;
+}
+/**
+ * Register the /view command on `pi`.
+ *
+ * Returns immediately when CRTR_NODE_ID is absent — the extension is fully
+ * inert in a non-canvas pi session.
+ */
+export function registerCanvasView(pi) {
+    const nodeId = process.env['CRTR_NODE_ID'];
+    if (nodeId === undefined || nodeId.trim() === '')
+        return; // not a canvas node
+    if (typeof pi.registerCommand !== 'function')
+        return;
+    pi.registerCommand('view', {
+        description: 'Open a view in a popup — bare for the picker, or /view <name> to open that view directly',
+        handler: async (args, ctx) => {
+            // The popup is terminal-only — guard the run mode before opening it.
+            if (ctx.mode !== 'tui') {
+                try {
+                    ctx.ui.notify('/view needs the interactive TUI', 'warning');
+                }
+                catch { /* best-effort */ }
+                return;
+            }
+            // crtr only runs in tmux: open the view (picker, or a named view) as a
+            // popup. It owns the screen and closes itself when the view exits,
+            // dropping back to THIS pi pane — no node-focus, no return-pane.
+            // Fire-and-forget: tmux runs the trailing string through sh -c.
+            if (process.env['TMUX'] !== undefined) {
+                const name = args.trim();
+                // bare /view → the picker; /view <name> → that view directly.
+                const cmd = name === '' ? 'crtr view pick' : `crtr view run ${shellQuote(name)}`;
+                try {
+                    execFile('tmux', ['display-popup', '-E', '-w', '90%', '-h', '85%', cmd], () => { });
+                }
+                catch { /* best-effort */ }
+                return;
+            }
+            // Not in tmux → crtr is tmux-only, so there is nothing to fall back to.
+            try {
+                ctx.ui.notify('/view needs tmux', 'warning');
+            }
+            catch { /* best-effort */ }
+        },
+    });
+}
+export default registerCanvasView;

package/dist/prompts/skill.js

@@ -108,7 +108,7 @@ ${topicLine(topic)}
 - \`ls\` repo top level
 - check stack manifests
 - \`git log --oneline -15\` in this area
-- \`crtr skill find search "<topic>"\` / \`crtr skill find list\` — does a primer already exist?
+- \`crtr memory find "<topic>"\` / \`crtr memory list\` — does a primer already exist?
 
 If subsystem is small/self-evident, **stop**. Suggest a CLAUDE.md note. Primers
 are for large, complicated, or unintuitive systems only.
@@ -116,7 +116,7 @@ are for large, complicated, or unintuitive systems only.
 ## 2. Scope + name
 
 - **Scope**: \`project\` by default. \`user\` only if cross-repo.
-- **Name**: kebab-case. Confirm no collision: \`crtr skill read <name> --no-body\` (returns \`.path\`, \`.scope\`, \`.plugin\`).
+- **Name**: kebab-case. Confirm no collision: \`crtr memory read <name>\` (returns \`.path\`, \`.scope\`).
 
 ## 3. Parallel exploration
 
@@ -182,9 +182,8 @@ Domain terms, invariants, non-obvious constraints.
 Non-obvious coupling. Looks-broken-but-isn't. Past footguns.
 \`\`\`
 
-**No \`## Related\` for within-plugin siblings** — the CLI auto-appends a
-\`## Neighbors\` section on \`crtr skill read <name>\`. Add a manual \`## Related\`
-only for cross-plugin or distant refs.
+Add a \`## Related\` section only for genuinely related skills — cross-plugin
+or distant refs included; skip it when there is nothing worth pointing at.
 
 **Density rules:**
 - \`file:line\` over prose
@@ -200,9 +199,8 @@ only for cross-plugin or distant refs.
 Output is JSON; \`.content\` has the body, \`.path\` has the location:
 
 \`\`\`
-crtr skill read <name> --no-body
-crtr skill read <name>
-crtr skill find search "<keyword>"    # confirm description triggers discovery
+crtr memory read <name>
+crtr memory find "<keyword>"    # confirm description triggers discovery
 \`\`\`
 
 Sharpen description if discovery misses. Cut body if bloated.
@@ -251,7 +249,7 @@ PR over many small ones for refactors here, because review churn dominates"*
 
 - **Scope**: \`user\` for cross-project methodology. \`project\` for repo-specific.
 - **Name**: kebab-case, verb-or-noun-phrase. Not "guide-to-X".
-- Check \`crtr skill read <name> --no-body\` (returns \`.path\`, \`.scope\`, \`.plugin\`).
+- Check \`crtr memory read <name>\` (returns \`.path\`, \`.scope\`).
 
 ## 3. Scaffold
 
@@ -301,9 +299,8 @@ to read the whole thing for value, you've buried the judgment.
 - **<name>**: what it looks like; how to avoid
 \`\`\`
 
-**No \`## Related\` for within-plugin siblings** — the CLI auto-appends a
-\`## Neighbors\` section on \`crtr skill read <name>\`. Add a manual \`## Related\`
-only for cross-plugin or distant refs.
+Add a \`## Related\` section only for genuinely related skills — cross-plugin
+or distant refs included; skip it when there is nothing worth pointing at.
 
 ## 6. Progressive disclosure
 
@@ -324,9 +321,8 @@ loads supporting files only when needed.
 Output is JSON; \`.content\` has the body, \`.path\` has the location:
 
 \`\`\`
-crtr skill read <name> --no-body
-crtr skill read <name>
-crtr skill find search "<keyword>"
+crtr memory read <name>
+crtr memory find "<keyword>"
 \`\`\`
 
 ## Constraints
@@ -415,9 +411,8 @@ Or invent your own. Stay tight — no padding.
 Output is JSON; \`.content\` has the body, \`.path\` has the location:
 
 \`\`\`
-crtr skill read <name> --no-body
-crtr skill read <name>
-crtr skill find search "<keyword>"
+crtr memory read <name>
+crtr memory find "<keyword>"
 \`\`\`
 
 ## Switch templates if needed
@@ -469,7 +464,7 @@ field/flag/code values** — pull verbatim from source.
 
 - **Scope**: \`user\` for cross-project facts. \`project\` for repo-specific.
 - **Name**: noun-phrase. \`http-status-codes\` not \`learn-http-status\`.
-- Check \`crtr skill read <name> --no-body\` (returns \`.path\`, \`.scope\`, \`.plugin\`).
+- Check \`crtr memory read <name>\` (returns \`.path\`, \`.scope\`).
 
 ## 3. Scaffold
 
@@ -530,9 +525,8 @@ SKILL.md links to siblings (\`see [full-table.md](full-table.md)\`).
 Output is JSON; \`.content\` has the body, \`.path\` has the location:
 
 \`\`\`
-crtr skill read <name> --no-body
-crtr skill read <name>
-crtr skill find search "<keyword>"
+crtr memory read <name>
+crtr memory find "<keyword>"
 \`\`\`
 
 Search must surface the skill on a typical lookup query. Sharpen the
@@ -582,7 +576,7 @@ push to \\\`main\\\`, wait for green CI, click promote"* is a runbook step.
 
 - **Scope**: \`project\` for repo-specific procedures. \`user\` for cross-project.
 - **Name**: verb-phrase. \`deploy-to-prod\` not \`production-deployment-guide\`.
-- Check \`crtr skill read <name> --no-body\` (returns \`.path\`, \`.scope\`, \`.plugin\`).
+- Check \`crtr memory read <name>\` (returns \`.path\`, \`.scope\`).
 
 ## 3. Scaffold
 
@@ -637,9 +631,8 @@ crtr skill author scaffold <name> --type runbook --scope <user|project> --descri
 Output is JSON; \`.content\` has the body, \`.path\` has the location:
 
 \`\`\`
-crtr skill read <name> --no-body
-crtr skill read <name>
-crtr skill find search "<keyword>"
+crtr memory read <name>
+crtr memory find "<keyword>"
 \`\`\`
 
 Walk through the runbook mentally. Each step verifiable? Each decision

package/dist/prompts/view.d.ts

@@ -0,0 +1,7 @@
+export interface ViewScaffoldVars {
+    id: string;
+    title: string;
+    description: string;
+}
+/** Build the `view.mjs` source for a freshly scaffolded view. */
+export declare function viewScaffold(v: ViewScaffoldVars): string;