@north-light/crouter 0.3.162 → 0.3.164

package/dist/builtin-memory/00-runtime-base.md

@@ -9,6 +9,7 @@ rationale: >-
   "Say what actually happens" exists because an approval request called a root a person had created an "attended root" — an invented category with no referent in the product, which forced Silas to halt the decision and ask what the term meant (2026-07-28). Agents coin taxonomies to compress a distinction; the reader pays by decoding a word that names nothing real.
 
   "Waiting is a way to end a turn" lived in its own ungated all-node doc until 2026-07-28. Same gate, same audience, never independently readable — so the split bought no routing and cost a stub cross-reference in this file pointing at a section spliced a few hundred tokens later. Split it back out only if it ever needs a gate of its own.
+lint-ignore: length
 ---
 
 You are a **node** in a live agent graph (the crtr canvas). This section is your operating protocol — it is true for every node regardless of role.

package/dist/builtin-memory/04-orchestration-kernel.md

@@ -6,6 +6,7 @@ file-read-visibility: none
 gate: {mode: orchestrator}
 rationale: >-
   Two observed orchestration failures set this kernel's stopping rules. A sole-writer feature lane produced a 5-deep 1:1 developer/orchestrator chain by repeatedly delegating the whole assignment; separately, the kernel's “idle capacity,” “maximum agents,” and “when in doubt, more rigor” objective helped produce review-only subtrees as large as 87 nodes and five levels deep. Coordination must optimize new evidence toward the goal rather than node count or process length.
+lint-ignore: length
 ---
 
 ## You are an orchestrator

package/dist/builtin-memory/init.md

@@ -0,0 +1,38 @@
+---
+kind: knowledge
+when-and-why-to-read: When bootstrapping a project's memory store — the user invoked /init or a workspace has no .crouter/memory/INDEX.md front door — this knowledge should be read because a lean routed front door gives every future agent in that workspace its operating contract for a fraction of the standing context cost an unstructured guidance dump would charge each session forever.
+short-form: "Bootstrap a project memory store: survey the repo, then author a lean INDEX front door plus a linked dev doc — commands, map, non-default rules, pointers — and lint. Depth splits into linked docs; every always-loaded line must earn its keep."
+system-prompt-visibility: none
+file-read-visibility: none
+slash: true
+rationale: Unguided agents bootstrap project memory badly in both directions — either no front door at all, or a monolithic CLAUDE.md-style manual (copied README, generic framework advice, exhaustive command catalogs) that taxes every future session and decays. Distilled 2026-07-31 from ecosystem research across Anthropic/OpenAI/Cursor/GitHub guidance and production AGENTS.md files — the strongest evidence being Sentry's consolidation postmortem (critical commands buried in nested files got missed) and Anthropic's under-200-line target with adherence falling as always-loaded files grow.
+---
+
+# /init — bootstrap this project's memory store
+
+Give this workspace its memory front door: a root INDEX every future agent boots with when the project mounts, plus a small graph of linked docs carrying the depth. The front door is an operating contract and routing layer, never a manual — every line it carries is paid by every session here forever, so a line earns its place only by changing behavior: a fact every task needs, a non-obvious hazard, or a rule an agent would otherwise get wrong.
+
+## 1. Survey before writing
+
+Learn the project from its own artifacts: README, package manifests and lockfiles, build/CI config, scripts, existing CLAUDE.md/AGENTS.md or docs. Extract the real commands (setup, run, build, targeted test, full verification) and RUN the important ones — record only commands you have seen work, with any required ordering, environment, or package-manager constraint. Note the architecture in a few sentences: major components, dependency direction, where generated or externally-owned code lives. Collect the conventions that differ from what a competent agent would assume — those deviations are the highest-value lines you will write.
+
+## 2. Read the contract, then author the front door
+
+Run `crtr memory write -h` first — it carries the substrate frontmatter contract and the exact root-INDEX shape, including the workspace-mount route that `crtr memory lint` validates. Then author the INDEX with these sections, total well under the length lint's cap:
+
+- **Project in one paragraph** — purpose, major components, dependency direction.
+- **Common commands** — the 3–8 commands most changes need, copyable, verified.
+- **Where to work** — a task-to-path map; mark generated or externally-owned areas.
+- **Non-default rules and gotchas** — only high-impact deviations from defaults. Skip anything a formatter, linter, or typechecker already enforces; point at the check instead.
+- **Done** — the minimum credible gate for an ordinary change.
+- **Pointers** — a `[[link]]` per deeper doc with a one-clause read trigger (e.g. "debugging the daemon → the dev doc").
+
+Exclude generic language/framework advice, copied docs or style guides, volatile version detail, rare edge cases, and multi-step procedures — depth belongs behind links, not in the standing load.
+
+## 3. Split depth into linked docs
+
+Author `dev` alongside the INDEX by default: validated setup/run/build/test/debug commands with required order and environment, targeted-vs-full verification, and common failure modes. Add `architecture` only when the tree cannot be understood from the INDEX's brief map, and a conventions/gotchas doc only once real project-specific rules outgrow a few INDEX bullets — never pre-populate generic security or style manuals. These reference docs take `none` visibility on both axes; the INDEX's links are how they are found, so they cost nothing until followed.
+
+## 4. Validate
+
+Run `crtr memory lint` — it strict-parses the store, checks the INDEX front-door contract, and fails on dangling links or over-length bodies. Fix findings rather than suppressing them. The store is a living contract: when commands, architecture, or conventions change, rewrite the affected doc in place and delete superseded guidance — an always-loaded line that has stopped being true is worse than no line at all.

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

@@ -14,6 +14,7 @@ Open this dir whenever a task turns on understanding the runtime itself or chang
 
 - **nodes-and-canvas** — the agent-runtime model: nodes on the canvas graph, spawn/delegate, the push/feed spine, lifecycle (mode + lifecycle axes), and revive (manual + daemon auto-revive).
 - **storage-tiers** — where every kind of state lives: the two tiers (scope root and canvas home) and their durability/ownership contracts.
+- **memory-loading** — the memory load model: the two hooks (boot catalog, file-read), the four-rung ladder, gates, applies-to/read-when routing, boot-render ordering, and store mounting/precedence — read when diagnosing why a doc did or didn't load.
 - **agent-shaping** — the when-to-use-which layer over the four dials that shape a node: kinds (the builtin roster, sub-kinds, and custom personas), modes (base vs orchestrator), profiles, and the memory tiers (node/profile/project/user/builtin).
 - **workflow-codification** — the codification loop for repeatable tasks: do the work hands-on under a capture session, mine the HAR, then codify it as scripts (scope-root `scripts/`) + a slash-invokable memory doc, with the self-heal rule that a failed script is re-derived and rewritten.
 - **plugins** — authoring a crtr plugin: the plugin.json manifest, directory layout, scopes, install mechanics, versioning, command plugins (contributing top-level CLI commands via commands.json + one executable), and configured CLIs (contributing commands as definition + HTTP from a remote manifest, no executable).

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

@@ -0,0 +1,45 @@
+---
+kind: knowledge
+when-and-why-to-read: When you need to know why a memory doc did or didn't load — or are deciding how a new doc should surface — this reference should be read because it names the hook, rung, gate, and ordering that produced the behavior, so you fix loading by turning the right dial instead of guessing at frontmatter.
+short-form: The complete load model — two hooks (boot catalog, file-read), the four-rung ladder, gates, applies-to/read-when routing, boot-render ordering, and store mounting/precedence.
+system-prompt-visibility: name
+file-read-visibility: none
+---
+
+# How memory loads
+
+Every memory doc declares its own loading policy in frontmatter; the runtime never guesses. Loading is two hooks, one four-rung dial per hook, an optional gate, and structural ordering. The authoring contract (flags, routing-line craft) is `crtr memory write -h`; which scope to write to is `internal/agent-shaping`; physical paths are `internal/storage-tiers`. This doc is the mechanics between those: what actually fires, when, and in what order.
+
+## The two hooks
+
+- **System prompt** (`system-prompt-visibility`) — the boot catalog assembled into every node's system prompt at revive.
+- **File read** (`file-read-visibility`) — context attached to the workspace or to files. Two events: **workspace mount** during first-message assembly (docs routed `applies-to: "."`), and a later **matching file read** (docs routed by glob). Nothing positional fires from where the doc happens to sit on disk — only from its declared route.
+
+Each doc sets both rungs explicitly; there is no kind-based default. Usually one axis carries a real rung and the other is `none`.
+
+## The rung ladder
+
+`none` → `name` → `preview` → `content`, per hook:
+
+- `none` — invisible on that hook; findable only by search/read. For archival docs and for the unused axis.
+- `name` — the bare title. The practical floor: an agent can't reach for a doc it has never seen named.
+- `preview` — name + the `when-and-why-to-read` routing line, rendered verbatim. The heart of progressive disclosure: one sentence that lets an agent decide whether to spend the read.
+- `content` — the full body inlined. Reserved for always-relevant docs that are either a bullet's worth of text or a wholly-important operating guide (the root INDEX shape below).
+
+`short-form` is **not** a rung and never enters agent context — it exists for humans browsing `crtr memory list`. Disclosure is name → routing line → whole thing; there is deliberately no "just the summary" level, because agents satisfice on abbreviations and never read the rest.
+
+## Gates and read-when
+
+An optional `gate` predicates visibility on the node's own config — kind, mode, orchestration depth, scope, cwd — using the standard matcher vocabulary (`crtr memory write -h`). No gate means always eligible. Persona prose is just gated content-rung docs (`gate: {kind: developer, mode: base}`); guidance that should scale with effort is one predicate (`orchestration.depth: {gte: 2}`), not a mechanism. `read-when` additionally matches the *read file's* frontmatter on the file-read hook; it refines a route but never replaces the required `applies-to` boundary.
+
+## Store mounting and precedence
+
+At boot/first-message assembly the runtime mounts: builtin docs, the user store (`~/.crouter/memory/`), the selected profile's store, and every project store — ancestor `.crouter/memory/` dirs walking up from cwd plus each project in the profile's purview. Physical duplicates are deduplicated; name collisions resolve nearest-first (project over profile over user over builtin), which is what lets a project doc shadow a builtin one.
+
+A root `INDEX.md` is a workspace's front door: `system-prompt-visibility: none`, `file-read-visibility: content`, `applies-to: "."` — the operating guide loads when that workspace mounts, not in every boot catalog. Multiple mounted roots render broad-to-specific, each under its own envelope name.
+
+## Ordering
+
+The boot render is structural, never a per-doc knob: docs group by rung (content bodies as prose, then previews, then names), and within a group order general-to-specific — scope first (builtin → user → profile → outermost project root → nearest), then tree position (higher directories before deeper), then filename. A numeric `NN-` filename prefix (stripped from the doc's name) is the sparing escape hatch when an exact sequence must be pinned.
+
+`crtr memory lint` is the validator for all of the above: frontmatter schema, both rungs present, routes on every non-`none` file-read rung, rung-scaled body length, dangling `[[links]]`, and each profile-managed project's front door.

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

@@ -2,8 +2,8 @@
 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
-system-prompt-visibility: none
-file-read-visibility: preview
+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.

package/dist/builtin-pi-packages/pi-crtr-extensions/README.md

@@ -32,7 +32,6 @@ directory's `node_modules/`.
 | Extension | What it does |
 |-----------|--------------|
 | `claude-plugin-commands.ts` | Surfaces commands and skills from `~/.claude`, the cwd, every project in the selected crouter profile, and installed plugins as pi slash commands with arg/shell-block execution. Writes shims to `~/.pi/agent/.plugin-command-shims/`. Skips any name pi already serves natively from `~/.pi/agent/prompts/` (e.g. crtr exports a slash command to both `~/.claude/commands` and `~/.pi/agent/prompts`), so the shim never collides with the native prompt. |
-| `crouter-help.ts` | Help integration for the `crtr` CLI. |
 | `provider-rotation.ts` | Subscription credential rotation across Anthropic / OpenAI-Codex: does its own OAuth login/refresh, rotates on rate-limits, falls back across the model ladder. Registers `/provider-sub <provider> <list\|add\|select\|rm>`. |
 | `crtr-commands/` | Auto-generates a slash command per `crtr` CLI node. The tree is derived in-process from crtr's own `buildRoot()` (no subprocesses, no cache on disk); `filters.json` controls which nodes are exposed. |
 | `sysprompt-window.ts` | Registers `/sysprompt`, which runs `crtr sys sysprompt --window` without injecting the prompt into context. |

package/dist/builtin-pi-packages/pi-crtr-extensions/extensions/__tests__/provider-rotation.test.ts

@@ -965,6 +965,7 @@ function makeRotationCtx(modelIntent?: string) {
     },
   } as any;
   const setModelCalls: any[] = [];
+  const thinkingLevelCalls: string[] = [];
   const providers: Record<string, { streamSimple: (...args: any[]) => AsyncIterable<any> }> = {};
   const events: Record<string, (...args: any[]) => unknown> = {};
   const commands: Record<string, { handler: (args: string, ctx: any) => unknown }> = {};
@@ -992,11 +993,42 @@ function makeRotationCtx(modelIntent?: string) {
       ctx.model = model;
       return true;
     },
-    setThinkingLevel(level: string) { ctx.thinkingLevel = level; },
+    setThinkingLevel(level: string) {
+      thinkingLevelCalls.push(level);
+      ctx.thinkingLevel = level;
+    },
   } as any;
-  return { ctx, setModelCalls, providers, events, commands, pi };
+  return { ctx, setModelCalls, thinkingLevelCalls, providers, events, commands, pi };
 }
 
+// A live route carries the session's exact thinking level through every provider
+// request, including the requests that continue a turn after tool results.
+test("preserves a manually selected thinking level across provider requests", async () => {
+  await resetRotationState();
+  writeLadderConfig();
+  await helpers.writeSubscriptionPool("openai-codex", [credential("codex")]);
+
+  const { ctx, thinkingLevelCalls, providers, events, pi } = makeRotationCtx("openai/strong");
+  ctx.thinkingLevel = "max";
+  rotationModule.__setStreamForProviderForTest(() => (async function* () {
+    yield { type: "text_delta", text: "continued after tool result" };
+  })() as any);
+
+  try {
+    await providerRotationExtension(pi);
+    await events.session_start?.({}, ctx);
+    const stream = providers["openai-codex"].streamSimple(ctx.model, ctx);
+    for await (const _event of stream) {
+      // Drain the managed-provider request to completion.
+    }
+
+    assert.deepEqual(thinkingLevelCalls, ["max"]);
+    assert.equal(ctx.thinkingLevel, "max");
+  } finally {
+    rotationModule.__setStreamForProviderForTest(undefined);
+  }
+});
+
 // Codex exhaustion switches the model and serves the same turn on the Anthropic fallback.
 test("falls back transparently and serves the turn on Anthropic when Codex is exhausted", async () => {
   await resetRotationState();

package/dist/builtin-pi-packages/pi-crtr-extensions/extensions/provider-rotation.ts

@@ -512,6 +512,8 @@ function emitTerminalError(stream: AssistantMessageEventStream, model: Model<any
 // turn-local cooling state.
 type RouteCandidate = {
   routeId: string;
+  credentialSource: string;
+  rank: number;
   providerId: string;
   model: Model<any>;
   thinkingLevel: string | undefined;
@@ -549,6 +551,12 @@ async function switchToRoute(pi: ExtensionAPI, ctx: ExtensionContext, candidate:
   return ctx.model?.provider === candidate.providerId && ctx.model.id === candidate.model.id;
 }
 
+function logRouteQueueAdvance(from: RouteCandidate, to: RouteCandidate | undefined, result: AttemptResult): void {
+  logRotation(
+    `from=${from.providerId}/${from.model.id} from_route_id=${from.routeId} from_credential_source=${from.credentialSource} from_rank=${from.rank} to=${to ? `${to.providerId}/${to.model.id}` : "none"} to_route_id=${to?.routeId ?? "none"} to_credential_source=${to?.credentialSource ?? "none"} to_rank=${to?.rank ?? "none"} reason=${result.classification?.reason ?? result.result}; advancing route queue`,
+  );
+}
+
 // Drive the deterministic route queue from the live rank. Managed routes walk
 // their pool rows; every other declared route is one configured credential.
 async function runManagedProvider(
@@ -570,7 +578,7 @@ async function runManagedProvider(
       if (!registry || !routeModel) return undefined;
       const availability = probeRouteAvailability(route, registry);
       if (!availability.registered || (!isManagedProvider(route.providerId) && !availability.authenticated)) return undefined;
-      return { routeId: route.routeId, providerId: route.providerId, model: routeModel, thinkingLevel: route.thinkingLevel };
+      return { routeId: route.routeId, credentialSource: route.credentialSource, rank: route.rank, providerId: route.providerId, model: routeModel, thinkingLevel: route.thinkingLevel };
     })
     .filter((candidate): candidate is RouteCandidate => candidate !== undefined);
   const isLiveRoute = (candidate: RouteCandidate): boolean =>
@@ -579,7 +587,7 @@ async function runManagedProvider(
   // later re-enter when a credential becomes ready, but it is never selected now.
   const candidates = routeCandidates.filter((candidate) => isLiveRoute(candidate) || !isManagedProvider(candidate.providerId) || readSubscriptionPool(candidate.providerId).some((entry) => entry.authFailure === undefined && (entry.rateLimitedUntil || 0) <= Date.now()));
   if (!candidates.some(isLiveRoute)) {
-    candidates.unshift({ routeId: `live:${model.provider}/${model.id}`, providerId: model.provider, model, thinkingLevel: undefined });
+    candidates.unshift({ routeId: `live:${model.provider}/${model.id}`, credentialSource: 'live', rank: liveRank, providerId: model.provider, model, thinkingLevel: liveThinking });
   }
 
   const queuedRouteIds = new Set(candidates.map((candidate) => candidate.routeId));
@@ -609,7 +617,7 @@ async function runManagedProvider(
       if (result.result === 'fatal') { stream.end(); return; }
       const cooldownMs = result.result === 'rate_limited' ? result.retryAfterMs ?? DEFAULT_RATE_LIMIT_BACKOFF_MS : TRANSIENT_ROTATE_COOLDOWN_MS;
       localCoolingDeadlines.set(routeId, Math.max(localCoolingDeadlines.get(routeId) ?? 0, Date.now() + cooldownMs));
-      logRotation(`${routeId} ${result.result === 'rate_limited' ? 'rate-limited' : 'transient failure'}; advancing route queue`);
+      logRouteQueueAdvance(candidate, candidates[0], result);
       continue;
     }
 
@@ -620,6 +628,7 @@ async function runManagedProvider(
     for (const credential of available) seenLabels.add(credential.label);
     seenReadyLabels.set(routeId, seenLabels);
 
+    let advanceResult: AttemptResult | undefined;
     for (const credential of available) {
       let freshCredential: ResolvedCredential;
       try {
@@ -654,9 +663,11 @@ async function runManagedProvider(
       } else {
         localCoolingDeadlines.set(routeId, Math.max(localCoolingDeadlines.get(routeId) ?? 0, Date.now() + cooldownMs));
       }
+      advanceResult = result;
     }
 
     enqueueFreshRouteCandidates(candidates, queuedRouteIds, knownRoutes, seenReadyLabels, cooldownAttempts, localCoolingDeadlines);
+    if (advanceResult !== undefined) logRouteQueueAdvance(candidate, candidates[0], advanceResult);
   }
 
   const coolingDeadline = earliestCoolingDeadline([...knownRoutes.values()], localCoolingDeadlines);

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

@@ -50,7 +50,7 @@ test('the attach viewer covers crtr bash tool calls and crtr-output messages nat
     const chatView = read(join(ROOT, 'clients', 'attach', 'render/chat-view.ts'));
     assert.match(chatView, /CRTR_OUTPUT_CUSTOM_TYPE/);
     assert.match(chatView, /new CrtrOutputMessageComponent\(/);
-    assert.match(chatView, /createCrtrBashToolDefinition\(args\)/);
+    assert.match(chatView, /createCrtrBashToolDefinition\(args,\s*fold\)/);
     // MinimizableToolComponent is the viewer's ToolExecutionComponent subclass (it
     // adds the Ctrl+O minimized state); the crtr tool definition still threads through it.
     assert.match(chatView, /new MinimizableToolComponent\([\s\S]*toolDefinition as never/);

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

@@ -16,6 +16,11 @@ const plainTheme = {
     bg(_name, text) { return text; },
     bold(text) { return text; },
 };
+/** pi calls tool renderers with a shared state bag; a normal (unfolded) call has an empty one. */
+function renderCrtrCall(definition, args) {
+    const definitionWithContext = definition;
+    return definitionWithContext.renderCall(args, theme, { state: {} });
+}
 function stripAnsi(text) {
     return text.replace(/\x1b\[[0-9;]*m/g, '');
 }
@@ -31,7 +36,7 @@ test('returns a viewer tool definition only for crtr bash commands', () => {
     assert.equal(createCrtrBashToolDefinition({ command: 'echo hi' }), undefined);
     const def = createCrtrBashToolDefinition({ command: 'crtr canvas dashboard' });
     assert.equal(typeof def.renderCall, 'function');
-    const rendered = def.renderCall({ command: 'crtr canvas dashboard' }, theme).render(80).join('\n');
+    const rendered = renderCrtrCall(def, { command: 'crtr canvas dashboard' }).render(80).join('\n');
     assert.equal(rendered.trimEnd().split('\n').length, 1);
     assert.match(rendered, new RegExp(iconForPath(['canvas', 'dashboard'])));
     assert.match(rendered, /crtr/);
@@ -165,7 +170,7 @@ test('a branch help preview with more subcommands than the line cap truncates wi
 // displayed crtr path and help detection include only the command segment.
 test('a shell redirect on the outer bash call never leaks into the displayed crtr path or help detection', () => {
     const def = createCrtrBashToolDefinition({ command: 'crtr push -h 2>&1' });
-    const rendered = def.renderCall({ command: 'crtr push -h 2>&1' }, theme).render(80).join('\n');
+    const rendered = renderCrtrCall(def, { command: 'crtr push -h 2>&1' }).render(80).join('\n');
     assert.match(rendered, new RegExp(HELP_ICON));
     assert.match(rendered, /crtr help/);
     assert.match(rendered, /<b>push<\/b>/);
@@ -175,18 +180,18 @@ test('a shell redirect on the outer bash call never leaks into the displayed crt
     // Other redirect shapes on the outer call, and mid-argv redirects, must
     // never survive into the path either.
     const other = createCrtrBashToolDefinition({ command: 'crtr node new --name foo > /tmp/log 2>&1' });
-    const otherRendered = other.renderCall({ command: 'crtr node new --name foo > /tmp/log 2>&1' }, theme).render(80).join('\n');
+    const otherRendered = renderCrtrCall(other, { command: 'crtr node new --name foo > /tmp/log 2>&1' }).render(80).join('\n');
     assert.match(otherRendered, /node new --name foo/);
     assert.doesNotMatch(otherRendered, /tmp\/log/);
     // Redirect operators glued to their target with NO space (`2>/tmp/out`,
     // `>/tmp/log`) are still shell plumbing and never displayed as path text.
     const noSpace = createCrtrBashToolDefinition({ command: 'crtr push -h 2>/tmp/out' });
-    const noSpaceRendered = noSpace.renderCall({ command: 'crtr push -h 2>/tmp/out' }, theme).render(80).join('\n');
+    const noSpaceRendered = renderCrtrCall(noSpace, { command: 'crtr push -h 2>/tmp/out' }).render(80).join('\n');
     assert.match(noSpaceRendered, /<b>push<\/b>/);
     assert.doesNotMatch(noSpaceRendered, /2>/);
     assert.doesNotMatch(noSpaceRendered, /tmp\/out/);
     const noSpaceMid = createCrtrBashToolDefinition({ command: 'crtr node new --name foo >/tmp/log' });
-    const noSpaceMidRendered = noSpaceMid.renderCall({ command: 'crtr node new --name foo >/tmp/log' }, theme).render(80).join('\n');
+    const noSpaceMidRendered = renderCrtrCall(noSpaceMid, { command: 'crtr node new --name foo >/tmp/log' }).render(80).join('\n');
     assert.match(noSpaceMidRendered, /node new --name foo/);
     assert.doesNotMatch(noSpaceMidRendered, /tmp\/log/);
 });
@@ -194,7 +199,7 @@ test('a shell redirect on the outer bash call never leaks into the displayed crt
 // body contains only synthesized preview content, never a repeated header.
 test('a collapsed help card never shows the help label twice (header + body)', () => {
     const def = createCrtrBashToolDefinition({ command: 'crtr canvas dashboard -h' });
-    const header = def.renderCall({ command: 'crtr canvas dashboard -h' }, theme).render(80).join('\n');
+    const header = renderCrtrCall(def, { command: 'crtr canvas dashboard -h' }).render(80).join('\n');
     const body = def
         .renderResult({ content: [{ type: 'text', text: LEAF_SCHEMA }] }, { expanded: false }, theme, {})
         .render(80)
@@ -414,7 +419,7 @@ test('a crtr memory lint with findings collapses to a findings count and warning
 // (possibly collapsed) result renders.
 test('renderCall shows a help-specific header for a -h/--help invocation, no bash chrome', () => {
     const def = createCrtrBashToolDefinition({ command: 'crtr node config -h' });
-    const rendered = def.renderCall({ command: 'crtr node config -h' }, theme).render(80).join('\n');
+    const rendered = renderCrtrCall(def, { command: 'crtr node config -h' }).render(80).join('\n');
     assert.equal(rendered.trimEnd().split('\n').length, 1);
     assert.match(rendered, new RegExp(HELP_ICON));
     assert.match(rendered, /crtr help/);
@@ -447,7 +452,7 @@ test('renderCall uses a mapped Nerd Font glyph and one line for every mapped roo
         // strip for width purposes), so the visible-width accounting used by the
         // real Text component's word-wrap counts that markup as content width —
         // a generous width keeps every case here well clear of an unrelated wrap.
-        const rendered = def.renderCall({ command }, theme).render(200).join('\n');
+        const rendered = renderCrtrCall(def, { command }).render(200).join('\n');
         assert.equal(rendered.trimEnd().split('\n').length, 1, `expected one line for ${command}`);
         assert.match(rendered, new RegExp(iconForPath(iconTokens)), `expected the ${iconTokens.join(' ')} glyph in ${command}`);
         assert.match(rendered, /crtr/, `expected "crtr" in ${command}`);
@@ -457,7 +462,7 @@ test('renderCall uses a mapped Nerd Font glyph and one line for every mapped roo
 });
 test('renderCall for a normal invocation previews the crtr path, not a raw bash echo', () => {
     const def = createCrtrBashToolDefinition({ command: 'crtr node config set foo bar' });
-    const rendered = def.renderCall({ command: 'crtr node config set foo bar' }, theme).render(200).join('\n');
+    const rendered = renderCrtrCall(def, { command: 'crtr node config set foo bar' }).render(200).join('\n');
     assert.equal(rendered.trimEnd().split('\n').length, 1);
     assert.match(rendered, new RegExp(iconForPath(['node', 'config'])));
     assert.match(rendered, /crtr/);

package/dist/clients/attach/__tests__/edit-diff.test.d.ts

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

package/dist/clients/attach/__tests__/edit-diff.test.js

@@ -0,0 +1,35 @@
+import assert from 'node:assert/strict';
+import test from 'node:test';
+import { createCrtrEditToolDefinition } from '../render/edit-diff.js';
+import { FoldedToolCallController } from '../render/tool-calls.js';
+const theme = {
+    fg: (_name, text) => text,
+    bg: (_name, text) => text,
+    bold: (text) => text,
+    getFgAnsi: (_name) => '',
+    getBgAnsi: (_name) => '',
+    getColorMode: () => 'truecolor',
+};
+test('edit cards stream argument diffs, then keep the executed result authoritative', () => {
+    const fold = new FoldedToolCallController();
+    const view = createCrtrEditToolDefinition(process.cwd(), fold);
+    const definition = view.definition;
+    const context = { cwd: process.cwd(), isError: false };
+    const streamedArgs = { path: 'example.ts', edits: [{ oldText: 'before', newText: 'streaming' }] };
+    const streamed = definition.renderCall(streamedArgs, theme, context).render(80).join('\n');
+    assert.match(streamed, /before/);
+    assert.match(streamed, /streaming/);
+    view.observeResult({
+        content: [{ type: 'text', text: 'edited' }],
+        details: { diff: '-10 before\n+10 executed\n+11 extra' },
+        isError: false,
+    }, false);
+    const laterArgs = { path: 'example.ts', edits: [{ oldText: 'before', newText: 'stale preview' }] };
+    const settled = definition.renderCall(laterArgs, theme, context).render(80).join('\n');
+    assert.match(settled, /executed/);
+    assert.doesNotMatch(settled, /stale preview/);
+    fold.setFolded(true);
+    const folded = definition.renderCall(laterArgs, theme, context).render(80).join('\n');
+    assert.match(folded, /\+2/);
+    assert.match(folded, /-1/);
+});

package/dist/clients/attach/__tests__/editor-frame-title.test.d.ts

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

package/dist/clients/attach/__tests__/editor-frame-title.test.js

@@ -0,0 +1,19 @@
+import { test } from 'node:test';
+import assert from 'node:assert/strict';
+import { editorLabel } from '../../../core/canvas/labels.js';
+import { displayEditorTitle } from '../session/editor-frame.js';
+test('a reloaded renamed session still shows its generated icon', () => {
+    const identity = { kind: 'general', mode: 'base', icon: '\uf188' };
+    assert.equal(displayEditorTitle('test', identity), '\uf188 test');
+    assert.equal(displayEditorTitle('\uf188 test', identity), '\uf188 test');
+});
+test('a node restart restores the explicit editor name instead of the generated description', () => {
+    const meta = {
+        name: 'test',
+        kind: 'general',
+        mode: 'base',
+        description: 'preserve-icon-on-rename',
+        icon: '\uf188',
+    };
+    assert.equal(editorLabel(meta), '\uf188 test');
+});

package/dist/clients/attach/render/chat-view.js

@@ -30,7 +30,7 @@ import { SITUATIONAL_CONTEXT_CUSTOM_TYPE } from '../../../core/runtime/situation
 import { transformMessageDiagrams } from './diagram.js';
 import { styleAttachMarkdownHeadings, styleAttachMessageMarkdown, styleAttachSummaryMarkdown, } from './markdown-headings.js';
 import { createCrtrEditToolDefinition } from './edit-diff.js';
-import { FOLDED_STATE_KEY, createCrtrPlainBashToolDefinition, createCrtrReadToolDefinition, createCrtrWriteToolDefinition, } from './tool-calls.js';
+import { FoldedToolCallController, createCrtrPlainBashToolDefinition, createCrtrReadToolDefinition, createCrtrWriteToolDefinition, } from './tool-calls.js';
 import { ringCompletionBell } from '../chrome/completion-bell.js';
 import { extractFilePaths } from '../visible-paths.js';
 import { FrozenHistoryComponent, keepWhenCondensed, liveRegionStart } from './frozen-history.js';
@@ -125,10 +125,15 @@ function stripBackground(line) {
         const kept = [];
         for (let i = 0; i < parts.length; i++) {
             const code = Number(parts[i] === '' ? 0 : parts[i]);
-            // Extended background (`48;5;n` / `48;2;r;g;b`) — skip the code AND its args.
-            if (code === 48) {
+            // Extended colors (`38` foreground, `48` background, `58` underline):
+            // consume the full sequence atomically so an RGB channel in the 40-47 or
+            // 100-107 range is not mistaken for a standalone background code.
+            if (code === 38 || code === 48 || code === 58) {
                 const mode = Number(parts[i + 1]);
-                i += mode === 5 ? 2 : mode === 2 ? 4 : 1;
+                const end = i + (mode === 5 ? 2 : mode === 2 ? 4 : 1);
+                if (code !== 48)
+                    kept.push(...parts.slice(i, end + 1));
+                i = end;
                 continue;
             }
             // Standard (40-47) and bright (100-107) backgrounds. `49` (reset to the
@@ -142,13 +147,10 @@ function stripBackground(line) {
     });
 }
 /** A tool component that can fold itself down to its CALL. pi's `ToolExecutionComponent`
- *  only knows expanded/collapsed, so the minimized state is crtr's — and the tool's own
- *  renderCall owns its folded form: every crtr-owned definition (read/write/edit/bash)
- *  reads the fold flag off its shared render-state bag and emits ONLY its one-line
- *  `<icon> <tool> <path>` header while folded. Folded render then paints just the call
- *  component (result and Box chrome dropped), so a wrapped path keeps its wrap rows
- *  naturally — no measuring or slicing of rendered ANSI rows. Tools without a crtr
- *  definition are not foldable and always render in full. */
+ *  only knows expanded/collapsed, so each crtr-owned definition receives a local fold
+ *  controller and captures the compact call component it renders. Folded render paints
+ *  that captured call directly, dropping result and Box chrome while letting a wrapped
+ *  path keep its natural rows. Tools without a crtr definition remain in full. */
 /** A one-line separator that appears only while its adjacent tool group is
  * folded. It stays in the transcript so toggling folded tools reflows the same
  * message/tool boundary without rebuilding the chat. */
@@ -169,30 +171,36 @@ class FoldedToolSeparator extends Spacer {
 }
 class MinimizableToolComponent extends ToolExecutionComponent {
     minimized = false;
-    foldable = false;
-    /** Only tools whose renderCall is fold-aware (the crtr-owned definitions) may
-     *  fold; chat-view marks them at construction. */
-    setFoldable(foldable) {
-        this.foldable = foldable;
+    expandedState = false;
+    foldController;
+    resultObserver;
+    /** A foldable definition owns its folded call component; an edit definition
+     *  may also observe results before the imported shell renders them. */
+    setToolView(foldController, resultObserver) {
+        this.foldController = foldController;
+        this.resultObserver = resultObserver;
     }
-    /** Flip the fold: expose it on the definitions' shared render-state bag, then
-     *  re-run `updateDisplay()` (the same path pi's own `setExpanded` uses) so the
-     *  fold-aware renderCall rebuilds the call component in its new form. NOT
-     *  `invalidate()` — pi's `ToolExecutionComponent.invalidate` recurses through
-     *  its renderer children and killed the viewer process. */
+    updateResult(...args) {
+        this.resultObserver?.(args[0], args[1] ?? false);
+        super.updateResult(...args);
+    }
+    setExpanded(expanded) {
+        this.expandedState = expanded;
+        super.setExpanded(expanded);
+    }
+    /** Flip the local fold state, then use the imported component's public
+     *  expansion setter to rebuild its call renderer at the current setting. */
     setMinimized(minimized) {
-        if (!this.foldable || this.minimized === minimized)
+        if (!this.foldController || this.minimized === minimized)
             return;
         this.minimized = minimized;
-        const internals = this;
-        internals.rendererState[FOLDED_STATE_KEY] = minimized;
-        internals.updateDisplay();
+        this.foldController.setFolded(minimized);
+        super.setExpanded(this.expandedState);
     }
     render(width) {
         if (!this.minimized)
             return super.render(width);
-        const call = this
-            .callRendererComponent;
+        const call = this.foldController?.callComponent();
         if (!call)
             return super.render(width);
         // trimEnd drops right-hand padding, which only existed to carry the
@@ -719,7 +727,7 @@ export class ChatView {
                         this.pendingTools.clear();
                     }
                     else {
-                        // Args complete → trigger diff computation for edit tools.
+                        // Finalize renderer caches now that every tool argument is complete.
                         for (const component of this.pendingTools.values()) {
                             component.setArgsComplete();
                             this.historyContainer.markDirty(component);
@@ -1015,18 +1023,26 @@ export class ChatView {
     }
     /** Tool component with native viewer renderers for crouter-owned tool output. */
     makeToolComponent(name, id, args) {
-        const toolDefinition = name === 'bash'
-            ? (createCrtrBashToolDefinition(args) ?? createCrtrPlainBashToolDefinition(this.cwd))
-            : name === 'edit'
-                ? createCrtrEditToolDefinition(this.cwd)
-                : name === 'read'
-                    ? createCrtrReadToolDefinition(this.cwd)
-                    : name === 'write'
-                        ? createCrtrWriteToolDefinition(this.cwd)
-                        : undefined;
+        const fold = new FoldedToolCallController();
+        let resultObserver;
+        let toolDefinition;
+        if (name === 'bash') {
+            toolDefinition = createCrtrBashToolDefinition(args, fold) ?? createCrtrPlainBashToolDefinition(this.cwd, fold);
+        }
+        else if (name === 'edit') {
+            const edit = createCrtrEditToolDefinition(this.cwd, fold);
+            toolDefinition = edit.definition;
+            resultObserver = edit.observeResult;
+        }
+        else if (name === 'read') {
+            toolDefinition = createCrtrReadToolDefinition(this.cwd, fold);
+        }
+        else if (name === 'write') {
+            toolDefinition = createCrtrWriteToolDefinition(this.cwd, fold);
+        }
         let component;
         component = new MinimizableToolComponent(name, id, args, { showImages: this.showImages, imageWidthCells: this.imageWidthCells }, toolDefinition, this.componentTui(() => component), this.cwd);
-        component.setFoldable(toolDefinition !== undefined);
+        component.setToolView(toolDefinition === undefined ? undefined : fold, resultObserver);
         component.setExpanded(this.toolOutputExpanded);
         return component;
     }

package/dist/clients/attach/render/crtr-output.d.ts

@@ -1,4 +1,5 @@
 import { Box } from '@earendil-works/pi-tui';
+import { FoldedToolCallController } from './tool-calls.js';
 type Theme = {
     fg: (name: string, text: string) => string;
     bg: (name: string, text: string) => string;
@@ -44,5 +45,5 @@ export declare class CrtrOutputMessageComponent extends Box {
     constructor(content: string, expanded: boolean, theme: Theme);
     setExpanded(expanded: boolean): void;
 }
-export declare function createCrtrBashToolDefinition(args: unknown): unknown | undefined;
+export declare function createCrtrBashToolDefinition(args: unknown, fold?: FoldedToolCallController): unknown | undefined;
 export {};