@crouton-kit/crouter 0.3.20 → 0.3.21

package/dist/builtin-memory/crouter-development/marketplaces.md

@@ -1,9 +1,7 @@
 ---
 kind: skill
-when: When a task relates to marketplaces
-why: How to author a crtr marketplace — marketplace.json index, plugin entries,
-  symlink-based install, auto-bump CI, dual-publishing. Use when creating a
-  marketplace or contributing plugins to one.
+when-and-why-to-read: When creating a crtr marketplace or contributing plugins
+  to one, this skill should be read.
 short-form: How to author a crtr marketplace — marketplace.json index, plugin
   entries, symlink-based install, auto-bump CI, dual-publishing. Use when
   creating a marketplace or contributing plugins to one.

package/dist/builtin-memory/crouter-development/personas/base-prompt.md

@@ -1,10 +1,8 @@
 ---
 kind: skill
-when: When a task relates to base prompt
-why: How to write a base persona prompt (the mode=base PERSONA.md) — the system
-  prompt for a single-window worker node. Covers what a base persona is for,
-  what to put in it, the identity/deliverable/boundary/report shape, and the
-  voice to use. Use when writing or revising a <kind>/PERSONA.md.
+when-and-why-to-read: When writing or revising a base persona prompt (a
+  <kind>/PERSONA.md, the system prompt for a single-window worker node), this
+  skill should be read.
 short-form: How to write a base persona prompt (the mode=base PERSONA.md) — the
   system prompt for a single-window worker node. Covers what a base persona is
   for, what to put in it, the identity/deliverable/boundary/report shape, and

package/dist/builtin-memory/crouter-development/personas/orchestrator-prompt.md

@@ -1,11 +1,8 @@
 ---
 kind: skill
-when: When a task relates to orchestrator prompt
-why: How to write an orchestrator persona prompt (orchestrator.md) — the system
-  prompt for a resident coordinator node. Covers the kernel-vs-kind split, what
-  belongs in the per-kind body, naming the child pipeline, the roadmapSkill
-  pointer, and the @include rule. Use when writing or revising a
-  <kind>/orchestrator.md.
+when-and-why-to-read: When writing or revising an orchestrator persona prompt (a
+  <kind>/orchestrator.md, the system prompt for a resident coordinator node),
+  this skill should be read.
 short-form: How to write an orchestrator persona prompt (orchestrator.md) — the
   system prompt for a resident coordinator node. Covers the kernel-vs-kind
   split, what belongs in the per-kind body, naming the child pipeline, the

package/dist/builtin-memory/crouter-development/personas.md

@@ -1,11 +1,7 @@
 ---
 kind: skill
-when: When a task relates to personas
-why: How to define a custom node kind (persona) for crtr — the
-  PERSONA.md/orchestrator files, the frontmatter contract (incl. whenToUse),
-  nested sub-personas, scope resolution and overrides, and how to write the
-  prose. Use when adding a new `--kind`, overriding a builtin agent, or
-  debugging persona resolution.
+when-and-why-to-read: When adding a new `--kind`, overriding a builtin agent, or
+  debugging persona resolution, this skill should be read.
 short-form: How to define a custom node kind (persona) for crtr — the
   PERSONA.md/orchestrator files, the frontmatter contract (incl. whenToUse),
   nested sub-personas, scope resolution and overrides, and how to write the

package/dist/builtin-memory/crouter-development/plugins.md

@@ -1,9 +1,7 @@
 ---
 kind: skill
-when: When a task relates to plugins
-why: How to author a crtr plugin — plugin.json manifest, directory layout,
-  scopes, install mechanics, versioning. Use when creating a new plugin,
-  packaging skills for distribution, or debugging install/resolution.
+when-and-why-to-read: When creating a crtr plugin, packaging skills for
+  distribution, or debugging install/resolution, this skill should be read.
 short-form: How to author a crtr plugin — plugin.json manifest, directory
   layout, scopes, install mechanics, versioning. Use when creating a new plugin,
   packaging skills for distribution, or debugging install/resolution.

package/dist/builtin-memory/design.md

@@ -1,9 +1,7 @@
 ---
 kind: skill
-when: When shaping a design roadmap or producing an architecture/interface design
-why: covers what a design deliverable is, the design-artifact shape, when to go
-  top-down vs bottom-up, and how to decompose a large design into composable
-  sub-designs.
+when-and-why-to-read: When shaping a design roadmap or producing an
+  architecture/interface design, this skill should be read.
 short-form: Use when shaping a design roadmap or producing an
   architecture/interface design — covers what a design deliverable is, the
   design-artifact shape, when to go top-down vs bottom-up, and how to decompose

package/dist/builtin-memory/development.md

@@ -1,8 +1,8 @@
 ---
 kind: skill
-when: When shaping or reshaping a build roadmap
-why: choosing a development style, selecting a phase skeleton, or setting exit
-  criteria for a software goal.
+when-and-why-to-read: When shaping or reshaping a build roadmap — choosing a
+  development style, selecting a phase skeleton, or setting exit criteria for a
+  software goal — this skill should be read.
 short-form: Use when shaping or reshaping a build roadmap — choosing a
   development style, selecting a phase skeleton, or setting exit criteria for a
   software goal.

package/dist/builtin-memory/planning.md

@@ -1,9 +1,8 @@
 ---
 kind: skill
-when: When shaping a planning roadmap, deciding plan structure, or fanning out
-  plan-review specialists before declaring a plan ready
-why: Use when shaping a planning roadmap, deciding plan structure, or fanning
-  out plan-review specialists before declaring a plan ready.
+when-and-why-to-read: When shaping a planning roadmap, deciding plan structure,
+  or fanning out plan-review specialists before declaring a plan ready, this
+  skill should be read.
 short-form: Use when shaping a planning roadmap, deciding plan structure, or
   fanning out plan-review specialists before declaring a plan ready.
 system-prompt-visibility: name

package/dist/builtin-memory/spec.md

@@ -1,15 +1,8 @@
 ---
 kind: skill
-when: When running a specification effort, shaping a spec roadmap, or deciding
-  how to stage design and requirements work. Covers the three-stage
-  shape→design→requirements methodology, when to delegate design to a child
-  node, the isolation principle behind the design/requirements split, and what a
-  finished spec contains
-why: Use when running a specification effort, shaping a spec roadmap, or
-  deciding how to stage design and requirements work. Covers the three-stage
-  shape→design→requirements methodology, when to delegate design to a child
-  node, the isolation principle behind the design/requirements split, and what a
-  finished spec contains.
+when-and-why-to-read: When running a specification effort, shaping a spec
+  roadmap, or deciding how to stage design and requirements work, this skill
+  should be read.
 short-form: Use when running a specification effort, shaping a spec roadmap, or
   deciding how to stage design and requirements work. Covers the three-stage
   shape→design→requirements methodology, when to delegate design to a child

package/dist/builtin-personas/orchestration-kernel.md

@@ -52,7 +52,7 @@ Separate from the roadmap (your live plan and state) you have a persistent docum
 
 **Reading.** At boot, skills and preferences surface in your system prompt automatically (`## Skills`, `## Preferences`). References surface in your `<crtr-context>` block (`## References`). To browse the full inventory: `crtr memory list`. To search by topic: `crtr memory find <query>`. To load a document by name: `crtr memory read <name>`.
 
-**Writing.** Use `crtr memory write` to create or update a document. Every document carries `kind`, `when`, and `why` in its frontmatter, plus a body. The `kind` governs which section it surfaces in at boot and how it loads:
+**Writing.** Use `crtr memory write` to create or update a document. Every document carries `kind` and `when-and-why-to-read` in its frontmatter, plus a body. `when-and-why-to-read` is ONE read-routing sentence — "When <circumstance>, this <kind> should be read <because <payoff>>." — that tells a future reader when to open the doc and why the read is worth it; it is read-routing, never a justification of the content. It becomes the preview line verbatim. The `kind` governs which section it surfaces in at boot and how it loads:
 
 - `skill` — a workflow or methodology to adopt. Surfaces by name in `## Skills`; load with `crtr memory read`.
 - `preference` — how you should work. Surfaces as a `###` routing line in `## Preferences` at boot (default `system-prompt-visibility: preview`).

package/dist/commands/human/queue.js

@@ -177,8 +177,8 @@ export const humanCancel = defineLeaf({
         return { canceled: true, job_id: jobId };
     },
     render: (r) => r['canceled'] === true
-        ? `<canceled job_id="${r['job_id']}"/>`
-        : `<cancel-noop job_id="${r['job_id']}">${r['reason'] ?? 'nothing to cancel'}</cancel-noop>`,
+        ? `Canceled human interaction ${r['job_id']} — its TUI pane is closed and subscribers were notified no answer is coming.`
+        : `Nothing to cancel for ${r['job_id']} — ${r['reason'] ?? 'nothing to cancel'}.`,
 });
 // ---------------------------------------------------------------------------
 // _run (hidden worker; not listed in branch help)

package/dist/commands/memory/__tests__/lint-schema.test.d.ts

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

package/dist/commands/memory/__tests__/lint-schema.test.js

@@ -0,0 +1,29 @@
+// Bug-regression: guards the hard cut that merged the substrate's `when`/`why`
+// frontmatter pair into the single `when-and-why-to-read` read-routing field.
+// The CTO ruling (taste/why-field-means-why-to-read) requires the migration be
+// a hard cut: an old-shape doc must FAIL at `crtr memory lint`, never be read at
+// runtime. `lintSubstrateSchema` is that enforcement seam — these lock it.
+//
+// Run: node --import tsx/esm --test src/commands/memory/__tests__/lint-schema.test.ts
+import { test } from 'node:test';
+import assert from 'node:assert/strict';
+import { lintSubstrateSchema } from '../lint.js';
+const ROUTING = 'When you are X, this reference should be read because Y';
+test('lint rejects a doc still carrying the retired `when` key', () => {
+    const err = lintSubstrateSchema({ kind: 'reference', when: 'when X' });
+    assert.ok(err !== null, 'old-shape `when` must produce a finding');
+    assert.match(err, /when-and-why-to-read/, 'the message points at the new field');
+});
+test('lint rejects a doc still carrying the retired `why` key', () => {
+    const err = lintSubstrateSchema({ kind: 'reference', why: 'because Y' });
+    assert.ok(err !== null, 'old-shape `why` must produce a finding');
+    assert.match(err, /when-and-why-to-read/, 'the message points at the new field');
+});
+test('lint rejects a substrate doc missing the merged routing field', () => {
+    const err = lintSubstrateSchema({ kind: 'reference' });
+    assert.ok(err !== null, 'a substrate doc must carry when-and-why-to-read');
+    assert.match(err, /when-and-why-to-read/);
+});
+test('lint accepts the merged new-shape frontmatter', () => {
+    assert.equal(lintSubstrateSchema({ kind: 'reference', 'when-and-why-to-read': ROUTING }), null);
+});

package/dist/commands/memory/find.js

@@ -12,8 +12,7 @@ function substrateUnit(d) {
         kind: d.kind,
         scope: d.scope,
         path: d.path,
-        when: d.when,
-        why: d.why,
+        routing: d.whenAndWhyToRead,
         shortForm: d.shortForm,
         loadBody: () => d.body,
     };
@@ -26,10 +25,9 @@ function skillUnit(s) {
         kind: 'skill',
         scope: s.scope,
         path: s.path,
-        // A skill's description plays the when+why role; keywords ride along so the
-        // ranker weighs them too. short_form surfaces the description as the hook.
-        when: [desc, keywords].filter((x) => x).join(' '),
-        why: '',
+        // A skill's description plays the read-routing role; keywords ride along so
+        // the ranker weighs them too. short_form surfaces the description as the hook.
+        routing: [desc, keywords].filter((x) => x).join(' '),
         shortForm: desc,
         loadBody: () => parseFrontmatter(readText(s.path)).body,
     };
@@ -80,12 +78,12 @@ function candidates(kindFilter) {
 export const findLeaf = defineLeaf({
     name: 'find',
     description: 'relevance search across memory documents',
-    whenToUse: 'you do not yet know which document applies and need to discover what is stored — ranks documents by relevance, weighted over name, when, why, and short-form (add --body to also weigh body text). Searches the full scope set regardless of any visibility gate. Use --grep instead when you need an exact regex or literal-string match across document bodies rather than a ranked topic match.',
+    whenToUse: 'you do not yet know which document applies and need to discover what is stored — ranks documents by relevance, weighted over name, the read-routing line, and short-form (add --body to also weigh body text). Searches the full scope set regardless of any visibility gate. Use --grep instead when you need an exact regex or literal-string match across document bodies rather than a ranked topic match.',
     help: {
         name: 'memory find',
-        summary: 'relevance search across memory documents, weighted over name/when/why/short-form (and body with --body)',
+        summary: 'relevance search across memory documents, weighted over name/routing-line/short-form (and body with --body)',
         params: [
-            { kind: 'positional', name: 'query', required: true, constraint: 'With ranked search (default): whitespace-separated terms, matched case-insensitively and weighted over name, when, why, and short-form (plus body with --body); documents matching more/stronger fields rank higher. With --grep: an ECMAScript regex applied to each document body line.' },
+            { kind: 'positional', name: 'query', required: true, constraint: 'With ranked search (default): whitespace-separated terms, matched case-insensitively and weighted over name, the read-routing line, and short-form (plus body with --body); documents matching more/stronger fields rank higher. With --grep: an ECMAScript regex applied to each document body line.' },
             { kind: 'flag', name: 'kind', type: 'enum', choices: [...MEMORY_KINDS], required: false, constraint: 'Filter to a single kind. Default: all kinds.' },
             { kind: 'flag', name: 'grep', type: 'bool', required: false, constraint: 'Treat the query as an ECMAScript regex and match it against document bodies, instead of weighted relevance ranking. Mutually exclusive with --body.' },
             { kind: 'flag', name: 'body', type: 'bool', required: false, constraint: 'Also weigh document body text in the relevance ranking (in addition to name/when/why/short-form). Ignored under --grep, which always scans bodies.' },
@@ -134,7 +132,7 @@ export const findLeaf = defineLeaf({
                 follow_up: 'Read a document in full with `crtr memory read <name>`. Drop --grep for a ranked topic search.',
             };
         }
-        // --- ranked mode: weighted relevance over name/when/why/short-form(+body) ---
+        // --- ranked mode: weighted relevance over name/routing-line/short-form(+body) ---
         const terms = query
             .toLowerCase()
             .split(/\s+/)
@@ -144,18 +142,15 @@ export const findLeaf = defineLeaf({
         const hits = [];
         for (const u of units) {
             const nameLc = u.name.toLowerCase();
-            const whenLc = u.when.toLowerCase();
-            const whyLc = u.why.toLowerCase();
+            const routingLc = u.routing.toLowerCase();
             const shortLc = u.shortForm.toLowerCase();
             const bodyLc = weighBody ? u.loadBody().toLowerCase() : null;
             let score = 0;
             for (const term of terms) {
                 if (nameLc.includes(term))
                     score += 10;
-                if (whenLc.includes(term))
+                if (routingLc.includes(term))
                     score += 5;
-                if (whyLc.includes(term))
-                    score += 4;
                 if (shortLc.includes(term))
                     score += 3;
                 if (bodyLc !== null && bodyLc.includes(term))

package/dist/commands/memory/lint.d.ts

@@ -1 +1,8 @@
+/** Schema checks for a doc living in a substrate memory dir: a memory store
+ *  holds ONLY substrate docs, so a missing/invalid `kind` is an authoring
+ *  error here (elsewhere it just means "not a substrate doc"). Rung and gate
+ *  values are checked RAW — the runtime parser silently falls back to kind
+ *  defaults / inert gates, which is exactly the silent tolerance this lint
+ *  exists to catch at authoring time. */
+export declare function lintSubstrateSchema(fm: Record<string, unknown> | null): string | null;
 export declare const lintLeaf: import("../../core/command.js").LeafDef;

package/dist/commands/memory/lint.js

@@ -24,12 +24,21 @@ const RUNG_FIELDS = ['system-prompt-visibility', 'file-read-visibility'];
  *  values are checked RAW — the runtime parser silently falls back to kind
  *  defaults / inert gates, which is exactly the silent tolerance this lint
  *  exists to catch at authoring time. */
-function lintSubstrateSchema(fm) {
+export function lintSubstrateSchema(fm) {
     if (fm === null)
         return 'missing frontmatter: a memory store doc requires `kind: skill|reference|preference`';
     if (!isDocKind(fm.kind)) {
         return `invalid kind: ${JSON.stringify(fm.kind)} (expected skill|reference|preference)`;
     }
+    // The retired `when`/`why` pair was merged into one read-routing field. The
+    // hard cut is enforced HERE: an old-shape doc must fail, never be silently
+    // read at runtime.
+    if ('when' in fm || 'why' in fm) {
+        return 'retired `when`/`why` keys: merge them into one `when-and-why-to-read` line — "When <circumstance>, this <kind> should be read <because <payoff>>."';
+    }
+    if (typeof fm['when-and-why-to-read'] !== 'string' || fm['when-and-why-to-read'].trim() === '') {
+        return 'missing `when-and-why-to-read`: one read-routing line — "When <circumstance>, this <kind> should be read <because <payoff>>."';
+    }
     for (const field of RUNG_FIELDS) {
         const v = fm[field];
         if (v !== undefined && (typeof v !== 'string' || !VALID_RUNGS.includes(v))) {

package/dist/commands/memory/shared.js

@@ -91,8 +91,7 @@ export function coerceAppliesTo(raw) {
 // first in this order; any preserved-on-update extras append after.
 const FRONTMATTER_ORDER = [
     'kind',
-    'when',
-    'why',
+    'when-and-why-to-read',
     'short-form',
     'system-prompt-visibility',
     'file-read-visibility',

package/dist/commands/memory/write.js

@@ -13,8 +13,7 @@ export const writeLeaf = defineLeaf({
         params: [
             { kind: 'positional', name: 'name', required: true, constraint: 'Path-derived identity (e.g. `topic` or `area/topic`) → memory/<name>.md at the resolved scope. Updated in place if it already exists, otherwise created.' },
             { kind: 'flag', name: 'kind', type: 'enum', choices: [...MEMORY_KINDS], required: true, constraint: 'Document kind.' },
-            { kind: 'flag', name: 'when', type: 'string', required: false, constraint: 'Frontmatter whenText — a short string describing when this document should be read.' },
-            { kind: 'flag', name: 'why', type: 'string', required: false, constraint: 'Frontmatter whyText — a short string describing why this document matters.' },
+            { kind: 'flag', name: 'when-and-why-to-read', type: 'string', required: false, constraint: 'The read-routing line, authored as ONE sentence: "When <circumstance>, this <kind> should be read <because <payoff>>." It states WHEN to read this doc and WHY the read is worth it — read-routing, NEVER a justification of why the content should be obeyed. Rendered verbatim as the preview. Required when creating.' },
             { kind: 'flag', name: 'short-form', type: 'string', required: false, constraint: 'Frontmatter short-form — a very abbreviated version of the content, the hook shown in `crtr memory list`.' },
             { kind: 'flag', name: 'system-prompt-visibility', type: 'enum', choices: [...VISIBILITY_RUNGS], required: false, constraint: 'Rung controlling how much of this document auto-loads into the system prompt / CLI help.' },
             { kind: 'flag', name: 'file-read-visibility', type: 'enum', choices: [...VISIBILITY_RUNGS], required: false, constraint: 'Rung controlling how much of this document surfaces when it is read off disk.' },
@@ -44,11 +43,10 @@ export const writeLeaf = defineLeaf({
         const { scope, memoryDir } = resolveWriteTarget(scopeArg);
         const path = memoryFilePath(memoryDir, name);
         const created = !pathExists(path);
-        // CREATE requires the two prose fields that compose the generated preview
-        // routing line — without them every preview renders the degenerate
-        // '", read this <kind>. ."'. UPDATE inherits them from the existing doc.
-        if (created && (input['when'] === undefined || input['why'] === undefined)) {
-            throw usage(`creating ${name} requires --when and --why (they compose the preview routing line "{when}, read this ${kind}. {why}.")`);
+        // CREATE requires the read-routing line that becomes the preview — without
+        // it every preview renders empty. UPDATE inherits it from the existing doc.
+        if (created && input['whenAndWhyToRead'] === undefined) {
+            throw usage(`creating ${name} requires --when-and-why-to-read: one read-routing sentence "When <circumstance>, this ${kind} should be read <because <payoff>>." (rendered verbatim as the preview).`);
         }
         // In-place update: start from the existing frontmatter (preserving fields
         // not passed this time), then overlay the provided ones. Create: start clean.
@@ -62,8 +60,7 @@ export const writeLeaf = defineLeaf({
             if (value !== undefined)
                 frontmatter[key] = value;
         };
-        setIf('when', input['when']);
-        setIf('why', input['why']);
+        setIf('when-and-why-to-read', input['whenAndWhyToRead']);
         setIf('short-form', input['shortForm']);
         setIf('system-prompt-visibility', input['systemPromptVisibility']);
         setIf('file-read-visibility', input['fileReadVisibility']);

package/dist/commands/node.js

@@ -164,7 +164,14 @@ const nodeNew = defineLeaf({
                 : childFollowUp(parent ?? process.env['CRTR_NODE_ID']),
         };
     },
-    render: (r) => `<spawned name="${r['name']}" id="${r['node_id']}" status="${r['status']}">\n${r['follow_up']}\n</spawned>`,
+    render: (r) => {
+        const win = r['window'] ? ` in window ${r['window']}` : '';
+        const lines = [`Spawned "${r['name']}" (${r['node_id']}) — ${r['status']}${win}.`];
+        if (r['session'])
+            lines.push(`- session: ${r['session']}`);
+        lines.push('', String(r['follow_up']));
+        return lines.join('\n');
+    },
 });
 // ---------------------------------------------------------------------------
 // node list — the active canvas (or a status slice)
@@ -352,9 +359,16 @@ const nodeRecycle = defineLeaf({
         const res = await recycleNode(id, pane);
         return { recycled: res.recycled, node_id: id, finalized: res.finalized, delivered: res.delivered.length, new_root: res.newRoot ?? undefined };
     },
-    render: (r) => r['recycled'] === true
-        ? `<recycled id="${r['node_id']}" finalized="${r['finalized']}" delivered="${r['delivered']}" new_root="${r['new_root'] ?? ''}"/>`
-        : `<recycle-failed id="${r['node_id'] ?? ''}">not in tmux, or no agent in this pane</recycle-failed>`,
+    render: (r) => {
+        if (r['recycled'] !== true)
+            return `Recycle failed for ${r['node_id'] ?? '?'} — not in tmux, or no agent in this pane.`;
+        const lines = [`Recycled the pane — finished ${r['node_id']}.`, `- finalized: ${r['finalized']}`];
+        if (r['finalized'] === true)
+            lines.push(`- delivered: ${r['delivered']}`);
+        if (r['new_root'])
+            lines.push(`- new root: ${r['new_root']}`);
+        return lines.join('\n');
+    },
 });
 // ---------------------------------------------------------------------------
 // node close — close a node + cascade-cancel its exclusive subtree (Alt+C → x)
@@ -398,9 +412,12 @@ const nodeClose = defineLeaf({
         const res = closeNode(id);
         return { closed: true, node_id: res.root, count: res.closed.length, closed_ids: res.closed, spared: res.spared };
     },
-    render: (r) => r['closed'] === true
-        ? `<closed id="${r['node_id']}" count="${r['count']}" spared="${r['spared']?.length ?? 0}"/>`
-        : `<close-failed/>`,
+    render: (r) => {
+        if (r['closed'] !== true)
+            return 'Close failed — no node found in this pane to close.';
+        const spared = r['spared']?.length ?? 0;
+        return `Closed ${r['node_id']} and its exclusive subtree — ${r['count']} node(s) closed${spared > 0 ? `, ${spared} spared (still managed from outside the subtree)` : ''}.`;
+    },
 });
 // ---------------------------------------------------------------------------
 // node cycle — DFS-walk the canvas one window at a time (Alt+] / Alt+[)
@@ -486,8 +503,8 @@ const nodeCycle = defineLeaf({
         return { focused: res.focused, node_id: targetId, name: target.name, from: fromId };
     },
     render: (r) => r['focused'] === true
-        ? `<cycled to="${r['node_id']}" name="${r['name'] ?? ''}" from="${r['from'] ?? ''}"/>`
-        : `<cycle-noop>no other live node to focus</cycle-noop>`,
+        ? `Cycled to "${r['name'] ?? ''}" (${r['node_id']}) — from ${r['from'] ?? '?'}.`
+        : 'No other live node to focus.',
 });
 // ---------------------------------------------------------------------------
 // node msg — direct-address any node at a wake tier (wakes a dormant target)
@@ -582,7 +599,7 @@ const nodeSubscribe = defineLeaf({
         subscribe(subscriber, publisher, !passive);
         return { subscribed: true, subscriber, publisher, mode: passive ? 'passive' : 'active' };
     },
-    render: (r) => `<subscribed subscriber="${r['subscriber']}" publisher="${r['publisher']}" mode="${r['mode']}"/>`,
+    render: (r) => `Subscribed ${r['subscriber']} → ${r['publisher']} (${r['mode']}).`,
 });
 const nodeUnsubscribe = defineLeaf({
     name: 'unsubscribe',
@@ -609,7 +626,7 @@ const nodeUnsubscribe = defineLeaf({
         unsubscribe(subscriber, publisher);
         return { unsubscribed: true, subscriber, publisher };
     },
-    render: (r) => `<unsubscribed subscriber="${r['subscriber']}" publisher="${r['publisher']}"/>`,
+    render: (r) => `Unsubscribed ${r['subscriber']} from ${r['publisher']}.`,
 });
 // ---------------------------------------------------------------------------
 // node promote — become an orchestrator (the worker→orchestrator polymorph)
@@ -728,7 +745,7 @@ const nodeDemote = defineLeaf({
         const res = setLifecycle(id, 'terminal', { pane, detach: input['detach'] === true });
         return { node_id: res.node_id, lifecycle: res.lifecycle, detached: res.detached };
     },
-    render: (r) => `<demoted node="${r['node_id']}" lifecycle="${r['lifecycle']}"${r['detached'] === true ? ' detached="true"' : ''}/>`,
+    render: (r) => `Demoted ${r['node_id']} — lifecycle now ${r['lifecycle']} (in place)${r['detached'] === true ? ', relocated to the background crtr session' : ''}.`,
 });
 // ---------------------------------------------------------------------------
 // node lifecycle — flip the lifecycle axis (terminal ↔ resident), independent
@@ -765,7 +782,7 @@ const nodeLifecycle = defineLeaf({
         const res = setLifecycle(id, value, { pane, detach: input['detach'] === true });
         return { node_id: res.node_id, lifecycle: res.lifecycle, detached: res.detached };
     },
-    render: (r) => `<lifecycle node="${r['node_id']}" set="${r['lifecycle']}"${r['detached'] === true ? ' detached="true"' : ''}/>`,
+    render: (r) => `Set ${r['node_id']} lifecycle → ${r['lifecycle']}${r['detached'] === true ? ', relocated to the background crtr session' : ''}.`,
 });
 // ---------------------------------------------------------------------------
 // node yield — refresh: discard context, revive fresh against the roadmap
@@ -908,10 +925,6 @@ function etaHint(fireAt, now) {
         return ` (~${hrs}h)`;
     return ` (~${Math.round(ms / 86_400_000)}d)`;
 }
-/** Escape a value for a rendered XML attribute (list rows carry free-text notes). */
-function xmlAttr(s) {
-    return s.replace(/&/g, '&amp;').replace(/"/g, '&quot;').replace(/</g, '&lt;').replace(/>/g, '&gt;');
-}
 // node wake at ---------------------------------------------------------------
 const nodeWakeAt = defineLeaf({
     name: 'at',
@@ -1011,7 +1024,10 @@ const nodeWakeAt = defineLeaf({
                 : `Bare self-alarm armed. You wake in a fresh window at ${fireAt}${eta}. End your turn now to go dormant; do not push final. The wake re-reads your roadmap.`;
         return { id, kind, fires_at: fireAt, recur: cadenceDisplay(recur), target, guidance };
     },
-    render: (r) => `<wake-armed id="${r['id']}" kind="${r['kind']}" fires-at="${r['fires_at']}" recur="${r['recur']}" target="${r['target']}">\n${r['guidance']}\n</wake-armed>`,
+    render: (r) => {
+        const recur = r['recur'] !== 'none' ? `, recurs ${r['recur']}` : '';
+        return `Armed ${r['kind']} wake ${r['id']} — fires ${r['fires_at']}${recur}, target ${r['target']}.\n\n${r['guidance']}`;
+    },
 });
 // node wake until ------------------------------------------------------------
 const nodeWakeUntil = defineLeaf({
@@ -1063,7 +1079,7 @@ const nodeWakeUntil = defineLeaf({
         const guidance = `Deadline armed. You wake on the first inbox message, or at ${w.fireAt}${eta} if none arrives. Now delegate / end your turn to go dormant — whichever fires first cancels the other.`;
         return { id, fires_at: w.fireAt, target: 'self', guidance };
     },
-    render: (r) => `<deadline-armed id="${r['id']}" fires-at="${r['fires_at']}" target="${r['target']}">\n${r['guidance']}\n</deadline-armed>`,
+    render: (r) => `Armed deadline ${r['id']} — fires ${r['fires_at']}, target ${r['target']}.\n\n${r['guidance']}`,
 });
 // node wake spawn -----------------------------------------------------------
 const nodeWakeSpawn = defineLeaf({
@@ -1164,7 +1180,10 @@ const nodeWakeSpawn = defineLeaf({
             : `Deferred spawn armed: a fresh ${kind} node is born at ${fireAt}${eta}. No node exists yet — inspect/cancel via \`crtr node wake list\` / \`crtr node wake cancel ${id}\`. Pick up other work or end your turn.`;
         return { id, kind, fires_at: fireAt, recur: cadenceDisplay(recur), guidance };
     },
-    render: (r) => `<spawn-deferred id="${r['id']}" kind="${r['kind']}" fires-at="${r['fires_at']}" recur="${r['recur']}">\n${r['guidance']}\n</spawn-deferred>`,
+    render: (r) => {
+        const recur = r['recur'] !== 'none' ? `, recurs ${r['recur']}` : '';
+        return `Armed deferred spawn ${r['id']} — a ${r['kind']} node, fires ${r['fires_at']}${recur}.\n\n${r['guidance']}`;
+    },
 });
 // node wake list -------------------------------------------------------------
 const nodeWakeList = defineLeaf({
@@ -1246,10 +1265,13 @@ const nodeWakeList = defineLeaf({
     },
     render: (r) => {
         const wakes = r['wakes'];
-        const rows = wakes.map((w) => `  <wake id="${w['id']}" kind="${w['kind']}" next="${w['next']}" recur="${xmlAttr(String(w['recur']))}" target="${xmlAttr(String(w['target']))}" owner="${xmlAttr(String(w['owner']))}" note="${xmlAttr(String(w['note']))}"/>`);
-        const body = rows.length > 0 ? '\n' + rows.join('\n') + '\n' : '\n';
-        return (`<wakes scope="${xmlAttr(String(r['scope']))}" count="${wakes.length}">${body}</wakes>\n` +
-            '<follow_up>Cancel one with `crtr node wake cancel <id>`. Fired one-shots are gone; a recurrence shows its NEXT fire, not past slots.</follow_up>');
+        const follow = 'Cancel one with `crtr node wake cancel <id>`. Fired one-shots are gone; a recurrence shows its NEXT fire, not past slots.';
+        if (wakes.length === 0)
+            return `No pending wakes in scope ${r['scope']}.\n\n${follow}`;
+        const cell = (v) => String(v).replace(/\|/g, '\\|').replace(/\n/g, ' ');
+        const head = '| id | kind | next | recur | target | owner | note |\n| --- | --- | --- | --- | --- | --- | --- |';
+        const rows = wakes.map((w) => `| ${cell(w['id'])} | ${cell(w['kind'])} | ${cell(w['next'])} | ${cell(w['recur'])} | ${cell(w['target'])} | ${cell(w['owner'])} | ${cell(w['note'])} |`);
+        return `${wakes.length} pending wake(s) in scope ${r['scope']}.\n\n${head}\n${rows.join('\n')}\n\n${follow}`;
     },
 });
 // node wake cancel -----------------------------------------------------------
@@ -1276,7 +1298,7 @@ const nodeWakeCancel = defineLeaf({
         cancelWake(id);
         return { id, was_pending: wasPending };
     },
-    render: (r) => `<wake-canceled id="${r['id']}" was-pending="${r['was_pending']}"/>`,
+    render: (r) => `Canceled wake ${r['id']}${r['was_pending'] === true ? '' : ' (already gone — no-op)'}.`,
 });
 // node wake (branch) ---------------------------------------------------------
 const nodeWake = defineBranch({

package/dist/commands/push.js

@@ -112,7 +112,7 @@ function makeTierLeaf(tier) {
                 : tier === 'urgent'
                     ? `Urgent report fanned to ${n} subscriber(s) — they are force-woken.`
                     : `Progress report fanned to ${n} subscriber(s).`;
-            return `<pushed tier="${tier}" status="${r['status']}" delivered="${n}">\n${line}\nreport: ${r['report_path']}\n</pushed>`;
+            return `${line}\n\n- report: ${r['report_path']}`;
         },
     });
 }
@@ -161,16 +161,16 @@ const feedReadLeaf = defineLeaf({
         const n = Array.isArray(r['entries']) ? r['entries'].length : 0;
         const rawDigest = typeof r['digest'] === 'string' ? r['digest'] : '';
         if (n > 0 && rawDigest.trim() !== '') {
-            return `<feed node="${r['node_id']}" unread="${n}">\n${rawDigest}\n</feed>`;
+            return `${n} unread pointer${n === 1 ? '' : 's'} drained from ${r['node_id']}'s inbox.\n\n${rawDigest.trim()}`;
         }
         // Empty drain has two distinct causes — say which, honestly. An inbox that
         // already holds entries was drained when the watcher woke you (the wake
         // message WAS that digest); a never-used inbox simply has nothing yet.
         const total = typeof r['inbox_total'] === 'number' ? r['inbox_total'] : 0;
-        const digest = total > 0
-            ? 'Nothing unread — but your inbox is not empty. The watcher drains your inbox to wake you, so the entries you already saw in your wake message are the same ones you would read here; that is why this is empty. Re-read the whole history (full message bodies included) with `crtr feed read --all`, or dereference the refs from the wake digest you already have.'
-            : 'Inbox empty — nothing has arrived from your subscriptions yet. Expected while workers run: a worker that has not pushed yet leaves no pointer, and it will wake you the moment it does. The wake is automatic — just continue your own work or end your turn. (Reach for `crtr feed peek` only if you suspect a worker died, not to confirm a live one.)';
-        return `<feed node="${r['node_id']}" unread="${n}">\n${digest}\n</feed>`;
+        const explanation = total > 0
+            ? 'Your inbox is not empty, though. The watcher drains your inbox to wake you, so the entries you already saw in your wake message are the same ones you would read here; that is why this is empty. Re-read the whole history (full message bodies included) with `crtr feed read --all`, or dereference the refs from the wake digest you already have.'
+            : 'Your inbox is empty — nothing has arrived from your subscriptions yet. Expected while workers run: a worker that has not pushed yet leaves no pointer, and it will wake you the moment it does. The wake is automatic — just continue your own work or end your turn. (Reach for `crtr feed peek` only if you suspect a worker died, not to confirm a live one.)';
+        return `No unread pointers for ${r['node_id']} (unread=0).\n\n${explanation}`;
     },
 });
 // ---------------------------------------------------------------------------
@@ -249,28 +249,23 @@ const feedPeekLeaf = defineLeaf({
             const tail = unread > 0
                 ? `${unread} unread report${unread === 1 ? '' : 's'} sit in your inbox — run \`crtr feed read\` to absorb ${unread === 1 ? 'it' : 'them'}.`
                 : 'If you spawned workers, they have finished and detached, or you never subscribed. Nothing will wake you.';
-            return `<peek node="${id}" subscriptions="0" unread="${unread}" verdict="empty">\nNo nodes below you. ${tail}\n</peek>`;
+            return `No nodes below you (0 subscriptions, ${unread} unread). ${tail}`;
         }
         const working = kids.filter((k) => k.status === 'active' || k.status === 'idle');
         const liveWaking = working.filter((k) => k.active); // active sub to a live node = it will wake me
         const done = kids.filter((k) => k.status === 'done' || k.status === 'canceled');
         const dead = kids.filter((k) => k.status === 'dead');
-        let verdict;
         let line;
         if (dead.length > 0) {
-            verdict = 'attention';
             line = `\u26a0 ${dead.length} below you ${dead.length === 1 ? 'is' : 'are'} dead and will NOT wake you. Inspect with \`crtr node inspect show <id>\`, then re-delegate or proceed without ${dead.length === 1 ? 'it' : 'them'}.`;
         }
         else if (liveWaking.length > 0) {
-            verdict = 'working';
             line = `Safe to yield \u2014 ${liveWaking.length} worker${liveWaking.length === 1 ? '' : 's'} running async will wake you on the next push. Nothing to do now; end your turn and chill.`;
         }
         else if (unread > 0) {
-            verdict = 'ready';
             line = `Nothing still running, but ${unread} unread report${unread === 1 ? '' : 's'} \u2014 run \`crtr feed read\` to absorb ${unread === 1 ? 'it' : 'them'}, then continue or finish.`;
         }
         else {
-            verdict = 'idle';
             line = 'Everything below you has finished and been drained \u2014 nothing is running. Continue your own work, or `crtr push final` to finish.';
         }
         const rows = kids.map((k) => {
@@ -279,10 +274,10 @@ const feedPeekLeaf = defineLeaf({
                 ? `pushed ${fmtAge(k.last_push.ts)} [${k.last_push.kind}]${k.last_push.ref !== null ? ` ref:${k.last_push.ref}` : ''}`
                 : 'no push yet';
             const glyph = STATUS_GLYPH[k.status] ?? '?';
-            return `  ${glyph} ${k.node_id}  ${k.kind}  ${k.name}${sub}  \u00b7 ${k.status} \u00b7 spawned ${fmtAge(k.spawned)} \u00b7 cyc ${k.cycles} \u00b7 ${push}`;
+            return `- ${glyph} ${k.name}${sub} (${k.node_id}) \u00b7 ${k.kind} \u00b7 ${k.status} \u00b7 spawned ${fmtAge(k.spawned)} \u00b7 cyc ${k.cycles} \u00b7 ${push}`;
         }).join('\n');
-        const attrs = `node="${id}" subscriptions="${kids.length}" working="${working.length}" done="${done.length}" dead="${dead.length}" unread="${unread}" verdict="${verdict}"`;
-        return `<peek ${attrs}>\n${line}\n\n${rows}\n</peek>`;
+        const summary = `${kids.length} node${kids.length === 1 ? '' : 's'} below you — ${working.length} working, ${done.length} done, ${dead.length} dead, ${unread} unread:`;
+        return `${line}\n\n${summary}\n${rows}`;
     },
 });
 // ---------------------------------------------------------------------------