@north-light/crouter 0.3.169 → 0.3.171

package/dist/build-root.d.ts

@@ -24,20 +24,5 @@ export declare function resolveRoot(first: string | undefined): Promise<RootDef>
  *  Composition is invocation-local and reads only stored manifest bytes — no
  *  cache, no persistence, ZERO network — so a plugin enable/update/remove or an
  *  HTTP-transport plugin manifest replacement takes effect on the next invocation
- *  automatically. The one network path (absent-store hydration, §5.1) is
- *  isolated in `hydrateAbsentStoresAndRebuild`, off this composition path. */
+ *  automatically. Composition performs no network I/O. */
 export declare function buildRoot(): Promise<RootDef>;
-/** The ONE unknown-first-token retry step (amended spec §5.1, §8), invoked by
- *  dispatch only when an unknown FIRST token misses (not a core command, not
- *  any stored external contribution) — never for a deeper unknown token under a
- *  known command. Hydrate EVERY registered HTTP-transport plugin whose manifest store
- *  is absent exactly once, write one stderr diagnostic per FAILED hydration,
- *  and — if anything was hydrated — return a freshly rebuilt root so dispatch
- *  can re-walk the original argv once. Returns undefined when nothing was
- *  hydrated (no absent stores, or every attempt failed): the caller then
- *  surfaces the plain `unknown_path`/USAGE error, with the failed-hydration
- *  diagnostics already emitted and NO NETWORK precedence over that outcome.
- *  When every registration holds a stored manifest this performs ZERO network
- *  I/O and returns undefined. It is the ONLY network the dispatch path can
- *  trigger; composition (`buildRoot`) never fetches. */
-export declare function hydrateAbsentStoresAndRebuild(): Promise<RootDef | undefined>;

package/dist/build-root.js

@@ -1,5 +1,4 @@
 import { defineRoot } from './core/command.js';
-import { diag } from './core/io.js';
 const TAGLINE = 'crtr: agentic runtime.';
 /** Lazy registry: subtree name → dynamic importer that builds its BranchDef.
  *  The whole point is that each `import()` only compiles that one subtree's
@@ -52,8 +51,7 @@ export async function resolveRoot(first) {
  *  Composition is invocation-local and reads only stored manifest bytes — no
  *  cache, no persistence, ZERO network — so a plugin enable/update/remove or an
  *  HTTP-transport plugin manifest replacement takes effect on the next invocation
- *  automatically. The one network path (absent-store hydration, §5.1) is
- *  isolated in `hydrateAbsentStoresAndRebuild`, off this composition path. */
+ *  automatically. Composition performs no network I/O. */
 export async function buildRoot() {
     const core = await Promise.all(SUBTREE_NAMES.map((n) => SUBTREE_LOADERS[n]()));
     // Dynamic import keeps external command discovery/compose (plugin +
@@ -71,25 +69,3 @@ export async function buildRoot() {
     const external = composeExternalSubtrees(snapshot);
     return defineRoot({ tagline: TAGLINE, globals: [], subtrees: [...core, ...external] });
 }
-/** The ONE unknown-first-token retry step (amended spec §5.1, §8), invoked by
- *  dispatch only when an unknown FIRST token misses (not a core command, not
- *  any stored external contribution) — never for a deeper unknown token under a
- *  known command. Hydrate EVERY registered HTTP-transport plugin whose manifest store
- *  is absent exactly once, write one stderr diagnostic per FAILED hydration,
- *  and — if anything was hydrated — return a freshly rebuilt root so dispatch
- *  can re-walk the original argv once. Returns undefined when nothing was
- *  hydrated (no absent stores, or every attempt failed): the caller then
- *  surfaces the plain `unknown_path`/USAGE error, with the failed-hydration
- *  diagnostics already emitted and NO NETWORK precedence over that outcome.
- *  When every registration holds a stored manifest this performs ZERO network
- *  I/O and returns undefined. It is the ONLY network the dispatch path can
- *  trigger; composition (`buildRoot`) never fetches. */
-export async function hydrateAbsentStoresAndRebuild() {
-    const { hydrateAbsentHttpPlugins } = await import('./core/command-plugins/discovery.js');
-    const { hydratedAny, diagnostics } = await hydrateAbsentHttpPlugins();
-    for (const line of diagnostics)
-        diag(line);
-    if (!hydratedAny)
-        return undefined;
-    return buildRoot();
-}

package/dist/builtin-memory/insights/capture.md

@@ -0,0 +1,66 @@
+---
+kind: knowledge
+when-and-why-to-read: When an initialized insight listener or a taste-capture preference identifies a possible reusable principle in user-supplied information, this knowledge should be read because immediate review separates durable user insight from plausible-sounding agent extrapolation before it shapes future decisions.
+short-form: Extract one coherent principle from user input, review terse candidate truths immediately, then create or revise semantic memory only from what the user approves.
+system-prompt-visibility: none
+file-read-visibility: none
+rationale: Agents have both missed deeper user insight hidden in ordinary feedback and saved their own unreviewed interpretation as fundamental truth; the user needs to edit, delete, or sharpen the inferred principle before it becomes standing semantic memory.
+---
+
+# Confirm a user-derived insight before saving it
+
+The calling memory defines the domain, destination, and final document shape. This workflow owns the extraction and review boundary. No semantic memory is written until the user approves the inferred truth.
+
+## Decide whether there is a principle
+
+Eligible source material is information supplied or validated by the user: ordinary messages, corrections, humanloop answers, anchored review comments and line edits, and responses to claims an agent surfaced. Model output alone is not user insight.
+
+A source episode qualifies only when you can state a coherent, non-obvious principle that would inform materially different future decisions. Routine requirements clarification, implementation feedback, wording changes, plan convergence, and facts already recorded in code or a specification do not qualify.
+
+A correction is a signal, not proof. Infer the deeper reason beneath the immediate symptom, but do not save the literal conversational before-and-after as the principle.
+
+## Find the existing home
+
+Search the destination directory before drafting. If the source refines, bounds, or strengthens an existing principle, propose a rewrite of that document. Create a new document only for a distinct read trigger that can evolve independently. One document may accumulate insight from several source episodes.
+
+## Review one coherent principle immediately
+
+Write a small Markdown artifact under the current node's absolute context directory and queue it with `crtr human review`. Do not batch it with unrelated principles and do not ask a separate confirmation question first.
+
+Use this shape:
+
+```markdown
+# Proposed insight: <short principle name>
+
+## Source context
+
+<Only enough user words or surrounding context to judge the inference. Prefer an exact quote.>
+
+## Current truth
+
+<Include only when revising an existing memory.>
+
+## Proposed durable truth
+
+- <terse candidate principle or facet>
+- <another candidate only when it adds a real distinction or boundary>
+```
+
+Candidate bullets are reverse-engineered hypotheses, not polished prose. Generate several when the deeper insight has multiple plausible formulations, and accept that the user may delete most of them. Do not pad to a target count, explain every bullet, or hide uncertainty in a long essay.
+
+The review is asynchronous. Continue other work or end the turn and let the submitted review wake this node; never poll it.
+
+## Apply only approved truth
+
+Apply direct line edits and explicit comments from the review. If feedback requires you to invent a materially new formulation rather than transcribe the user's correction, revise the artifact and review that formulation again. If no candidate survives, save nothing.
+
+Then run `crtr memory write -h` and create or rewrite the approved destination document. For an initialized `insights/<topic>/` listener:
+
+- store the principle as knowledge unless its actual use is to direct behavior;
+- keep the body to the current distilled truth as short declarative bullets;
+- use `none` visibility on both axes so the topic index is the one router; and
+- add a link to its canonical principle document in the topic index without duplicating the insight there.
+
+When the calling preference routes to `taste/` or another established destination, preserve that destination's own body and routing contract while keeping the same review-before-write boundary.
+
+Source context and agent reasoning stay in the review artifact. Do not copy them into the approved memory or add provenance machinery. Run `crtr memory lint` after every create or rewrite and fix every finding.

package/dist/builtin-memory/insights/init.md

@@ -0,0 +1,45 @@
+---
+kind: knowledge
+when-and-why-to-read: When the user invokes /insights:init to begin gathering user-derived insight about a domain, this knowledge should be read because a correctly scoped listener preserves uniquely valuable knowledge without creating a parallel store or background system.
+short-form: Initialize passive insight gathering for a domain at the narrowest durable scope; create one routed topic index that reviews user-derived principles before saving them.
+system-prompt-visibility: none
+file-read-visibility: none
+slash: true
+rationale: Ordinary conversations, corrections, humanloop answers, and review comments carry unique user knowledge that agents inconsistently recognize or save; when agents do infer a deeper principle, they have written it without first letting the user correct the extrapolation.
+---
+
+# /insights:init — begin passive domain listening
+
+Initialize an ordinary memory directory that listens for user-derived insight about this domain. This version is passive: do not start research, schedule work, create a standing node, or proactively question the user after initialization.
+
+**Requested domain:** $ARGUMENTS
+
+## Establish the topic and scope
+
+Turn the request into a short path-safe topic slug and a compact domain boundary that preserves the user's meaning rather than reducing it to a single keyword. If the request is empty or too vague to distinguish relevant from unrelated information, ask one focused question through `crtr human ask`.
+
+Choose the narrowest durable scope that reaches every future conversation where this domain matters:
+
+- project when the insight is meaningful only inside one project;
+- profile when it spans the selected profile's projects but should not follow the user elsewhere; or
+- user when it concerns the person, a market, a craft, or a domain that crosses workspaces.
+
+Infer the scope from the request and current workspace. Ask through `crtr human ask` only when more than one scope is genuinely plausible, and settle scope before writing anything. Never use node scope for an ongoing listener.
+
+Search the chosen scope before creating. If `insights/<topic>` already represents the same domain, refine that listener rather than creating an overlapping directory.
+
+## Create the listener
+
+Run `crtr memory write -h`, then create `insights/<topic>/INDEX.md` at the chosen scope as a preference with system-prompt visibility `preview` and file-read visibility `none`.
+
+Its routing line must name the actual domain trigger: when user-supplied information, a correction, or a user response relates to this domain, read the preference because recognizing the underlying principle preserves knowledge future decisions can use.
+
+Keep the body short. It contains:
+
+- the domain boundary, including exclusions needed to prevent false triggers;
+- a directive to follow [[insights/capture]] whenever a source episode may reveal a reusable principle; and
+- an `Approved insights` section containing document links to principle memories as they are approved.
+
+Do not copy the capture workflow into the listener. The link keeps that process in one maintained place. Do not create placeholder principle documents.
+
+Run `crtr memory lint`, fix every finding, then report the canonical listener name, selected scope, and the domain boundary. Initialization is complete once the routed listener exists; no independent work follows.

package/dist/builtin-memory/internal/plugins.md

@@ -64,12 +64,12 @@ The `<plugin-name>` directory IS the plugin. The manifest's `name` field must ma
 | Field | Required | Notes |
 |---|---|---|
 | `name` | yes | Must match the directory name. Lowercase kebab. |
-| `version` | yes | Semver. Marketplace CI may bump automatically — see marketplaces knowledge. |
+| `version` | yes for authored plugins | Semver. Marketplace CI may bump automatically; archive installs synthesize a 12-character content identifier. |
 | `description` | yes | One sentence. |
-| `source` | recommended | Git URL where the plugin lives. Used by `crtr pkg plugin update --name <name>`. |
+| `source` | recommended | Human-facing URL where the plugin lives. Source-installed plugin updates derive provenance from their checkout or marketplace registration, not this descriptive field. |
 | `owner` | optional | Author info. |
 | `commands` | optional | Plugin-root-relative path to a `commands.json` command manifest. It must appear with `transport`; together they make the plugin contribute `crtr` commands — see [Plugin commands](#plugin-commands). |
-| `transport` | optional | Required exactly when `commands` is present. `{ "kind": "exec", "executable": "bin/cmd.js" }` runs executable leaves; a passthrough-only exec manifest may omit `executable`. `{ "kind": "http", "endpoint": "https://…", "authEnv": "TOKEN_NAME" }` calls a remote HTTP command surface. |
+| `transport` | optional | Required exactly when `commands` is present. `{ "kind": "exec", "executable": "bin/cmd.js" }` runs executable leaves; a passthrough-only exec manifest may omit `executable`. `{ "kind": "http", "endpoint": "https://…", "authEnv": "TOKEN_NAME" }` calls a remote HTTP command surface. Archive-installed plugins also carry crouter-synthesized `bundle` provenance; authors do not add it. |
 
 ## Scopes
 
@@ -96,9 +96,10 @@ Four ways a plugin lands in a scope:
    - `crtr pkg market update --name <mkt>` refreshes the marketplace and every installed plugin it sources; relative sources follow the checkout, while remote-source checkouts pull their own Git remote.
    - See [[internal/marketplaces]].
 
-3. **From an HTTP endpoint** (`crtr pkg plugin install --endpoint <url> --name <name> --scope user`):
-   - Fetches the served `commands.json`, then writes the plugin manifest and exact fetched bytes into the selected scope. The endpoint must use `https:`; `http:` is accepted only for `localhost`, `127.0.0.1`, `[::1]`, `::1`, or `host.docker.internal`, with no credentials or fragment.
-   - The install fails loudly and writes nothing when that fetch fails. Reinstalling the same HTTP plugin replaces its endpoint/auth-env declaration and stored manifest; it conflicts with an existing non-HTTP plugin of the same name.
+3. **From an HTTP directory archive** (`crtr pkg plugin install --endpoint <url> --name <name> --scope user`):
+   - Fetches one authenticated uncompressed `application/x-tar` archive containing `bundle.json`, `commands.json`, and `memory/**/*.md`. crouter validates every member before writing, then materializes the complete package with a synthesized `.crouter-plugin/plugin.json`. The endpoint must use `https:`; `http:` is accepted only for `localhost`, `127.0.0.1`, `[::1]`, `::1`, or `host.docker.internal`, with no credentials or fragment.
+   - The synthesized `bundle` field records the archive endpoint and optional credential variable name for installs and updates. Its distinct `transport` field records the archive endpoint's origin for command invocation. crouter stores the environment variable name, never its token.
+   - Reinstalling a bundle plugin replaces commands and memory together. Fetch or validation failure leaves the prior package intact. A commands-only HTTP plugin predating this archive contract must be removed and reinstalled.
 
 4. **Authored in place** (you're writing the plugin in a working repo):
    - Symlink for tight dev loop: `ln -s $(pwd) ~/.crouter/plugins/<name>`.
@@ -136,7 +137,7 @@ Standard semver:
 | New doc, new section, new example | minor (0.1.0 → 0.2.0) |
 | Removed doc, renamed doc, changed manifest schema | major (0.1.0 → 1.0.0) |
 
-`crtr pkg plugin update --name <name>` pulls source updates for ordinary and exec-transport plugins, while an HTTP-transport plugin unconditionally refetches and replaces its stored `commands.json`. A failed HTTP refresh preserves the prior bytes and exits nonzero. Plugins published through a marketplace may have their `version` field bumped automatically by CI — see [[internal/marketplaces]].
+`crtr pkg plugin update --name <name>` pulls source updates for ordinary plugins, including source-installed plugins whose command transport is HTTP. An archive plugin instead re-fetches its recorded `bundle` endpoint and replaces its complete package atomically; its version is the first 12 hex characters of the fetched archive SHA-256. A failed named update preserves the prior package and exits nonzero; bulk update reports the failure and continues. Plugins published through a marketplace may have their `version` field bumped automatically by CI — see [[internal/marketplaces]].
 
 ## Enable/disable
 
@@ -180,12 +181,12 @@ Beyond docs, a plugin may contribute **top-level `crtr` commands** — new noun
 An HTTP-transport plugin replaces that declaration with:
 
 ```json
-"transport": { "kind": "http", "endpoint": "https://example.com/v1/cli/manifest", "authEnv": "DEPLOY_TOKEN" }
+"transport": { "kind": "http", "endpoint": "https://example.com", "authEnv": "DEPLOY_TOKEN" }
 ```
 
-For `exec`, `executable` is required when the manifest has any executable leaf; a passthrough-only manifest omits it. When declared, it is plugin-root-relative, resolves inside the plugin root to a regular file, and carries the POSIX exec bit. For `http`, `endpoint` is an absolute endpoint and `authEnv` is optional. crtr stores only the environment variable **name**, never its credential; it reads the credential when fetching the manifest or invoking a leaf.
+For `exec`, `executable` is required when the manifest has any executable leaf; a passthrough-only manifest omits it. When declared, it is plugin-root-relative, resolves inside the plugin root to a regular file, and carries the POSIX exec bit. For `http`, `transport.endpoint` is the backend origin and `authEnv` is optional. crouter stores only the environment variable **name**, never its credential; it reads the credential when invoking a leaf. A crouter-materialized archive plugin additionally records its archive URL separately in `bundle` for installation and update.
 
-Only an installed, **enabled** plugin's command manifest contributes. Discovery is per-invocation: enable, disable, update, and remove take effect on the next `crtr` call — no daemon restart or cache clearing.
+Only an installed, **enabled** plugin's command manifest contributes. Discovery is per-invocation and reads the installed `commands.json` only: enable, disable, update, and remove take effect on the next `crtr` call with no daemon restart, cache clearing, or network fetch.
 
 ### commands.json shape
 
@@ -239,7 +240,7 @@ For an exec leaf, crtr writes exactly one JSON request to the executable's stdin
 
 - **Generate an exec plugin's `commands.json` from its command definitions — never hand-write it.** The manifest must stay in lockstep with the executable's command surface; drifted params or output fields surface as a validation issue or `plugin_protocol_error` at invocation.
 - **A required output field must be non-null.** The adapter treats an explicit `null` for a declared-required field as absent → `plugin_protocol_error`. If a value is optional, declare it `required: false`; if it is required, return a real value.
-- **HTTP plugin manifests are fetched bytes.** `crtr pkg plugin install --endpoint <url> --name <name>` fetches before writing the plugin, then stores the exact response at the plugin's declared `commands` path. `crtr pkg plugin update` unconditionally refetches HTTP plugins; failures preserve the prior bytes and exit nonzero. The stored manifest is authoritative with no TTL, ETag, or revalidation. If its file is missing or unparseable, an unknown-first-token miss fetches each affected HTTP plugin once; diagnostics name `crtr pkg plugin update <name>`.
+- **HTTP archive plugins are complete package bytes.** `crtr pkg plugin install --endpoint <url> --name <name>` fetches and validates the complete archive before replacing the plugin directory. `crtr pkg plugin update` uses the recorded `bundle` provenance to do the same replacement. The installed `commands.json` and memory tree are authoritative with no TTL, ETag, revalidation, or dispatch-time network path.
 
 ### Validation and command collisions
 

package/dist/cli.js

@@ -4,7 +4,7 @@ import { openSync } from 'node:fs';
 import { enableCompileCache } from 'node:module';
 import { fileURLToPath } from 'node:url';
 import { runCli } from './core/command.js';
-import { resolveRoot, hydrateAbsentStoresAndRebuild } from './build-root.js';
+import { resolveRoot } from './build-root.js';
 import { maybeBootRoot } from './core/runtime/front-door.js';
 import { maybeAutoUpdate } from './core/auto-update.js';
 import { ensureOfficialMarketplace, ensureProjectScope } from './core/bootstrap.js';
@@ -57,12 +57,8 @@ async function main() {
     ensureOfficialMarketplace(process.argv);
     ensureProjectScope(process.argv);
     maybeAutoUpdate(process.argv);
-    // Pass the one-shot unknown-first-token retry seam: on a first-token miss with
-    // 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');
-    await runCli(root, process.argv, { onUnknownFirstTokenMiss: hydrateAbsentStoresAndRebuild });
+    await runCli(root, process.argv);
     mark('cli.dispatch_done');
 }
 main().catch((err) => {

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

@@ -28,6 +28,7 @@ test('attach direct and private control input dispatch through the same action m
         'crtr.attach.detach': ['ctrl+x'],
         'crtr.attach.clear-or-detach': [],
         'crtr.attach.graph.toggle': [],
+        'crtr.attach.help.toggle': ['alt+shift+k'],
         'crtr.mode.cycle': ['alt+x'],
         'crtr.attach.model-ladder.next': ['alt+z'],
         'crtr.attach.model-ladder.previous': ['alt+y'],
@@ -40,6 +41,7 @@ test('attach direct and private control input dispatch through the same action m
         'crtr.attach.detach': () => calls.push('detach'),
         'crtr.attach.clear-or-detach': () => calls.push('clear'),
         'crtr.attach.graph.toggle': () => calls.push('graph'),
+        'crtr.attach.help.toggle': () => calls.push('help'),
         'crtr.mode.cycle': () => calls.push('mode'),
         'crtr.attach.model-ladder.next': () => calls.push('ladder'),
         'crtr.attach.model-ladder.previous': () => calls.push('ladder-back'),
@@ -57,12 +59,16 @@ test('attach direct and private control input dispatch through the same action m
     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.equal(dispatchAttachBinding(bindings, '\x1b[75;4u', actions), true);
     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']);
+    const helpPrivateInput = encodeAttachControlInput('crtr.attach.help.toggle');
+    assert.equal(decodeAttachControlInput(helpPrivateInput), 'crtr.attach.help.toggle');
+    dispatchAttachAction('crtr.attach.help.toggle', actions);
+    assert.deepEqual(calls, ['detach', 'mode', 'ladder', 'ladder-back', 'inspect', 'help', 'profile-files', 'help']);
     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`), {

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

@@ -1,7 +1,7 @@
 // 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.
+// while bearings, situational updates, fresh-revive kickoffs, runtime steering,
+// recovery prompts, 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';
@@ -13,7 +13,7 @@ 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';
+import { AUTH_FAULT_RECOVERY_BODY, CONNECTION_FAULT_RECOVERY_BODY, CONTEXT_NUDGE_CUSTOM_TYPE, PROVIDER_FAULT_RECOVERY_BODY, REVIVE_KICKOFF_SENTINEL, RUNTIME_RESTART_CONTINUATION, STALL_REPROMPT, formatModelFallbackRecovery, formatPersonaTransition, formatStructuredOutputReprompt, 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;
@@ -51,6 +51,27 @@ test('generated rows add no leading spacer after prior transcript content', asyn
     assert.notEqual(generatedIndex, -1);
     assert.match(lines[generatedIndex - 1] ?? '', /before/, 'the collapsed row follows prior content directly');
 });
+test('Ctrl+O expands generated context while showing individual summarized calls', async () => {
+    const container = new Container();
+    const tui = { requestRender() { }, terminal: { rows: 40 } };
+    const view = new ChatView(tui, container, { toolOutputExpanded: false });
+    const internals = view;
+    internals.summarizeToolCalls = true;
+    internals.foldSettledTools = true;
+    internals.showGroupSummaries = true;
+    await view.applySnapshot({
+        messages: [{ role: 'user', content: RUNTIME_RESTART_CONTINUATION }],
+        stats: {},
+        state: { isStreaming: false },
+    });
+    assert.doesNotMatch(container.render(80).join('\n'), /runtime-restart-continuation/);
+    assert.deepEqual(view.toggleToolsExpanded(), { kind: 'summaries', shown: false });
+    assert.equal(internals.toolOutputExpanded, true);
+    assert.match(container.render(80).join('\n'), /runtime-restart-continuation/);
+    assert.deepEqual(view.toggleToolsExpanded(), { kind: 'summaries', shown: true });
+    assert.equal(internals.toolOutputExpanded, false);
+    assert.doesNotMatch(container.render(80).join('\n'), /runtime-restart-continuation/);
+});
 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);
     const line = bearings.render(80).join('\n');
@@ -80,6 +101,32 @@ test('fresh-revive kickoff and both context-nudge roles classify as generated co
     assert.equal(inbox?.label, 'crtr inbox');
     assert.equal(inbox?.summary, '2 updates from child-node-123');
 });
+test('runtime steering and recovery prompts classify without hiding their full bodies', () => {
+    const personaBody = formatPersonaTransition('You are now an orchestrator.');
+    const persona = generatedContextPresentation({ role: 'user', content: personaBody });
+    assert.equal(persona?.kind, 'persona-transition');
+    assert.equal(persona?.body, personaBody);
+    const structuredBody = formatStructuredOutputReprompt(JSON.stringify({ type: 'object' }, null, 2));
+    assert.equal(generatedContextPresentation({ role: 'user', content: STALL_REPROMPT })?.summary, 'completion required');
+    assert.equal(generatedContextPresentation({ role: 'user', content: structuredBody })?.summary, 'structured output required');
+    const recoveries = [
+        [AUTH_FAULT_RECOVERY_BODY, 'provider credentials updated'],
+        [CONNECTION_FAULT_RECOVERY_BODY, 'network connection restored'],
+        [PROVIDER_FAULT_RECOVERY_BODY, 'provider retry'],
+        [formatModelFallbackRecovery('old/model', 'new/model:high', 'credential'), 'model route changed'],
+        [formatModelFallbackRecovery('custom(provider)/model', 'new/model:high', 'not-found'), 'model route changed'],
+        [RUNTIME_RESTART_CONTINUATION, 'runtime restarted'],
+    ];
+    for (const [body, summary] of recoveries) {
+        const presentation = generatedContextPresentation({ role: 'user', content: body });
+        assert.equal(presentation?.kind, 'recovery');
+        assert.equal(presentation?.summary, summary);
+        assert.equal(presentation?.body, body);
+    }
+    assert.equal(generatedContextPresentation({ role: 'user', content: 'continue' }), null, 'a human one-word continue is not mistaken for runtime recovery');
+    const unmarkedModelRecovery = formatModelFallbackRecovery('custom(provider)/model', 'new/model:high', 'not-found').split('\n').slice(1, -1).join('\n');
+    assert.equal(generatedContextPresentation({ role: 'user', content: unmarkedModelRecovery }), null, 'a human message matching the recovery prose lacks the producer marker');
+});
 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__/diagram.test.js

@@ -1,6 +1,6 @@
 import assert from 'node:assert/strict';
 import test from 'node:test';
-import { ensureRenderer, isRendererReady } from '@crouton-kit/humanloop';
+import { ensureRenderer, isRendererReady } from '../../../core/termrender/termrender.js';
 import { transformDiagramFences } from '../render/diagram.js';
 // This asserts a REAL termrender render (box-drawing glyphs), so it only holds
 // once the managed renderer is provisioned — true in the full tier and on a dev

package/dist/clients/attach/chrome/header.d.ts

@@ -0,0 +1,10 @@
+import { Container } from '@earendil-works/pi-tui';
+import type { SessionState } from '../../../core/session-model/session-state.js';
+import type { AttachSession } from '../session/context.js';
+export interface RecapHeader {
+    /** The component ViewerFrame renders as its header region. */
+    readonly component: Container;
+    /** Repaint from the live `crtr-recap` widget state. Empty widget → 0 rows. */
+    render(): void;
+}
+export declare function createRecapHeader(ctx: Pick<AttachSession, 'tui' | 'pal'>, state: () => SessionState): RecapHeader;

package/dist/clients/attach/chrome/header.js

@@ -0,0 +1,35 @@
+// chrome/header.ts — the pinned recap header above the transcript.
+//
+// The broker's retained `crtr-recap` widget is painted here rather than in the
+// bottom cockpit so it stays visible while the transcript scrolls.
+import { Container, Text, wrapTextWithAnsi } from '@earendil-works/pi-tui';
+import { DynamicBorder } from '@earendil-works/pi-coding-agent';
+/** A recap line is `Goal:`/`State:` + body — bold the label, faint the body.
+ * Styled BEFORE wrapping (wrapTextWithAnsi carries SGR state across wraps), so a
+ * wrapped continuation stays faint. Unlabeled lines are all-faint. */
+const styleRecapLine = (line, pal) => {
+    const match = /^(Goal|State):\s*/.exec(line);
+    if (match === null)
+        return pal.faint(line);
+    return `${pal.bold(match[1] + ':')} ${pal.faint(line.slice(match[0].length))}`;
+};
+export function createRecapHeader(ctx, state) {
+    const { tui, pal } = ctx;
+    const component = new Container();
+    const render = () => {
+        component.clear();
+        const widget = state().display.widgets['crtr-recap'];
+        if (widget !== undefined && widget.lines.length > 0) {
+            const span = Math.max(1, (process.stdout.columns ?? 80) - 2);
+            for (const line of widget.lines) {
+                const styled = styleRecapLine(line, pal);
+                for (const wrapped of wrapTextWithAnsi(styled, span)) {
+                    component.addChild(new Text(wrapped, 1, 0));
+                }
+            }
+            component.addChild(new DynamicBorder(pal.border));
+        }
+        tui.requestRender();
+    };
+    return { component, render };
+}

package/dist/clients/attach/chrome/status-line.d.ts

@@ -20,6 +20,9 @@ export interface StatusLineHooks {
      *  a LOCAL in-tmux attach: a remote attach's local inbox registry cannot open
      *  the remote canvas's filesystem tickets. */
     inboxAffordance: boolean;
+    /** Whether mouse reporting is currently enabled. When false, displays a
+     *  low-priority 'mouse off' indicator in the status bar. */
+    mouseEnabled: () => boolean;
 }
 export interface AttachStatusLine {
     /** Repaint the bar from current state. */

package/dist/clients/attach/chrome/status-line.js

@@ -76,6 +76,11 @@ export function createStatusLine(s, hooks) {
                 segs.push(pal.muted(`⚑ ${total} · ${inboxOpenHint(bindings)}`));
             }
         }
+        // Mouse reporting state: show "mouse off" when reporting is disabled, so
+        // users are aware that tmux drag-select and copy-mode mouse work again.
+        if (!hooks.mouseEnabled()) {
+            segs.push(pal.muted('mouse off'));
+        }
         // Lowest-priority segment (R4): the Alt+C -> b hint, shown only once the
         // oldest still-foreground bash job has crossed the threshold. Read straight
         // off this node's job files rather than tracked from relayed tool-execution

package/dist/clients/attach/chrome/widgets.js

@@ -7,33 +7,22 @@ import { DynamicBorder } from '@earendil-works/pi-coding-agent';
 export function createChromeWidgets(ctx, state) {
     const { tui, pal } = ctx;
     const { chrome, aboveWidgets, belowWidgets, queued } = ctx.containers;
-    /** A recap line is `Goal:`/`State:` + body — bold the label, faint the body.
-     *  Styled BEFORE wrapping (wrapTextWithAnsi carries SGR state across wraps),
-     *  so a wrapped continuation stays faint. Unlabeled lines are all-faint. */
-    const styleRecapLine = (line) => {
-        const m = /^(Goal|State):\s*/.exec(line);
-        if (m === null)
-            return pal.faint(line);
-        return `${pal.bold(m[1] + ':')} ${pal.faint(line.slice(m[0].length))}`;
-    };
-    /** Paint serializable extension widgets into their fixed cockpit slots. The
-     *  recap sits immediately above the editor border and uses the faint palette:
-     *  persistent orientation, but visually a side note rather than primary UI. */
+    /** Paint serializable extension widgets into their fixed cockpit slots. */
     const renderExtensionWidgets = () => {
         const session = state();
         aboveWidgets.clear();
         belowWidgets.clear();
-        // The brief is an inline annotation, so do not give it the chat/chrome divider
-        // that would make it read as a separate panel.
+        // The chrome container is the pinned transcript/cockpit divider. Recap is
+        // painted by the pinned header instead of being part of this cockpit slot.
         chrome.clear();
-        if (session.display.widgets['crtr-recap'] === undefined)
-            chrome.addChild(new DynamicBorder(pal.border));
+        chrome.addChild(new DynamicBorder(pal.border));
         const span = Math.max(1, (process.stdout.columns ?? 80) - 2);
         for (const [key, widget] of Object.entries(session.display.widgets)) {
+            if (key === 'crtr-recap')
+                continue;
             const target = widget.placement === 'belowEditor' ? belowWidgets : aboveWidgets;
             for (const line of widget.lines) {
-                const styled = key === 'crtr-recap' ? styleRecapLine(line) : line;
-                for (const wrapped of wrapTextWithAnsi(styled, span)) {
+                for (const wrapped of wrapTextWithAnsi(line, span)) {
                     target.addChild(new Text(wrapped, 1, 0));
                 }
             }

package/dist/clients/attach/input/controller.d.ts

@@ -1,6 +1,7 @@
 import type { CustomEditor } from '@earendil-works/pi-coding-agent';
 import type { Component, KeybindingsManager, TUI } from '@earendil-works/pi-tui';
 import { type BrokerDataFrame, type ClientRole, type BrokerSnapshot, type ClientToBroker, type RpcExtensionUIRequest, type RpcExtensionUIResponse } from '../../../core/runtime/broker-protocol.js';
+import type { CopyTarget } from '../render/transcript-copy.js';
 import type { ReadOpRequest } from '../../../core/broker-client/index.js';
 import { type Picker, type PickerControls } from '../overlays/pickers.js';
 export interface InputControllerHooks {
@@ -33,12 +34,21 @@ export interface InputControllerHooks {
     /** OPTIONAL: toggle the GRAPH overlay — forwarded to the slash context so
      *  `/graph` opens/closes it (Unit Q wires it from runAttach). */
     onGraph?: () => void;
+    /** OPTIONAL: toggle the Help overlay — forwarded to the slash context so
+     *  `/hotkeys` opens/closes it. */
+    onHelp?: () => void;
     /** OPTIONAL: detach the viewer — forwarded to the slash context so `/quit`
      *  tears down the TUI/socket (the engine keeps running). Wired by viewer.ts. */
     onQuit?: () => void;
     /** OPTIONAL: copy the last assistant message to the clipboard — forwarded to
      *  the slash context so `/copy` works. Wired by viewer.ts (it owns ChatView). */
     onCopy?: () => void;
+    /** OPTIONAL: copy a viewer-local transcript target — forwarded to the slash
+     *  context so `/copy-message`, `/copy-tool`, and `/copy-transcript` work. */
+    onCopyTarget?: (target: CopyTarget) => void;
+    /** OPTIONAL: toggle mouse wheel reporting — forwarded to the slash context so
+     *  `/mouse` can change viewer-local mouse state. */
+    onToggleMouse?: () => void;
     /** OPTIONAL: recolor the editor's name chip — forwarded to the slash context
      *  so `/color` paints it (`null` clears). Wired by viewer.ts (it owns the
      *  TitledEditor). */

package/dist/clients/attach/input/controller.js

@@ -240,8 +240,11 @@ export class InputController {
             remote: this.hooks.remote,
             role: this.hooks.role,
             onGraph: this.hooks.onGraph,
+            onHelp: this.hooks.onHelp,
             onQuit: this.hooks.onQuit,
             onCopy: this.hooks.onCopy,
+            onCopyTarget: this.hooks.onCopyTarget,
+            onToggleMouse: this.hooks.onToggleMouse,
             onColor: this.hooks.onColor,
             onNodeMetadata: this.hooks.onNodeMetadata,
             onFoldTools: this.hooks.onFoldTools,

package/dist/clients/attach/overlays/help.d.ts

@@ -0,0 +1,33 @@
+import { type Component, type TUI } from '@earendil-works/pi-tui';
+import type { AttachPalette } from '../config.js';
+import type { AttachBindings } from '../session/bindings.js';
+/** A bounded, focused reference for the attach viewer's viewport controls. */
+export declare class HelpOverlay implements Component {
+    private readonly tui;
+    private readonly pal;
+    private handle;
+    private bindings;
+    private scrollTop;
+    private lastContentRows;
+    constructor(tui: TUI, pal: AttachPalette);
+    /** Re-resolve key spellings after `/reload` (mirrors GraphOverlay.setBindings). */
+    setBindings(bindings: AttachBindings): void;
+    toggle(): void;
+    close(): void;
+    isOpen(): boolean;
+    invalidate(): void;
+    render(width: number): string[];
+    handleInput(data: string): boolean;
+    private open;
+    private matchesBinding;
+    private scrollBy;
+    private pageSize;
+    private body;
+    private lines;
+    private binding;
+    private wrap;
+    private style;
+    private boxRow;
+    private borderRow;
+    private renderNarrow;
+}