@north-light/crouter 0.3.164 → 0.3.166

package/dist/builtin-memory/spec.md

@@ -9,12 +9,9 @@ short-form: Use when running a specification effort, shaping a spec roadmap, or
   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.
-system-prompt-visibility: name
+system-prompt-visibility: preview
 file-read-visibility: none
-gate:
-  kind:
-    imatches: '^spec($|/)'
-needs-refinement: true
+gate: {kind: spec}
 ---
 
 ## The Three Stages
@@ -25,9 +22,9 @@ A specification effort runs in exactly this order: **SHAPE** → **DESIGN** →
 
 Shape is the discovery stage — the one place this effort is genuinely interactive. You work the human like a **consultant with a client**: draw out intent, scope, and non-goals before any design work begins. The deliverable is not an artifact — it is a shared mental model sufficient to write a sharp design brief.
 
-Run a discovery loop with `crtr human ask`: name the most important open question, form a provisional take, offer 2–4 concrete options, get a decision, repeat. Two rules keep it sharp. **Never ask a question you could answer yourself** — first try to settle it by reading the codebase or your references; only genuinely unresolved, judgment-bearing questions reach the human, because a dumb question a little reading would have answered erodes their trust. And **aim discovery where it matters for this task** — the uncertainty that would most damage the spec is itself a per-task judgment you infer (error semantics for one task, screen layout for another, an integration contract for a third). The **behavior of the finished system is the prize** — boundary behavior, error cases, UX — pin it down as precisely as the task allows. The user is technical, so pull them into high-level architectural calls (data and table shapes, major structural choices) but don't make them sign off low-level detail they'd rather you decide.
+Run a discovery loop with `crtr human ask`: name the most important open question, form a provisional take, offer concrete options, get a decision, repeat. Two rules keep it sharp. **Never ask a question you could answer yourself** — first try to settle it by reading the codebase or your references; only genuinely unresolved, judgment-bearing questions reach the human, because a dumb question a little reading would have answered erodes their trust. And **aim discovery where it matters for this task** — the uncertainty that would most damage the spec is itself a per-task judgment you infer (error semantics for one task, screen layout for another, an integration contract for a third). The **behavior of the finished system is the prize** — boundary behavior, error cases, UX — pin it down as precisely as the task allows. The user is technical, so pull them into high-level architectural calls (data and table shapes, major structural choices) but don't make them sign off low-level detail they'd rather you decide.
 
-Track these turns carefully. The shape stage is done when: (1) 3–7 named components or functional areas are identified, (2) the user's intent can be restated without correction, and (3) no unresolved contradictions remain between the user's goal and the existing codebase. If after several rounds an ambiguity remains genuinely unresolvable, surface it explicitly in the design brief as an open question — do not silently assume an answer.
+Track these turns carefully. The shape stage is done when: (1) the named components or functional areas are identified, (2) the user's intent can be restated without correction, and (3) no unresolved contradictions remain between the user's goal and the existing codebase. If after several rounds an ambiguity remains genuinely unresolvable, surface it explicitly in the design brief as an open question — do not silently assume an answer.
 
 Gate: human confirms readiness to proceed to design.
 
@@ -35,7 +32,7 @@ Gate: human confirms readiness to proceed to design.
 
 Design produces the blueprint: components and their topology, end-to-end flows, files and directories affected, locked decisions, and open questions resolved. The altitude is infra/services — no function signatures, no algorithm descriptions, no implementation ordering. Design answers "what shape does this take?" — planning answers "how is it built?"
 
-Small or simple design work (one surface, clear scope, few components) can be done by a single `design`-kind child node. Large or complex design work — multi-surface features, multiple interacting subsystems, significant architectural choices — must be delegated to a **design orchestrator** (a `design`-kind node created directly with `--mode orchestrator`), which decomposes the design internally and returns a finished artifact. The trigger for spawning a design orchestrator rather than a base design node: if the design effort has more than one distinct phase or more than ~5 interacting components, use an orchestrator.
+Small or simple design work (one surface, clear scope, few components) can be done by a single `design`-kind child node. Large or complex design work — multi-surface features, multiple interacting subsystems, significant architectural choices — must be delegated to a **design orchestrator** (a `design`-kind node created directly with `--mode orchestrator`), which decomposes the design internally and returns a finished artifact. The trigger for spawning a design orchestrator rather than a base design node: if the design effort has distinct phases or interacting components that need separate design treatment, use an orchestrator.
 
 Gate: human approves the rendered design artifact.
 
@@ -61,9 +58,9 @@ The isolation is structural, not stylistic. The requirements writer receives: th
 
 After the design is approved, the spec orchestrator runs `crtr node yield` before starting requirements work. This is mandatory, not optional.
 
-Why: the design conversation fills context with reasoning about tradeoffs, rejected alternatives, and design intent. That context biases delegation — it causes the orchestrator to frame the requirements task with assumptions from the design discussion. After yielding, the orchestrator revives fresh against `context/roadmap.md`, which records the finished design artifact path. It reads the design artifact cold and delegates the requirements work from that clean window, anchored on the rendered design rather than on the design conversation.
+Why: the design conversation fills context with reasoning about tradeoffs, rejected alternatives, and design intent. That context biases delegation — it causes the orchestrator to frame the requirements task with assumptions from the design discussion. After yielding, the orchestrator revives fresh against `$CRTR_CONTEXT_DIR/roadmap.md`, which records the finished design artifact path. It reads the design artifact cold and delegates the requirements work from that clean window, anchored on the rendered design rather than on the design conversation.
 
-The roadmap must record the design artifact path and the current stage before yielding. On revive, the first action is to read `context/roadmap.md`, confirm the design is landed, and delegate requirements work.
+The roadmap must record the design artifact path and the current stage before yielding. On revive, the first action is to read `$CRTR_CONTEXT_DIR/roadmap.md`, confirm the design is landed, and delegate requirements work.
 
 ---
 
@@ -77,9 +74,9 @@ After yield-and-revive, `## Strategy / phases` plus `## Active context` must let
 
 ## Delegating Design: Base Node vs. Orchestrator
 
-Spawn a base `design` node (terminal) when: the design surface is bounded, one component or subsystem, no multi-phase structure required. The node produces `context/design.md` and `context/design.json` and returns.
+Spawn a base `design` node when the design surface is bounded: one component or subsystem with no multi-phase structure required. The child writes `design-<subject>.md` in its own context directory and reports that absolute path.
 
-Spawn a `design` orchestrator (resident) when: the feature spans multiple subsystems, has distinct implementation phases that need separate design treatment, or the design effort is itself likely to fill one context window before it's finished. Create it directly as an orchestrator — `crtr node new --kind design --mode orchestrator` — rather than spawning a base design node and counting on it to promote itself once it discovers the surface is too big; self-promotion is unreliable, and a node born an orchestrator is strictly more capable than one hoping to become one. Pass it the shape brief as its goal; it owns the decomposition and integration internally and reports a finished design artifact when done.
+Spawn a terminal `design` orchestrator when the feature spans multiple subsystems, has distinct implementation phases that need separate design treatment, or the design effort is itself likely to fill one context window before it is finished. Create it directly as an orchestrator — `crtr node new --kind design --mode orchestrator` — so it owns decomposition and integration from the start. Pass it the shape brief as its goal; it writes the integrated `design-<subject>.md` in its own context directory and reports that absolute path when done.
 
 In either case, the spec orchestrator waits for the design to land and the human to approve it before proceeding.
 

package/dist/builtin-memory/wedged-child-on-runaway-bash.md

@@ -1,34 +1,20 @@
 ---
 kind: knowledge
 when-and-why-to-read: When a node is marked wedged or remains active without progress while its inbox accumulates, this reference should be read so recovery restores progress without losing context or killing the wrong process.
-short-form: a child stuck mid-turn (runaway bash, or a stalled broker with no subprocess) is AUTO-DETECTED by the daemon (⚠ wedged + a doctrine wake) — kill the subprocess if one exists; if none, the daemon SIGTERM-kicks the broker and automatically starts a fresh recovery cycle
+short-form: A node stuck mid-turn is detected from a stale busy heartbeat plus near-zero process-tree CPU. Kill a runaway subprocess when one exists; when the broker itself is stuck, the daemon SIGTERMs it and applies bounded, conditional recovery.
 system-prompt-visibility: preview
 file-read-visibility: none
 ---
 
-A base node can wedge INDEFINITELY on a single runaway bash command (classic: `grep -rln "..." /` — a recursive grep from filesystem root that scans all of disk and never returns; also any unbounded find/scan over `/` or a network mount). The node's pi turn is blocked waiting on the bash call, so it never `push`es and never finishes.
+A base node can wedge mid-turn on a runaway bash command (for example, an unbounded recursive scan from `/`). Its pi turn cannot push or finish while the tool call is blocked.
 
-**Detection is automatic (crtrd, issue #110).** The daemon's supervision tick corroborates two signals on every live/busy node: the busy-marker heartbeat (re-touched on every tool start/stream/end and turn end) gone quiet for 20+ minutes, AND the broker's whole process tree (broker pid + every descendant) reading near-zero CPU. Only when BOTH hold does it fire — routine long tool calls that are genuinely still producing output or burning CPU never trip it. On a 'wedged' verdict the daemon records a `daemon→node`/`wedged` Fault (the local canvas graph and browse UI show ⚠ "wedged · needs you", the same surface provider-fault stalls use) and fans a doctrine wake to the node's subscribers — ONE notice per wedge episode, not a repeat every tick. In the local browse UI, the hanging-node recovery action runs `node lifecycle revive <id> --now`; there is no hanging filter on `node inspect list`.
+**Detection is automatic.** The daemon reports a wedge only after both the busy heartbeat has been quiet for 20+ minutes and the broker's whole process tree is near-zero CPU. It records a `daemon→node` `wedged` fault and sends one doctrine wake to subscribers per wedge episode. The canvas marks the node as needing attention.
 
-**Remediation branches on whether the tree has a descendant (issue #119):**
+## Recover the process that is actually stuck
 
-- **A subprocess exists (the common case)** — a runaway bash/find/grep is the likely cause. The daemon does NOT touch the engine here; you kill the subprocess yourself (see below).
-- **No subprocess exists** — the broker pid stands alone in its own tree (the engine itself stalled, e.g. mid a `model_change`, with nothing a human could kill). The daemon performs the ONLY remaining remediation itself: it SIGTERMs the broker (the same on-demand kick `node lifecycle revive --now` does). The surviving `job/busy` marker proves the process died mid-turn, so its exit-policy job starts a fresh cycle on the saved session tree. That cycle automatically receives the normal roadmap/feed/context kickoff; it does not reopen the dead turn at an idle prompt, and no manual nudge is required.
+- **A subprocess exists.** The daemon leaves the broker alone because a runaway bash/find/grep is the likely cause. Inspect the broker process tree, kill the scanner subprocess rather than its shell wrapper or node, and let the tool call return. The pi turn then resumes with its context intact. Tell the owning orchestrator if you discovered the wedge before its doctrine wake.
+- **No subprocess exists.** The broker itself is stalled. The daemon SIGTERMs it; its live-exit policy then makes a bounded recovery attempt. A broker-certified clean abort resumes the saved session with a continuation. A dirty interrupted turn, pending refresh, or pending cycle starts a new recovery cycle from the saved session instead. A broker that never established a session terminalizes rather than entering a respawn loop.
 
-**Why it used to be invisible to the orchestrator:** the wake spine only fires on a child's push/finalize/crash. A child wedged *mid-turn* does none of those — its row stays `status=active` and the dashboard shows it `●` working. Before #110, the parent got no wake at all, so an entire wave could stall for hours looking healthy; cli-verbs-B2 sat wedged ~2h14m on a `grep /` before a safety-deadline inspection caught it. The daemon-side detection above closes that gap; you should no longer need to notice a wedge by elapsed-time vibes alone — but if you do (the daemon hasn't caught up yet, or the wedge is younger than its grace window), the manual inspection below still works.
+Recovery is not unconditional. Repeated short-lived exits or a boot failure terminalize the node as `dead`; no daemon respawn follows that terminal state. Reopen it explicitly with `crtr node lifecycle revive <id>` (use `--reopen` if it finalized), or deliver an inbox wake where that is the intended control path. If the daemon is down, it cannot detect, signal, or respawn a wedge; restore the daemon before relying on lifecycle recovery.
 
-## Subprocess case: kill the runaway command
-
-**How to inspect further / confirm:** `tmux capture-pane -p -t <pane>` shows the live turn (look for `Elapsed NNNNs ⠼ Working...` on one bash command); `pgrep -P <pi_pid>` + `ps -axo pid,ppid,etime,command` reveals the runaway subprocess and how long it's run.
-
-**How to apply:** kill the runaway SUBPROCESS, not the node — `kill <grep_pid>`. The bash call then returns and the pi turn resumes on its own, no context lost, no respawn. (Killing the bash `-c` wrapper can orphan the grep; kill the actual scanner PID. A pipeline `grep / | head` resumes fastest if you kill the first-stage grep — the pipe closes and bash proceeds.) Then notify the OWNING orchestrator (deferred tier) so it steers the child to completion and knows the lost time — the doctrine wake above already does this automatically for a detected wedge, but do it yourself if you found the wedge before the daemon did. Related: the `revive-stuck-orchestrator` doc covers the orchestrator-level false-finish failure mode.
-
-## No-subprocess case: broker wedged mid-stream (`streaming:true` stuck)
-
-The wedge can outlive any subprocess, or exist with none at all. A node (including a top-level **resident orchestrator**, not just a child) can sit stuck with the canvas snapshot showing `streaming: true` and a stale `last_activity` for **days**, while the broker pid is alive but doing nothing (0% CPU) and NO subprocess exists to kill — the engine deadlocked mid-stream (often right after a bash call returned, or after a `model_change`) and never closed the turn. Tells: `job/busy` lockfile present with an old mtime, `job/telemetry.json` `updated_at` frozen, `job/broker.log` stopped growing, inbox piling up (`queued (N)` in the dashboard) because the turn never ends. The `busy` marker alone is harmless (it is always AND-ed with `pidAlive`, so a stale one from a dead pid is ignored) — do not bother deleting it.
-
-**This is now the daemon's own remediation (issue #119) — it auto-kicks the broker for you.** If it hasn't caught up yet (younger than the wedge grace, or the daemon was down), do it manually:
-
-1. `kill -TERM <broker_pid>` — the wedged broker. Confirm it dies (`ps -p <pid>`) and that no orphan subprocess lingers (`ps -o pid,ppid,command | awk '$2==<pid>'`).
-2. The **daemon auto-resumes** it within ~20s on the saved session — a fresh broker pid appears (`node inspect show`), `status=active`, `intent=null`, `view.sock` accepts connections. (No manual `node lifecycle revive` needed if the daemon is up; do it manually only if it doesn't come back.)
-3. **The daemon starts the replacement as a fresh recovery cycle** — the stale `job/busy` marker distinguishes an interrupted turn from an idle crash, so the daemon selects `resume:false`. The saved session tree remains on disk, while the new cycle re-orients from `context/roadmap.md`, feed, reports, and context automatically. Confirm success by watching `telemetry.json` `updated_at` go current and the node run tools again. A manual `--tier critical` message is now only a fallback if the replacement broker itself fails to boot or provider access is still unhealthy.
+Do not kill a healthy node merely because it has been working for a long time. The detector intentionally requires both a silent heartbeat and an idle process tree; a long-running tool that is still producing output or consuming CPU is not wedged.

package/dist/cli.js

@@ -54,7 +54,7 @@ async function main() {
     ensureProjectScope(process.argv);
     maybeAutoUpdate(process.argv);
     // Pass the one-shot unknown-first-token retry seam: on a first-token miss with
-    // absent configured-CLI stores, hydrate them once, rebuild, and re-walk (§5.1).
+    // absent HTTP-plugin stores, hydrate them once, rebuild, and re-walk.
     // A recognized core first token resolves in `resolveRoot`'s fast path and never
     // reaches a first-token miss, so the seam stays off the core fast path.
     mark('cli.dispatch_start');

package/dist/clients/attach/__tests__/attach-keybindings.test.js

@@ -1,7 +1,7 @@
 import test from 'node:test';
 import assert from 'node:assert/strict';
-import { resolveKeybindings } from '../../../core/keybindings/index.js';
-import { detachHint, inboxOpenHint, dispatchAttachBinding, matchesAttachBinding, refreshAttachBindingSnapshot, } from '../session/bindings.js';
+import { decodeAttachControlInput, encodeAttachControlInput, extractAttachControlInput, resolveKeybindings, } from '../../../core/keybindings/index.js';
+import { detachHint, inboxOpenHint, dispatchAttachAction, dispatchAttachBinding, matchesAttachBinding, refreshAttachBindingSnapshot, } from '../session/bindings.js';
 import { GraphOverlay } from '../overlays/graph.js';
 const PALETTE = {
     accent: (s) => s,
@@ -23,7 +23,7 @@ function fakeTui() {
         requestRender: () => { },
     };
 }
-test('attach input dispatches only the current configured action', () => {
+test('attach direct and private control input dispatch through the same action map', () => {
     const bindings = resolveKeybindings({
         'crtr.attach.detach': ['ctrl+x'],
         'crtr.attach.clear-or-detach': [],
@@ -33,6 +33,7 @@ test('attach input dispatches only the current configured action', () => {
         'crtr.attach.model-ladder.previous': ['alt+y'],
         'crtr.attach.command.inspect': ['alt+shift+h'],
         'crtr.attach.file-review': [],
+        'crtr.attach.profile-files': [],
     });
     const calls = [];
     const actions = {
@@ -44,6 +45,7 @@ test('attach input dispatches only the current configured action', () => {
         'crtr.attach.model-ladder.previous': () => calls.push('ladder-back'),
         'crtr.attach.command.inspect': () => calls.push('inspect'),
         'crtr.attach.file-review': () => calls.push('review'),
+        'crtr.attach.profile-files': () => calls.push('profile-files'),
     };
     assert.equal(dispatchAttachBinding(bindings, '\x18', actions), true);
     assert.equal(dispatchAttachBinding(bindings, '\x04', actions), false, 'old detach must not reach the listener action');
@@ -55,7 +57,18 @@ test('attach input dispatches only the current configured action', () => {
     assert.equal(dispatchAttachBinding(bindings, '\x1by', actions), true);
     assert.equal(dispatchAttachBinding(bindings, '\x1bM', actions), false, 'old ladder-back key must not reach the listener action');
     assert.equal(dispatchAttachBinding(bindings, '\x1b[72;4u', actions), true);
-    assert.deepEqual(calls, ['detach', 'mode', 'ladder', 'ladder-back', 'inspect']);
+    assert.equal(dispatchAttachBinding(bindings, '\x06', actions), false, 'disabled direct binding must stay disabled');
+    const privateInput = encodeAttachControlInput('crtr.attach.profile-files');
+    const privateAction = decodeAttachControlInput(privateInput);
+    assert.equal(privateAction, 'crtr.attach.profile-files');
+    dispatchAttachAction(privateAction, actions);
+    assert.deepEqual(calls, ['detach', 'mode', 'ladder', 'ladder-back', 'inspect', 'profile-files']);
+    assert.equal(decodeAttachControlInput(`${privateInput}x`), undefined, 'whole-input decoding must be exact');
+    assert.equal(decodeAttachControlInput('\x1b_crtr;crtr.attach.not-real\x1b\\'), undefined, 'unknown actions must stay ordinary input');
+    assert.deepEqual(extractAttachControlInput(`before${privateInput}after`), {
+        actionId: 'crtr.attach.profile-files',
+        remaining: 'beforeafter',
+    });
     assert.equal(detachHint(bindings), 'Ctrl+X', 'disabled clear-or-detach must fall back to enabled detach');
     const noDetach = resolveKeybindings({ 'crtr.attach.detach': [], 'crtr.attach.clear-or-detach': [] });
     assert.equal(detachHint(noDetach), undefined, 'a disabled pair must not render "Disabled to detach"');

package/dist/clients/attach/__tests__/context-message.test.js

@@ -1,35 +1,55 @@
-// Regression coverage for the attach viewer's collapsed hidden-context
-// rendering (render/context-message.ts + its dispatch in render/chat-view.ts).
-//
-// Both hidden-context custom types — `crtr-context` (fresh-birth bearings) and
-// `crtr-situational-context` (an existing node's ambient update, sent by
-// canvas-inbox-watcher.ts) — must render through the same collapsed
-// ContextMessageComponent, never the generic always-expanded
-// CustomMessageComponent: body text stays hidden until the user expands it
-// (Ctrl+O). These tests pin (a) the collapsed component itself never leaks
-// body text before expansion, for both labels it serves, and (b)
-// render/chat-view.ts's source wires the situational customType to that same
-// collapsed component (a full ChatView needs a live TUI/Container from
-// pi-tui, so this source-contract check is the smallest meaningful assertion
-// of the dispatch).
+// Regression coverage for the attach viewer's display-only folding of
+// crouter-generated context. The body must stay agent-visible and expandable,
+// while bearings, situational updates, fresh-revive kickoffs, context nudges,
+// and node inbox digests share one compact renderer by default.
 import assert from 'node:assert/strict';
 import { readFileSync } from 'node:fs';
 import { dirname, join } from 'node:path';
 import test from 'node:test';
 import { fileURLToPath } from 'node:url';
+import { UserMessageComponent } from '@earendil-works/pi-coding-agent';
+import { Container } from '@earendil-works/pi-tui';
+import { applyTheme, attachMarkdownTheme } from '../config.js';
+import { ChatView } from '../render/chat-view.js';
 import { ContextMessageComponent } from '../render/context-message.js';
+import { styleAttachMarkdownHeadings } from '../render/markdown-headings.js';
+import { CONTEXT_NUDGE_CUSTOM_TYPE, REVIVE_KICKOFF_SENTINEL, generatedContextPresentation, } from '../../../shared/generated-context.js';
 const HERE = dirname(fileURLToPath(import.meta.url));
 const CHAT_VIEW = readFileSync(join(HERE, '..', 'render/chat-view.ts'), 'utf8');
 const identity = (s) => s;
+applyTheme();
 test('collapsed by default: body text is not rendered until expanded', () => {
     const body = '<situational-context>\nthe user is mid-checkout\n</situational-context>';
     const collapsed = new ContextMessageComponent(body, false, identity, identity, 'situational context', ' hint');
-    const collapsedLines = collapsed.render(80).join('\n');
+    const collapsedRender = collapsed.render(80);
+    const collapsedLines = collapsedRender.join('\n');
+    assert.equal(collapsedRender.length, 1, 'a collapsed row has no surrounding blank line');
     assert.match(collapsedLines, /\[situational context\]/);
     assert.doesNotMatch(collapsedLines, /mid-checkout/, 'collapsed state must never leak the body');
     collapsed.setExpanded(true);
-    const expandedLines = collapsed.render(80).join('\n');
+    const expandedRender = collapsed.render(80);
+    const expandedLines = expandedRender.join('\n');
     assert.match(expandedLines, /mid-checkout/, 'expanded state (Ctrl+O) still shows the full body — the LLM-visible content is never lost, only the default view folds it');
+    const normalUserRender = new UserMessageComponent(styleAttachMarkdownHeadings(body), attachMarkdownTheme()).render(80);
+    assert.deepEqual(expandedRender.slice(0, -1), normalUserRender, 'expanded generated context uses the ordinary user-message surface');
+    assert.equal(expandedRender.at(-1), '', 'an expanded block leaves one blank line below its body');
+});
+test('generated rows add no leading spacer after prior transcript content', async () => {
+    const container = new Container();
+    const tui = { requestRender() { }, terminal: { rows: 40 } };
+    const view = new ChatView(tui, container, { toolOutputExpanded: false });
+    await view.applySnapshot({
+        messages: [
+            { role: 'assistant', content: [{ type: 'text', text: 'before' }], stopReason: 'stop' },
+            { role: 'user', content: `${REVIVE_KICKOFF_SENTINEL} — full disk bearings` },
+        ],
+        stats: {},
+        state: { isStreaming: false },
+    });
+    const lines = container.render(80).map((line) => line.replace(/\x1b\[[0-9;]*m/g, ''));
+    const generatedIndex = lines.findIndex((line) => line.includes('[crtr revive]'));
+    assert.notEqual(generatedIndex, -1);
+    assert.match(lines[generatedIndex - 1] ?? '', /before/, 'the collapsed row follows prior content directly');
 });
 test('the crtr-context label/hint keep their defaults when callers omit the new params', () => {
     const bearings = new ContextMessageComponent('some bearings body', false, identity, identity);
@@ -37,10 +57,30 @@ test('the crtr-context label/hint keep their defaults when callers omit the new
     assert.match(line, /\[crtr context\]/);
     assert.match(line, /orienting bearings/);
 });
-test('render/chat-view.ts dispatches the situational customType to the collapsed component, not the generic fallback', () => {
-    assert.match(CHAT_VIEW, /SITUATIONAL_CONTEXT_CUSTOM_TYPE/, 'must reference the constant, not a duplicated literal');
-    const situationalBranch = CHAT_VIEW.slice(CHAT_VIEW.indexOf('customType === SITUATIONAL_CONTEXT_CUSTOM_TYPE'));
-    const nextBraceClose = situationalBranch.indexOf('\n          }');
-    const branchBody = situationalBranch.slice(0, nextBraceClose === -1 ? undefined : nextBraceClose);
-    assert.match(branchBody, /new ContextMessageComponent\(/, 'must render collapsed via the same component crtr-context uses, not CustomMessageComponent');
+test('fresh-revive kickoff and both context-nudge roles classify as generated context', () => {
+    const revive = generatedContextPresentation({
+        role: 'user',
+        content: `${REVIVE_KICKOFF_SENTINEL} — full disk bearings`,
+    });
+    assert.equal(revive?.label, 'crtr revive');
+    assert.equal(revive?.summary, 'fresh context kickoff');
+    const body = '[crtr] Context ~150k. Yield when substantial work remains.';
+    const steered = generatedContextPresentation({ role: 'user', content: body });
+    const held = generatedContextPresentation({
+        role: 'custom',
+        customType: CONTEXT_NUDGE_CUSTOM_TYPE,
+        content: body,
+    });
+    assert.equal(steered?.summary, 'Context ~150k');
+    assert.equal(held?.summary, 'Context ~150k');
+    const inbox = generatedContextPresentation({
+        role: 'user',
+        content: 'From child-node-123 — 2 updates:\n  [update] still working',
+    });
+    assert.equal(inbox?.label, 'crtr inbox');
+    assert.equal(inbox?.summary, '2 updates from child-node-123');
+});
+test('render/chat-view.ts routes the shared generated-context classification through the foldable component', () => {
+    assert.match(CHAT_VIEW, /generatedContextPresentation\(message\)/);
+    assert.match(CHAT_VIEW, /new ContextMessageComponent\(/);
 });

package/dist/clients/attach/__tests__/crtr-output.test.js

@@ -1568,15 +1568,22 @@ test('node and package mutations share compact outcome-first receipts', () => {
         assert.match(collapsed, /ctrl\+o to expand/, command);
     }
 });
-const PKG_PLUGIN_INSTALL_OUTPUT = ['- name: ai', '- scope: user', '', '/Users/silas/.crouter/plugins/ai'].join('\n');
-const PKG_PLUGIN_INSTALL_SHORT_PATH_OUTPUT = ['- name: ai', '- scope: user', '- path: /a'].join('\n');
+const PKG_PLUGIN_INSTALL_OUTPUT = [
+    '- name: ai',
+    '- scope: user',
+    '- transport: exec',
+    '- commands: {"mounts":["app"],"issues":[]}',
+    '',
+    '/Users/silas/.crouter/plugins/ai',
+].join('\n');
+const PKG_PLUGIN_INSTALL_SHORT_PATH_OUTPUT = ['- name: ai', '- scope: user', '- transport: http', '- path: /a'].join('\n');
 test('a crtr pkg plugin install card collapses to an installed status + scope/path digest, not the raw fields', () => {
     const def = createCrtrBashToolDefinition({ command: 'crtr pkg plugin install ai' });
     const collapsed = def
         .renderResult({ content: [{ type: 'text', text: PKG_PLUGIN_INSTALL_OUTPUT }] }, { expanded: false }, theme, {})
         .render(140)
         .join('\n');
-    assert.match(collapsed, /<success>installed ai<\/success>/);
+    assert.match(collapsed, /<success>installed ai · exec<\/success>/);
     assert.match(collapsed, /<muted>user · \/Users\/silas\/\.crouter\/plugins\/ai<\/muted>/);
     assert.doesNotMatch(collapsed, /- name:/);
     const expanded = def
@@ -1588,33 +1595,34 @@ test('a crtr pkg plugin install card collapses to an installed status + scope/pa
         .renderResult({ content: [{ type: 'text', text: PKG_PLUGIN_INSTALL_SHORT_PATH_OUTPUT }] }, { expanded: false }, theme, {})
         .render(140)
         .join('\n');
+    assert.match(shortPath, /<success>installed ai · http<\/success>/);
     assert.match(shortPath, /<muted>user · \/a<\/muted>/);
 });
-const PKG_PLUGIN_UPDATE_UPDATED_OUTPUT = ['1 updated:', '', '| name | updated | sha |', '| --- | --- | --- |', '| ai | true | def5678 |'].join('\n');
-const PKG_PLUGIN_UPDATE_CURRENT_OUTPUT = ['1 updated:', '', '| name | updated | sha |', '| --- | --- | --- |', '| ai | false | abc1234 |'].join('\n');
+const PKG_PLUGIN_UPDATE_UPDATED_OUTPUT = ['1 updated:', '', '| name | transport | updated | sha |', '| --- | --- | --- | --- |', '| ai | http | true |  |'].join('\n');
+const PKG_PLUGIN_UPDATE_CURRENT_OUTPUT = ['1 updated:', '', '| name | transport | updated | sha |', '| --- | --- | --- | --- |', '| ai | exec | false | abc1234 |'].join('\n');
 const PKG_PLUGIN_UPDATE_MULTI_OUTPUT = [
     '3 updated:',
     '',
-    '| name | updated | sha |',
-    '| --- | --- | --- |',
-    '| ai | true | aaa1111 |',
-    '| beta | false | bbb2222 |',
-    '| gamma | true | ccc3333 |',
+    '| name | transport | updated | sha |',
+    '| --- | --- | --- | --- |',
+    '| ai | exec | true | aaa1111 |',
+    '| beta | exec | false | bbb2222 |',
+    '| gamma | http | true |  |',
 ].join('\n');
-test('a crtr pkg plugin update card collapses to an updated/current status + sha, not the raw table', () => {
+test('a crtr pkg plugin update card collapses to an updated/current transport-aware status + sha, not the raw table', () => {
     const def = createCrtrBashToolDefinition({ command: 'crtr pkg plugin update --name ai' });
     const collapsed = def
         .renderResult({ content: [{ type: 'text', text: PKG_PLUGIN_UPDATE_UPDATED_OUTPUT }] }, { expanded: false }, theme, {})
         .render(140)
         .join('\n');
-    assert.match(collapsed, /<success>updated ai<\/success>/);
-    assert.match(collapsed, /<muted>def5678<\/muted>/);
-    assert.doesNotMatch(collapsed, /\| name \| updated \|/);
+    assert.match(collapsed, /<success>refreshed ai<\/success>/);
+    assert.match(collapsed, /<muted>http<\/muted>/);
+    assert.doesNotMatch(collapsed, /\| name \| transport \| updated \|/);
     const expanded = def
         .renderResult({ content: [{ type: 'text', text: PKG_PLUGIN_UPDATE_UPDATED_OUTPUT }] }, { expanded: true }, theme, {})
         .render(140)
         .join('\n');
-    assert.match(expanded, /\| name \| updated \| sha \|/);
+    assert.match(expanded, /\| name \| transport \| updated \| sha \|/);
     const current = def
         .renderResult({ content: [{ type: 'text', text: PKG_PLUGIN_UPDATE_CURRENT_OUTPUT }] }, { expanded: false }, theme, {})
         .render(140)
@@ -1626,7 +1634,7 @@ test('a crtr pkg plugin update card collapses to an updated/current status + sha
         .renderResult({ content: [{ type: 'text', text: PKG_PLUGIN_UPDATE_MULTI_OUTPUT }] }, { expanded: false }, theme, {})
         .render(140)
         .join('\n');
-    assert.match(multi, /2 updated · 1 already current/);
+    assert.match(multi, /2 updated · 1 already current · 1 HTTP/);
     const empty = multiDef
         .renderResult({ content: [{ type: 'text', text: '0 updated.' }] }, { expanded: false }, theme, {})
         .render(140)
@@ -1638,11 +1646,11 @@ test('a crtr pkg plugin update card collapses to an updated/current status + sha
     const malformedUpdate = [
         '3 updated:',
         '',
-        '| name | updated | sha |',
-        '| --- | --- | --- |',
-        '| ai | true | aaa1111 |',
-        '| beta | maybe | bbb2222 |',
-        '| gamma | false | ccc3333 |',
+        '| name | transport | updated | sha |',
+        '| --- | --- | --- | --- |',
+        '| ai | exec | true | aaa1111 |',
+        '| beta | exec | maybe | bbb2222 |',
+        '| gamma | http | false |  |',
     ].join('\n');
     const malformed = multiDef
         .renderResult({ content: [{ type: 'text', text: malformedUpdate }] }, { expanded: false }, theme, {})
@@ -1655,11 +1663,11 @@ const PKG_PLUGIN_LIST_OUTPUT = [
     '',
     '3 items:',
     '',
-    '| name | scope | version | enabled | source_marketplace | path |',
-    '| --- | --- | --- | --- | --- | --- |',
-    '| ai | user | 0.7.1 | true | crouter-official-marketplace | /Users/silas/.crouter/plugins/ai |',
-    '| beta | user | 1.0.0 | false | crouter-official-marketplace | /Users/silas/.crouter/plugins/beta |',
-    '| gamma | project | 2.3.0 | true | custom-market | /Users/silas/Code/cli/crouter/.crouter/plugins/gamma |',
+    '| name | scope | version | enabled | transport | source_marketplace | path |',
+    '| --- | --- | --- | --- | --- | --- | --- |',
+    '| ai | user | 0.7.1 | true | exec | crouter-official-marketplace | /Users/silas/.crouter/plugins/ai |',
+    '| beta | user | 1.0.0 | false |  | crouter-official-marketplace | /Users/silas/.crouter/plugins/beta |',
+    '| gamma | project | 2.3.0 | true | http | custom-market | /Users/silas/Code/cli/crouter/.crouter/plugins/gamma |',
 ].join('\n');
 test('a crtr pkg plugin list card collapses to a plugin/enabled count + name digest, not the raw table', () => {
     const def = createCrtrBashToolDefinition({ command: 'crtr pkg plugin list' });
@@ -1668,13 +1676,13 @@ test('a crtr pkg plugin list card collapses to a plugin/enabled count + name dig
         .render(140)
         .join('\n');
     assert.match(collapsed, /3 plugins · 2 enabled/);
-    assert.match(collapsed, /<muted>ai, beta, gamma<\/muted>/);
+    assert.match(collapsed, /<muted>ai \(exec\), beta, gamma \(http\)<\/muted>/);
     assert.doesNotMatch(collapsed, /\| name \| scope \|/);
     const expanded = def
         .renderResult({ content: [{ type: 'text', text: PKG_PLUGIN_LIST_OUTPUT }] }, { expanded: true }, theme, {})
         .render(140)
         .join('\n');
-    assert.match(expanded, /\| name \| scope \| version \|/);
+    assert.match(expanded, /\| name \| scope \| version \| enabled \| transport \|/);
     const empty = def
         .renderResult({ content: [{ type: 'text', text: '- total: 0\n\n0 items.' }] }, { expanded: false }, theme, {})
         .render(140)
@@ -1693,7 +1701,8 @@ const PKG_PLUGIN_SHOW_OUTPUT = [
     '- scope: user',
     '- path: /Users/silas/.crouter/plugins/ai',
     '- enabled: true',
-    '- manifest: {"name":"ai","version":"0.7.1","description":"AI helpers"}',
+    '- manifest: {"name":"ai","version":"0.7.1","description":"AI helpers","commands":"commands.json","transport":{"kind":"exec","executable":"bin/ai.js"}}',
+    '- commands: {"manifestPath":"/Users/silas/.crouter/plugins/ai/commands.json","mounts":["ai"],"issues":[]}',
     '',
     '2 docs:',
     '',
@@ -1717,7 +1726,7 @@ test('a crtr pkg plugin show card collapses to a name@version + enabled status +
         .renderResult({ content: [{ type: 'text', text: PKG_PLUGIN_SHOW_OUTPUT }] }, { expanded: false }, theme, {})
         .render(140)
         .join('\n');
-    assert.match(collapsed, /<success>ai@0\.7\.1 · enabled<\/success>/);
+    assert.match(collapsed, /<success>ai@0\.7\.1 · exec · enabled<\/success>/);
     assert.match(collapsed, /<muted>2 substrate docs<\/muted>/);
     assert.doesNotMatch(collapsed, /\| name \| path \|/);
     const expanded = def

package/dist/clients/attach/render/chat-view.d.ts

@@ -25,12 +25,12 @@ export interface ChatViewOptions {
      *  the module defaults (faint + ANSI red) are used. */
     palette?: AttachPalette;
     /** Trailing refresh-yield cycles rendered at full fidelity; older cycles are
-     *  condensed to prose and frozen (see frozen-history.ts). Absent → the user's
-     *  `live_cycles` config setting, itself defaulting to 2. */
+     *  condensed to lightweight, reflowing content (see condensed-history.ts).
+     *  Absent → the user's `live_cycles` config setting, itself defaulting to 2. */
     liveCycles?: number;
-    /** Which messages of a condensed cycle survive into the frozen block. Absent →
-     *  the user's `condensed_history` config setting, itself defaulting to `none`
-     *  (cycle dividers only). */
+    /** Which messages of a condensed cycle survive into the condensed region.
+     *  Absent → the user's `condensed_history` config setting, itself defaulting
+     *  to `none` (cycle dividers only). */
     condensedHistory?: CondensedHistoryMode;
     /** Pre-colored banner lines pinned as the FIRST child of the chat container,
      *  above history (the crouton wordmark). Sits at the very top of the transcript
@@ -47,8 +47,8 @@ export declare class ChatView {
     /** Activity/status area below history. Holds working/compaction/retry loaders. */
     private readonly statusContainer;
     /** Where `append()` puts a component. Normally `historyContainer`; retargeted to
-     *  a scratch container while a frozen block is being built, so the very same
-     *  message-rendering path serves both. */
+     *  a nested container while condensed history is being built, so the same
+     *  message-rendering path serves both regions. */
     private appendTarget;
     /** Trailing cycles kept at full fidelity (config `live_cycles`). */
     private readonly liveCycles;
@@ -114,17 +114,17 @@ export declare class ChatView {
      *  reflow-on-resize is automatic — no scrollback reconstruction needed. */
     applySnapshot(snapshot: BrokerSnapshot): Promise<void>;
     /**
-     * Render the condensed form of the already-finished cycles ONCE and hand back a
-     * frozen line block (or undefined when nothing survived condensation).
+     * Build the condensed form of the already-finished cycles as a nested component
+     * container, or return undefined when nothing survives condensation.
      *
-     * Reuses `addMessageToChat` verbatim by retargeting `append()` at a scratch
-     * container, so condensed history is styled exactly like live history — the same
-     * renderer, with the tool traffic filtered out and the result flattened to text.
-     * Yields on the same cadence as the live build so a very long history still lets
-     * queued keystrokes through, and abandons itself when a newer welcome supersedes
-     * this generation.
+     * Reuses `addMessageToChat` by retargeting `append()` at the nested container, so
+     * condensed history uses the same renderer as live history with tool traffic
+     * filtered out. The outer history cache keeps stable-width frames cheap, while
+     * preserving the components lets pane-width changes reflow their content. The
+     * build yields on the live cadence and abandons itself when a newer welcome
+     * supersedes this generation.
      */
-    private buildFrozenBlock;
+    private buildCondensedBlock;
     /** Defer a live broker frame when a snapshot build is in flight. Returns true
      *  (and enqueues the replay closure) while building so the caller returns
      *  without mutating the half-rebuilt view; false when the caller may proceed.
@@ -141,8 +141,8 @@ export declare class ChatView {
     dispose(): void;
     /** Ctrl+O / app.tools.expand — flip global tool-output expansion and apply it to
      *  every rendered component that supports it. Returns the new expanded state so
-     *  the caller can surface a notice. Condensed cycles hold no tool components and
-     *  are frozen as text, so they are unaffected by design. */
+     *  the caller can surface a notice. Condensed cycles hold no tool components, so
+     *  they are unaffected by design. */
     toggleToolsExpanded(): boolean;
     /** The `fold finished tool calls` view setting (`/fold-tools`, Alt+C → w → f).
      *  Returns the new state so the caller can surface a notice. */
@@ -179,14 +179,14 @@ export declare class ChatView {
     /** Tool component with native viewer renderers for crouter-owned tool output. */
     private makeToolComponent;
     /** Append conversation content above the independent live status area — or into
-     *  the scratch container while a frozen block is under construction. */
+     *  the nested container while condensed history is under construction. */
     private append;
     /** Approximate render width for inline mermaid diagrams. Only affects
      *  termrender's trailing padding (stripped in the transform), so the terminal
      *  column count is close enough without threading the live pane width here. */
     private renderWidth;
     /** Number of rendered conversation components in the container currently being
-     *  appended to (history, or the frozen block's scratch container). */
+     *  appended to (live history or the nested condensed region). */
     private chatChildCount;
     /** Clear all chat content. */
     private resetChat;