@crouton-kit/crouter 0.3.20 → 0.3.21

package/dist/commands/tmux-spread.js

@@ -125,5 +125,20 @@ export const tmuxSpreadLeaf = defineLeaf({
             focused: spread.focused,
         };
     },
-    render: (r) => `<spread node window="${r['window'] ?? ''}" joined="${r['children_joined'].length}" overflow="${r['overflow'].length}" focused="${r['focused']}"/>`,
+    render: (r) => {
+        const joined = r['children_joined'] ?? [];
+        const overflow = r['overflow'] ?? [];
+        const where = r['window'] !== undefined && r['window'] !== ''
+            ? ` into window ${r['window']}${r['session'] !== undefined ? ` (session ${r['session']})` : ''}`
+            : '';
+        const lead = `Spread node${where} — ${joined.length} child pane(s) joined, ${overflow.length} overflow, ${r['focused'] === true ? 'window focused' : 'window not focused'}.`;
+        const blocks = [lead];
+        if (joined.length > 0) {
+            blocks.push(['Children joined:', ...joined.map((c) => `- ${c}`)].join('\n'));
+        }
+        if (overflow.length > 0) {
+            blocks.push(['Overflow (max_panes_per_window reached):', ...overflow.map((c) => `- ${c}`)].join('\n'));
+        }
+        return blocks.join('\n\n');
+    },
 });

package/dist/commands/view-cycle.js

@@ -117,9 +117,13 @@ export const viewCycleLeaf = defineLeaf({
         catch { /* best-effort */ }
         return { cycled: true, view: targetId, from: current };
     },
-    render: (r) => r['cycled'] === true
-        ? `<view-cycled to="${r['view']}" from="${r['from'] ?? ''}"/>`
-        : r['from'] !== undefined
-            ? `<view-cycle-noop>no other view to switch to</view-cycle-noop>`
-            : `<view-cycle-noop>this pane is not hosting a view</view-cycle-noop>`,
+    render: (r) => {
+        if (r['cycled'] === true) {
+            return `Cycled the monitor to view "${r['view']}" (from "${r['from']}").`;
+        }
+        if (r['from'] !== undefined) {
+            return `No other view to switch to — the pane is still on "${r['from']}".`;
+        }
+        return 'Nothing to cycle — this pane is not hosting a view.';
+    },
 });

package/dist/commands/view-run.js

@@ -181,11 +181,12 @@ export const viewRunLeaf = defineLeaf({
     render: (result) => {
         const hosted = result['hosted'];
         if (hosted === 'window') {
-            return `<view-opened mode="window" view="${result['view']}" window="${result['window']}" pane="${result['pane']}"/>`;
+            return `Opened view "${result['view']}" as a window monitor — window ${result['window']}, pane ${result['pane']}.`;
         }
         if (hosted === 'split') {
-            return `<view-opened mode="split" view="${result['view']}" pane="${result['pane']}"/>`;
+            return `Opened view "${result['view']}" as a split monitor — pane ${result['pane']}.`;
         }
+        // In-pane host: the terminal was held until quit; nothing to report.
         return '';
     },
 });

package/dist/core/__tests__/cascade-close.test.js

@@ -103,8 +103,9 @@ test('cascade close: middle-node close reaps EXACTLY its subtree (canceled), anc
         // ===================================================================
         const closeRes = h.cli(A, ['node', 'close', '--node', B]);
         assert.equal(closeRes.code, 0, `node close exit 0\n${closeRes.stderr}`);
-        // The CLI's own rendered report: cascade root B, exactly 4 closed, 0 spared.
-        assert.match(closeRes.stdout, new RegExp(`<closed id="${B}" count="4" spared="0"\\s*/>`), `close report names B as root, count=4, spared=0\n${closeRes.stdout}`);
+        // The CLI's own rendered report (plain markdown): cascade root B, exactly
+        // 4 closed, 0 spared (no spared clause is emitted when none were spared).
+        assert.match(closeRes.stdout, new RegExp(`^Closed ${B} and its exclusive subtree — 4 node\\(s\\) closed\\.`), `close report names B as root, count=4, spared=0\n${closeRes.stdout}`);
         // ===================================================================
         // ASSERT 1 — the A5 DELIVERABLE: the EXACT terminal status of every
         // cascade-reaped node. CURRENT behavior: status='canceled', intent=null,

package/dist/core/__tests__/context-intro.test.js

@@ -1,10 +1,8 @@
 // Tests for the <crtr-context> bearings preamble:
 //   1. Worker and orchestrator bearings carry the `## References` block
-//      (substrate reference docs + node-local docs as `###` sub-sections) in
-//      place of the removed `<memory>` block — no `label · dir` stanzas, no
-//      `(empty)` markers, no MEMORY.md index inlining. Orchestrators add the
-//      across-cycles framing; promotion delivers that same orchestrator
-//      context-dir framing to a node that spawned base.
+//      (substrate reference docs + node-local docs as `###` sub-sections).
+//      Orchestrators add the across-cycles framing; promotion delivers that
+//      same orchestrator context-dir framing to a node that spawned base.
 //   2. canvas-context-intro injects the block as its own session message at
 //      session_start (before the first prompt), idempotent across resumes.
 //
@@ -36,53 +34,51 @@ after(() => {
     delete process.env['CRTR_HOME'];
     delete process.env['CRTR_NODE_ID'];
 });
-test('worker bearings: base framing + ## References block (no <memory>, no label·dir stanzas), NO across-cycles framing', () => {
-    // Bug-regression: review finding M1 — buildContextBearings was changed from
-    // buildMemoryBlock (<memory> + label·dir per-store stanzas) to
-    // renderReferencesBlock (## References + ### <name> sub-sections). This test
-    // locks in the new contract.
+test('worker bearings: base framing + ## References block, NO across-cycles framing', () => {
+    // Bug-regression: review finding M1 — buildContextBearings renders the
+    // ## References block (renderReferencesBlock): ## References + ### <name>
+    // sub-sections. This test locks in that contract.
     const meta = spawnNode({ kind: 'general', cwd: '/tmp/work', parent: null });
     // Seed a node-local substrate doc so the ## References block is non-empty.
     const dir = memoryDir(meta.node_id);
     mkdirSync(dir, { recursive: true });
-    writeFileSync(join(dir, 'test-ref.md'), '---\nkind: reference\nwhen: when testing\nwhy: regression fixture\nsystem-prompt-visibility: preview\n---\nTest body.\n');
+    writeFileSync(join(dir, 'test-ref.md'), '---\nkind: reference\nwhen-and-why-to-read: When testing, this reference should be read because it is a regression fixture\nsystem-prompt-visibility: preview\n---\nTest body.\n');
     const block = buildContextIntro(meta.node_id);
     assert.match(block, new RegExp(`<crtr-context dir="${contextDir(meta.node_id)}">`));
     assert.match(block, /shared document store, not a task tracker/, 'base = shared docs, not tasks');
-    // New contract: NO <memory> block — replaced by ## References.
+    // Reference content renders ONLY as ## References + ### sub-sections.
     assert.doesNotMatch(block, /<memory>/, 'no <memory> block');
-    // New contract: NO label·dir stanza headers (the removed per-store format).
+    // Per-store stanza headers (label · dir) never appear.
     assert.doesNotMatch(block, /user-global · /, 'no user-global label·dir stanza');
     assert.doesNotMatch(block, /node-local · /, 'no node-local label·dir stanza');
-    // New contract: NO (empty) placeholder (the removed empty-store marker).
+    // No (empty) placeholder marker.
     assert.doesNotMatch(block, /\(empty\)/, 'no (empty) placeholder');
-    // Reference content renders as ## References + ### sub-sections — no other shape.
     assert.match(block, /## References\n\n###/, '## References followed by ### sub-sections');
     // A terminal worker must NOT carry the orchestrator across-cycles framing.
     assert.doesNotMatch(block, /refresh cycles/, 'no across-cycles framing for a terminal worker');
     assert.match(block, /<\/crtr-context>/);
 });
-test('orchestrator bearings: across-cycles framing + node-local substrate docs ride into ## References; the MEMORY.md index never renders', () => {
-    // Bug-regression: review finding M1 — buildContextBearings replaced the old
-    // <memory> pointer-line block with ## References. Node-local substrate docs
-    // render as ### sub-sections at their rung; the old index file never surfaces.
+test('orchestrator bearings: across-cycles framing + node-local substrate docs ride into ## References; a non-substrate .md file is never inlined', () => {
+    // Bug-regression: review finding M1 — buildContextBearings renders ## References.
+    // Node-local substrate docs render as ### sub-sections at their rung; a
+    // non-substrate .md file (no frontmatter `kind`) never surfaces.
     const meta = spawnNode({ kind: 'general', cwd: '/tmp/work', parent: null });
     promote(meta.node_id); // flip to orchestrator mode — the across-cycles gate
     const dir = memoryDir(meta.node_id);
     mkdirSync(dir, { recursive: true });
-    // Write a MEMORY.md file to verify it is never surfaced in the block.
+    // Write a non-substrate MEMORY.md file to verify it is never surfaced in the block.
     const legacyIndexPath = join(dir, 'MEMORY.md');
     writeFileSync(legacyIndexPath, '# memory index — one pointer line per memory; how-to in "Your long-term memory".\n\n- [Flaky build](flaky-build.md) — first run fails\n');
     // A node-local substrate doc DOES ride into ## References at its rung.
-    writeFileSync(join(dir, 'flaky-build.md'), '---\nkind: reference\nwhen: when the build flakes\nwhy: first run fails\nsystem-prompt-visibility: preview\n---\nFirst run always fails; rerun once.\n');
+    writeFileSync(join(dir, 'flaky-build.md'), '---\nkind: reference\nwhen-and-why-to-read: When the build flakes, this reference should be read because the first run fails\nsystem-prompt-visibility: preview\n---\nFirst run always fails; rerun once.\n');
     const block = buildContextIntro(meta.node_id);
     assert.match(block, /shared document store, not a task tracker/, 'still carries the base framing');
     assert.match(block, /refresh cycles/, 'orchestrator gets the across-cycles framing');
     assert.doesNotMatch(block, /<memory>/, 'no <memory> block');
     assert.match(block, /## References\n/, 'references block present');
     assert.match(block, /### flaky-build\n/, 'node-local doc gets its ### sub-section');
-    assert.match(block, /when the build flakes, read this reference\. first run fails\./, 'preview rung renders the routing line');
-    // The index file itself never renders: no header comment, no pointer line, no path.
+    assert.match(block, /When the build flakes, this reference should be read because the first run fails\./, 'preview rung renders the routing line');
+    // The non-substrate file never renders: no header line, no pointer line, no path.
     assert.ok(!block.includes('# memory index'), 'the index header comment is NOT inlined');
     assert.ok(!block.includes('- [Flaky build](flaky-build.md)'), 'index pointer lines are NOT inlined');
     assert.ok(!block.includes(legacyIndexPath), 'no absolute index (MEMORY.md) path');
@@ -90,9 +86,9 @@ test('orchestrator bearings: across-cycles framing + node-local substrate docs r
     assert.match(block, /<\/crtr-context>/);
 });
 test('orchestrator bearings: no per-store stanzas or (empty) markers; a rung-none node-local doc still surfaces as a ### title stub', () => {
-    // Bug-regression: review findings M1 + M6 — the three-store `label · dir`
-    // stanzas and (empty) markers are gone, and node-local docs are NOT filtered
-    // on rung: a migrated node-local reference defaults
+    // Bug-regression: review findings M1 + M6 — the ## References block carries no
+    // per-store `label · dir` stanzas or (empty) markers, and node-local docs are
+    // NOT filtered on rung: a migrated node-local reference defaults
     // system-prompt-visibility: none and must still ride into ## References as
     // its bare title (never its body).
     const meta = spawnNode({ kind: 'general', cwd: '/tmp/work', parent: null });
@@ -101,7 +97,7 @@ test('orchestrator bearings: no per-store stanzas or (empty) markers; a rung-non
     mkdirSync(dir, { recursive: true });
     writeFileSync(join(dir, 'rung-none-fact.md'), '---\nkind: reference\n---\nbody that must not render at the none rung\n');
     const block = buildContextIntro(meta.node_id);
-    // No per-store stanza headers, no (empty) markers, no index paths.
+    // No per-store stanza headers, no (empty) markers, no MEMORY.md paths.
     assert.ok(!block.includes(`node-local · ${memoryDir(meta.node_id)}`), 'no node-local stanza header');
     assert.ok(!block.includes('user-global · '), 'no user-global stanza header');
     assert.ok(!block.includes('project · '), 'no project stanza header');

package/dist/core/__tests__/detach-focus.test.js

@@ -109,7 +109,7 @@ test('node demote --detach on a FOCUSED node: flips terminal, relocates the pane
         //     breaks the pane back into h.session.
         const res = h.cli(B, ['node', 'demote', '--node', B, '--pane', bPane, '--detach']);
         assert.equal(res.code, 0, `node demote --detach exit 0\n${res.stderr}`);
-        assert.match(res.stdout, /detached="true"/, `the agent was detached\n${res.stdout}`);
+        assert.match(res.stdout, /relocated to the background/, `the agent was detached\n${res.stdout}`);
         closeDb();
         const b = getNode(B);
         // (a) lifecycle flipped to terminal IN PLACE.
@@ -180,7 +180,7 @@ test('node demote --detach on a NON-GENERATING focused node: RELEASES to dormant
         // --- Drive the REAL verb on the non-generating focused node.
         const res = h.cli(B, ['node', 'demote', '--node', B, '--pane', bPane, '--detach']);
         assert.equal(res.code, 0, `node demote --detach exit 0\n${res.stderr}`);
-        assert.match(res.stdout, /detached="true"/, `the agent was detached\n${res.stdout}`);
+        assert.match(res.stdout, /relocated to the background/, `the agent was detached\n${res.stdout}`);
         closeDb();
         const b = getNode(B);
         // (b) RELEASED to dormant — idle + intent='idle-release' (revivable via inbox

package/dist/core/__tests__/live-mutation-verbs.test.js

@@ -66,7 +66,7 @@ test('node demote flips lifecycle→terminal IN PLACE; node recycle is FINISH+RE
         //     untouched, NOT finalized.
         const dem = h.cli(B, ['node', 'demote', '--node', B]);
         assert.equal(dem.code, 0, `node demote exit 0\n${dem.stderr}`);
-        assert.match(dem.stdout, /<demoted /, `demote rendered\n${dem.stdout}`);
+        assert.match(dem.stdout, /^Demoted /, `demote rendered\n${dem.stdout}`);
         {
             const b = h.node(B);
             assert.equal(b.lifecycle, 'terminal', 'demote flips lifecycle→terminal IN PLACE');
@@ -83,10 +83,10 @@ test('node demote flips lifecycle→terminal IN PLACE; node recycle is FINISH+RE
         // RECYCLE via the real verb (TMUX_PANE is scrubbed from child env → pass --pane).
         const res = h.cli(B, ['node', 'recycle', '--node', B, '--pane', pane]);
         assert.equal(res.code, 0, `recycle exit 0\n${res.stderr}`);
-        // The leaf renders `<recycled ... finalized=".." new_root=".."/>` (not JSON).
-        assert.match(res.stdout, /<recycled /, `recycle recycled the pane\n${res.stdout}`);
-        const newRoot = /new_root="([^"]+)"/.exec(res.stdout)?.[1];
-        const finalized = /finalized="true"/.test(res.stdout);
+        // The leaf renders plain markdown: a lead sentence + `- finalized:` / `- new root:` bullets.
+        assert.match(res.stdout, /^Recycled the pane /, `recycle recycled the pane\n${res.stdout}`);
+        const newRoot = /- new root: (\S+)/.exec(res.stdout)?.[1];
+        const finalized = /- finalized: true/.test(res.stdout);
         // The recycled node is FINISHED, not mode-flipped.
         {
             const b = h.node(B);

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

@@ -29,7 +29,7 @@ after(() => {
     delete process.env['CRTR_HOME'];
 });
 // ---------------------------------------------------------------------------
-// Kernel + guidance: substrate flow, not MEMORY.md
+// Kernel + guidance: the document substrate flow
 // ---------------------------------------------------------------------------
 test('the orchestration kernel names the three stores and the substrate commands', () => {
     const kernel = loadKernel();
@@ -41,7 +41,7 @@ test('the orchestration kernel names the three stores and the substrate commands
     assert.ok(kernel.includes('crtr memory list'), 'kernel mentions crtr memory list');
     assert.ok(kernel.includes('crtr memory find'), 'kernel mentions crtr memory find');
     assert.ok(kernel.includes('crtr memory read'), 'kernel mentions crtr memory read');
-    // The old MEMORY.md pointer-line flow must NOT be present.
+    // It teaches the substrate flow only — no MEMORY.md pointer-line index.
     assert.ok(!kernel.includes('MEMORY.md'), 'kernel does not mention MEMORY.md');
     assert.ok(!kernel.includes('pointer line'), 'kernel does not teach the pointer-line flow');
 });
@@ -55,6 +55,6 @@ test('promotion guidance references the three stores; no <memory> block', () =>
     for (const store of ['user-global', 'project', 'node-local']) {
         assert.ok(guidance.includes(store), `guidance names the ${store} store`);
     }
-    // The old <memory> block reference must NOT be present in guidance.
-    assert.ok(!guidance.includes('<memory>'), 'guidance does not point at the removed <memory> block');
+    // The guidance points at the substrate flow, not a <memory> block.
+    assert.ok(!guidance.includes('<memory>'), 'guidance does not point at a <memory> block');
 });

package/dist/core/__tests__/subscription-delivery.test.js

@@ -79,10 +79,10 @@ test('multi-level subscription delivery: active subscriber WOKEN vs passive subs
         {
             const passiveRes = h.cli(P, ['node', 'subscribe', T, '--passive']);
             assert.equal(passiveRes.code, 0, `P→T passive subscribe exit 0\n${passiveRes.stderr}`);
-            assert.match(passiveRes.stdout, /mode="passive"/, 'P→T wired PASSIVE');
+            assert.match(passiveRes.stdout, /\(passive\)/, 'P→T wired PASSIVE');
             const activeRes = h.cli(P, ['node', 'subscribe', K]);
             assert.equal(activeRes.code, 0, `P→K active subscribe exit 0\n${activeRes.stderr}`);
-            assert.match(activeRes.stdout, /mode="active"/, 'P→K wired ACTIVE');
+            assert.match(activeRes.stdout, /\(active\)/, 'P→K wired ACTIVE');
         }
         // T now has BOTH an active (B) and a passive (P) subscriber — the crux.
         assert.deepEqual(edgeSet(h.subscribers(T)), new Set([`${B}:active`, `${P}:passive`]), 'T has B(active) + P(passive) as subscribers — the same-target split');
@@ -103,7 +103,7 @@ test('multi-level subscription delivery: active subscriber WOKEN vs passive subs
         {
             const res = h.cli(X, ['node', 'subscribe', K, '--passive']);
             assert.equal(res.code, 0, `X→K passive subscribe exit 0\n${res.stderr}`);
-            assert.match(res.stdout, /mode="passive"/, 'X→K wired PASSIVE-only (its ONLY subscription)');
+            assert.match(res.stdout, /\(passive\)/, 'X→K wired PASSIVE-only (its ONLY subscription)');
         }
         assert.deepEqual(edgeSet(h.subscriptions(X)), new Set([`${K}:passive`]), 'X holds exactly one tie: K(passive) — no active live subscription');
         const injBeforeStall = h.injected(X).length;

package/dist/core/bootstrap.js

@@ -30,36 +30,40 @@ const BOOT_SKILL_MARKER_PREFIX = '<!-- crtr-boot-skill v';
 function bootSkillBody() {
     return `---
 name: crtr-skills
-description: 'Capture, list, search, and load skills via the crtr CLI. Skills 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 skill. Triggers: "save", "remember", "build context for", "what skills do we have", "skill for X".'
+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 — skill router
+# /crtr-skills — crtr memory router
 
-Skills = durable agent memory. Written for **future LLM sessions**, not the
-user. \`crtr skill\` is the index — discoverable via list/search/grep.
+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 skill create $ARGUMENTS\` → pick template (primer/playbook/freeform)
-  → \`crtr skill template <type> $ARGUMENTS\` for the full workflow. Follow it
-  directly.
-- **Find** ("what do we have on X"): \`crtr skill search "$ARGUMENTS"\` →
-  \`crtr skill show <name>\` on the best hit.
-- **Load by name**: \`crtr skill show <name>\`.
-- **List all**: \`crtr skill list\`.
-- **Anything else**: \`crtr skill\` (no args) prints the full workflow guide.
+  \`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.
-- Don't load \`create\` and \`template\` outputs in the same turn (progressive
-  disclosure). \`create\` decides type; \`template\` returns the workflow.
+- 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.
 `;
 }

package/dist/core/help.d.ts

@@ -94,7 +94,7 @@ export interface RootEntry {
     useWhen: string;
     /** Optional bounded block this subtree contributes to its <name> block at
      *  root. Returns a complete self-named state element (build it with
-     *  stateBlock), e.g. `<skills count="42">…</skills>`. Aggregate, never an
+     *  stateBlock), e.g. `<kinds count="7">…</kinds>`. Aggregate, never an
      *  unbounded enumeration on a cold path. Soft-fails to omission on
      *  null/throw. */
     dynamicState?: () => string | null;
@@ -141,7 +141,7 @@ export interface BranchHelp {
      *  child's purpose lives in its own listing row). */
     model?: string;
     /** Bounded runtime aggregate as a complete self-named state element (build
-     *  it with stateBlock), e.g. `<skills count="42">…</skills>`. Renderer
+     *  it with stateBlock), e.g. `<kinds count="7">…</kinds>`. Renderer
      *  soft-fails to omission if this returns null or throws. */
     dynamicState?: () => string | null;
     /** Parent-level listing assembled by defineBranch from the actual child defs.

package/dist/core/help.js

@@ -105,7 +105,7 @@ export function renderRoot(h) {
         for (const l of rootSubcommandLines(c))
             lines.push(l);
         // dynamicState returns a complete self-named element (e.g.
-        // <skills count="42">…</skills>) — emit it as-is, nested in the command.
+        // <kinds count="7">…</kinds>) — emit it as-is, nested in the command.
         const state = evalDynamic(c.dynamicState);
         if (state !== null)
             lines.push(state);

package/dist/core/render.d.ts

@@ -1,9 +1,10 @@
 import type { LeafHelp } from './help.js';
 import type { ErrorPayload } from './io.js';
-/** Schema-driven fallback: turn a result object into agent-ready XML+markdown.
+/** Schema-driven fallback: turn a result object into agent-ready plain markdown.
  *  Field order follows the leaf's declared output schema; any extra keys append
- *  after. Scalars become attributes or a bullet list, prose and collections
- *  become their own fenced blocks. */
+ *  after. Scalars (and nested objects) list as `- name: value` bullets, prose
+ *  fields render as paragraphs, and arrays become a count lead-in plus a table
+ *  or bullets. No root tag — the result is read as a continuation of the prompt. */
 export declare function renderResult(result: Record<string, unknown>, help: LeafHelp): string;
 /** Render a structured failure as an instruction-shaped block: what broke, what
  *  was received, and the recovery road sign — the same recovery info the JSON

package/dist/core/render.js

@@ -1,14 +1,18 @@
 // Default stdout rendering: the result a leaf returns is written FOR the model
 // to act on, not as data to parse. Output is a continuation of the agent's
-// prompt — light XML fences around markdown, prose where prose belongs. The
-// raw JSON object is still available behind the `--json` global for tooling.
+// prompt — PLAIN MARKDOWN, no XML wrapper. Scalars list as `- name: value`
+// bullets in output-schema order, prose fields render as paragraphs, and arrays
+// become a count lead-in plus a markdown table (objects) or bullets (scalars).
+// The raw JSON object is still available behind the `--json` global for tooling.
 //
 // A leaf may hand `defineLeaf` a bespoke `render(result)` for instruction-shaped
-// output (see `node new`, `push`, `feed read`). Everything else falls through to
-// the schema-driven generic renderer here, so every command obeys the paradigm
-// without a hand-written renderer.
+// output that leads with the outcome (see `node new`, `push`, `feed read`).
+// Everything else falls through to the schema-driven generic renderer here, so
+// every command obeys the markdown paradigm without a hand-written renderer.
+// `renderError` is the one sanctioned exception: a failure is a different domain
+// from a result, so it keeps its `<error>` block.
 // Field names whose value is prose the agent reads, not a scalar it keys on —
-// these always render as their own fenced block, never as a tag attribute.
+// these always render as their own paragraph, never as a `- name: value` bullet.
 const PROSE_FIELDS = new Set([
     'follow_up', 'digest', 'message', 'next', 'result', 'content', 'body', 'guide',
     'summary', 'note', 'reason', 'detail', 'details', 'hint', 'instruction',
@@ -37,20 +41,17 @@ function isProse(name, v) {
         return true;
     return v.includes('\n') || v.length > 80;
 }
-/** Short, space-free scalars ride as attributes on the open tag (ids, statuses,
- *  counts); everything else that isn't prose lists as a markdown bullet. */
-function isAttr(v) {
-    if (typeof v === 'number' || typeof v === 'boolean')
-        return true;
-    return typeof v === 'string' && v.length <= 40 && !v.includes(' ') && !v.includes('\n');
-}
-/** Root element name = the command path with spaces hyphenated. */
-function rootTag(help) {
-    return help.name.trim().split(/\s+/).join('-').replace(/[^a-zA-Z0-9_-]/g, '') || 'result';
+/** Keep a value safe inside a markdown table cell: pipes would split columns,
+ *  newlines would break the row. */
+function cellEsc(v) {
+    return scalarStr(v).replace(/\|/g, '\\|').replace(/\n/g, ' ');
 }
+/** An array renders as a count lead-in followed by the collection: a markdown
+ *  table when every element is an object, plain bullets otherwise. */
 function renderArray(name, arr) {
     if (arr.length === 0)
-        return `<${name} count="0"></${name}>`;
+        return `0 ${name}.`;
+    const lead = `${arr.length} ${name}:`;
     const allObjects = arr.every((x) => x !== null && typeof x === 'object' && !Array.isArray(x));
     if (allObjects) {
         const rows = arr;
@@ -61,55 +62,51 @@ function renderArray(name, arr) {
                     cols.push(k);
         const head = `| ${cols.join(' | ')} |`;
         const sep = `| ${cols.map(() => '---').join(' | ')} |`;
-        const body = rows.map((r) => `| ${cols.map((c) => scalarStr(r[c])).join(' | ')} |`).join('\n');
-        return `<${name} count="${arr.length}">\n${head}\n${sep}\n${body}\n</${name}>`;
+        const body = rows.map((r) => `| ${cols.map((c) => cellEsc(r[c])).join(' | ')} |`).join('\n');
+        return `${lead}\n\n${head}\n${sep}\n${body}`;
     }
     const items = arr.map((x) => `- ${scalarStr(x)}`).join('\n');
-    return `<${name} count="${arr.length}">\n${items}\n</${name}>`;
+    return `${lead}\n${items}`;
 }
-/** Schema-driven fallback: turn a result object into agent-ready XML+markdown.
+/** Schema-driven fallback: turn a result object into agent-ready plain markdown.
  *  Field order follows the leaf's declared output schema; any extra keys append
- *  after. Scalars become attributes or a bullet list, prose and collections
- *  become their own fenced blocks. */
+ *  after. Scalars (and nested objects) list as `- name: value` bullets, prose
+ *  fields render as paragraphs, and arrays become a count lead-in plus a table
+ *  or bullets. No root tag — the result is read as a continuation of the prompt. */
 export function renderResult(result, help) {
     const order = help.output.map((f) => f.name);
     for (const k of Object.keys(result))
         if (!order.includes(k))
             order.push(k);
-    const attrs = [];
     const bullets = [];
-    const blocks = [];
+    const proseFields = [];
+    const arrays = [];
     for (const name of order) {
         const v = result[name];
         if (v === undefined || v === null)
             continue;
         if (Array.isArray(v)) {
-            blocks.push(renderArray(name, v));
-            continue;
-        }
-        if (typeof v === 'object') {
-            blocks.push(`<${name}>\n${JSON.stringify(v, null, 2)}\n</${name}>`);
+            arrays.push(renderArray(name, v));
             continue;
         }
         if (isProse(name, v)) {
-            blocks.push(`<${name}>\n${v}\n</${name}>`);
-            continue;
-        }
-        if (isAttr(v)) {
-            attrs.push(`${name}="${attrEsc(v)}"`);
+            proseFields.push({ name, text: v });
             continue;
         }
+        // Scalars and nested objects alike list as a bullet (objects via compact JSON).
         bullets.push(`- ${name}: ${scalarStr(v)}`);
     }
-    const tag = rootTag(help);
-    const open = attrs.length > 0 ? `<${tag} ${attrs.join(' ')}>` : `<${tag}>`;
     const parts = [];
     if (bullets.length > 0)
         parts.push(bullets.join('\n'));
-    if (blocks.length > 0)
-        parts.push(blocks.join('\n\n'));
-    const inner = parts.join('\n\n');
-    return inner !== '' ? `${open}\n${inner}\n</${tag}>` : `${open}</${tag}>`;
+    // Label prose only when more than one block would otherwise blur together.
+    const labelProse = proseFields.length > 1;
+    for (const { name, text } of proseFields) {
+        parts.push(labelProse ? `**${name}:** ${text}` : text);
+    }
+    for (const block of arrays)
+        parts.push(block);
+    return parts.join('\n\n');
 }
 /** Render a structured failure as an instruction-shaped block: what broke, what
  *  was received, and the recovery road sign — the same recovery info the JSON

package/dist/core/resolver.js

@@ -403,7 +403,7 @@ function formatNotFoundMessage(rawName, skillName, pluginQualifier) {
         lines.push(`       did you mean: ${formatted.join(', ')}`);
     }
     else {
-        lines.push('       run `crtr skill find list` or `crtr skill find search <query>` to discover skills');
+        lines.push('       run `crtr memory list` or `crtr memory find "<query>"` to discover skills');
     }
     return lines.join('\n');
 }

package/dist/core/runtime/bearings.d.ts

@@ -56,6 +56,6 @@ export declare function buildWakeBearings(origin: WakeOrigin): string;
  *  any copied-in persona) followed by the `<crtr-context>` bearings block. Base
  *  framing rides for EVERY node; the across-cycles context-dir note is added
  *  ONLY for an orchestrator (by mode) — the one node whose dir a future cycle
- *  resumes from. The `## References` block (substrate reference docs +
- *  node-local docs) replaces the old `<memory>` block. */
+ *  resumes from. The `## References` block carries the substrate reference docs
+ *  + node-local docs. */
 export declare function buildContextBearings(nodeId: string): string;

package/dist/core/runtime/bearings.js

@@ -145,8 +145,8 @@ export function buildWakeBearings(origin) {
  *  any copied-in persona) followed by the `<crtr-context>` bearings block. Base
  *  framing rides for EVERY node; the across-cycles context-dir note is added
  *  ONLY for an orchestrator (by mode) — the one node whose dir a future cycle
- *  resumes from. The `## References` block (substrate reference docs +
- *  node-local docs) replaces the old `<memory>` block. */
+ *  resumes from. The `## References` block carries the substrate reference docs
+ *  + node-local docs. */
 export function buildContextBearings(nodeId) {
     const identity = buildIdentityAssertion(nodeId);
     const dir = contextDir(nodeId);

package/dist/core/substrate/render.d.ts

@@ -14,8 +14,7 @@ export declare function renderPreferencesSection(nodeId: string): string;
  *  drops it when ''). Holds every eligible `kind: reference` resolver doc at its
  *  `system-prompt-visibility` (reference boot default is `none`, so only
  *  author-promoted references show) PLUS the node-local memory docs (any kind),
- *  each a `###` sub-section. Replaces the old `<memory>` block. Returns '' when
- *  nothing is eligible.
+ *  each a `###` sub-section. Returns '' when nothing is eligible.
  *
  *  DEFENSIVE: each doc is rendered in its own try/catch so a single malformed
  *  doc drops only itself (with a loud stderr warning naming the offending path),