@north-light/crouter 0.3.162 → 0.3.163

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/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.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,34 @@
+import assert from 'node:assert/strict';
+import test from 'node:test';
+import { initTheme } from '@earendil-works/pi-coding-agent';
+import { FOLDED_STATE_KEY } from '../render/tool-calls.js';
+import { createCrtrEditToolDefinition } from '../render/edit-diff.js';
+initTheme(undefined, false);
+const theme = {
+    fg: (_name, text) => text,
+    bg: (_name, text) => text,
+    bold: (text) => text,
+    getFgAnsi: (_name) => '',
+    getBgAnsi: (_name) => '',
+    getColorMode: () => 'truecolor',
+};
+test('folded edit counts keep the executed diff when its speculative preview settles later', () => {
+    const definition = createCrtrEditToolDefinition(process.cwd());
+    const args = { path: 'example.ts', edits: [{ oldText: 'before', newText: 'after' }] };
+    const state = {};
+    const context = {
+        args,
+        argsComplete: false,
+        cwd: process.cwd(),
+        invalidate() { },
+        isError: false,
+        state,
+    };
+    definition.renderCall(args, theme, context);
+    definition.renderResult({ content: [{ type: 'text', text: 'edited' }], details: { diff: '- 1 before\n+ 1 after' } }, { isPartial: false }, theme, context);
+    state.callComponent.preview = { error: 'speculative preview completed after execution' };
+    state[FOLDED_STATE_KEY] = true;
+    const folded = definition.renderCall(args, theme, context).render(80).join('\n');
+    assert.match(folded, /\+1/);
+    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

@@ -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

package/dist/clients/attach/render/crtr-output.js

@@ -1,6 +1,7 @@
 import { truncateToVisualLines } from '@earendil-works/pi-coding-agent';
 import { Box, Text, truncateToWidth, visibleWidth, wrapTextWithAnsi } from '@earendil-works/pi-tui';
 import { HELP_ICON, iconForPath, suppressOutputForPath, summarizePath, } from '../../../core/preview-registry.js';
+import { isFoldedContext } from './tool-calls.js';
 // Hard cap on a collapsed crtr card's total rendered lines (rule 12,
 // inline-ui-placement): help synthesis or a normal truncated result never
 // shows more than this many lines total, blank spacer + status + body +
@@ -148,6 +149,32 @@ function commandFromArgs(args) {
     const command = args.command;
     return typeof command === 'string' ? command : '';
 }
+const CRTR_FLAG_TOKEN = /^-{1,2}[A-Za-z0-9]/;
+const CRTR_ATTACHED_FLAG_VALUE = /^(--?[A-Za-z0-9][^=]*)(=)(.*)$/;
+const CRTR_NUMBER_VALUE = /^-?(?:\d+(?:\.\d+)?|\.\d+)$/;
+/** Syntax-color flags and their values while leaving the command path and
+ * positional arguments in the folded row's existing bold title style. */
+function styleFoldedCrtrTokens(tokens, theme) {
+    let expectsValue = false;
+    return tokens.map((token) => {
+        const attached = CRTR_ATTACHED_FLAG_VALUE.exec(token);
+        if (attached !== null) {
+            expectsValue = false;
+            const valueColor = CRTR_NUMBER_VALUE.test(attached[3]) ? 'syntaxNumber' : 'syntaxString';
+            return `${theme.fg('syntaxKeyword', attached[1])}${theme.fg('syntaxOperator', attached[2])}${theme.fg(valueColor, attached[3])}`;
+        }
+        if (expectsValue && !CRTR_FLAG_TOKEN.test(token)) {
+            expectsValue = false;
+            return theme.fg(CRTR_NUMBER_VALUE.test(token) ? 'syntaxNumber' : 'syntaxString', token);
+        }
+        if (CRTR_FLAG_TOKEN.test(token)) {
+            expectsValue = true;
+            return theme.fg('syntaxKeyword', token);
+        }
+        expectsValue = false;
+        return theme.fg('toolTitle', theme.bold(token));
+    }).join(' ');
+}
 function resultText(result) {
     return (result.content ?? [])
         .filter((part) => part?.type === 'text' || typeof part?.text === 'string')
@@ -670,7 +697,7 @@ export function createCrtrBashToolDefinition(args) {
         label: 'bash',
         description: 'Render crtr bash output with crtr-specific chrome in the attach viewer.',
         parameters: {},
-        renderCall(callArgs, theme) {
+        renderCall(callArgs, theme, context) {
             const currentCommand = commandFromArgs(callArgs) || command;
             // Semantic card, not a bash echo: the header names what the invocation
             // IS (help schema vs. a crtr command), and the body previews only the
@@ -684,7 +711,9 @@ export function createCrtrBashToolDefinition(args) {
             const icon = isHelp ? HELP_ICON : iconForPath(pathTokens);
             const prefix = isHelp ? `${icon} crtr help` : `${icon} crtr`;
             const styledPrefix = theme.fg('accent', theme.bold(prefix));
-            const styledPath = path ? ` ${theme.fg('toolTitle', theme.bold(path))}` : '';
+            const styledPath = path
+                ? ` ${isFoldedContext(context) ? styleFoldedCrtrTokens(pathTokens, theme) : theme.fg('toolTitle', theme.bold(path))}`
+                : '';
             return new Text(`${styledPrefix}${styledPath}`, 0, 0);
         },
         renderResult(result, options, theme, context) {

package/dist/clients/attach/render/edit-diff.js

@@ -102,6 +102,20 @@ function parseDiffLine(line) {
         return null;
     return { prefix: match[1], lineNum: match[2], content: match[3] };
 }
+/** Count only changed rows in pi's display diff; context and ellipsis rows do
+ *  not contribute to the folded file summary. */
+function countDiffLines(diff) {
+    let added = 0;
+    let removed = 0;
+    for (const line of diff.split('\n')) {
+        const parsed = parseDiffLine(line);
+        if (parsed?.prefix === '+')
+            added++;
+        if (parsed?.prefix === '-')
+            removed++;
+    }
+    return { added, removed };
+}
 function replaceTabs(text) {
     return text.replace(/\t/g, '   ');
 }
@@ -247,7 +261,11 @@ export function createCrtrEditToolDefinition(cwd) {
             if (isFoldedContext(context)) {
                 const a = args;
                 const raw = typeof a?.file_path === 'string' ? a.file_path : typeof a?.path === 'string' ? a.path : '';
-                return new Text(foldedFileCallLine('edit', raw, theme, context.cwd ?? cwd), 0, 0);
+                const preview = context.state.callComponent?.preview;
+                const changes = context.isError
+                    ? undefined
+                    : context.state.settledChanges ?? (preview && !('error' in preview) ? countDiffLines(preview.diff) : undefined);
+                return new Text(foldedFileCallLine('edit', raw, theme, context.cwd ?? cwd, changes), 0, 0);
             }
             const component = builtin.renderCall(args, theme, context);
             const callBox = context.state.callComponent;
@@ -258,6 +276,13 @@ export function createCrtrEditToolDefinition(cwd) {
             return component;
         },
         renderResult(result, options, theme, context) {
+            const resultDiff = result?.details?.diff;
+            if (!options?.isPartial) {
+                if (!context.isError && typeof resultDiff === 'string')
+                    context.state.settledChanges = countDiffLines(resultDiff);
+                else
+                    delete context.state.settledChanges;
+            }
             const component = builtin.renderResult(result, options, theme, context);
             const callBox = context.state.callComponent;
             if (callBox) {
@@ -269,7 +294,6 @@ export function createCrtrEditToolDefinition(cwd) {
             }
             // Fallback path (no call box state, e.g. a bare result replay): render
             // the result diff standalone. No host Box here, so restore to default bg.
-            const resultDiff = result?.details?.diff;
             if (!context.isError && typeof resultDiff === 'string') {
                 const container = new Container();
                 container.addChild(new Spacer(1));

package/dist/clients/attach/render/tool-calls.d.ts

@@ -11,8 +11,13 @@ export declare const FOLDED_STATE_KEY = "crtrFolded";
 export declare function isFoldedContext(context: {
     state?: object;
 }): boolean;
-/** The one-line folded form of a file tool's call: `<icon> <label> <path>`. */
-export declare function foldedFileCallLine(tool: 'read' | 'write' | 'edit', rawPath: string, theme: Theme, cwd: string): string;
+export type FileLineChanges = {
+    added: number;
+    removed: number;
+};
+/** The one-line folded form of a file tool's call: `<icon> <label> <path>`,
+ *  optionally followed by its green/red changed-line counts. */
+export declare function foldedFileCallLine(tool: 'read' | 'write' | 'edit', rawPath: string, theme: Theme, cwd: string, changes?: FileLineChanges): string;
 /** Prefix a pi-built `Text` in place (its `text` field is TS-private but a plain
  *  runtime property). Used where the header line is baked into the same string as
  *  a body we want to keep verbatim — write's syntax-highlighted content preview,

package/dist/clients/attach/render/tool-calls.js

@@ -28,9 +28,29 @@ export const FOLDED_STATE_KEY = 'crtrFolded';
 export function isFoldedContext(context) {
     return context.state?.[FOLDED_STATE_KEY] === true;
 }
-/** The one-line folded form of a file tool's call: `<icon> <label> <path>`. */
-export function foldedFileCallLine(tool, rawPath, theme, cwd) {
-    return `${header(TOOL_ICON[tool], tool, theme)} ${pathDisplay(rawPath, theme, cwd)}`;
+/** Count file lines the way a diff does: a trailing newline terminates the last
+ *  line instead of creating an extra empty one. */
+function countFileLines(content) {
+    if (content.length === 0)
+        return 0;
+    const newlines = content.match(/\n/g)?.length ?? 0;
+    return newlines + (content.endsWith('\n') ? 0 : 1);
+}
+/** The green/red line-count suffix shown after a folded write/edit path. */
+function lineChangesDisplay(changes, theme) {
+    if (!changes)
+        return '';
+    const counts = [];
+    if (changes.added > 0)
+        counts.push(theme.fg('toolDiffAdded', `+${changes.added}`));
+    if (changes.removed > 0)
+        counts.push(theme.fg('toolDiffRemoved', `-${changes.removed}`));
+    return counts.length > 0 ? ` ${counts.join(' ')}` : '';
+}
+/** The one-line folded form of a file tool's call: `<icon> <label> <path>`,
+ *  optionally followed by its green/red changed-line counts. */
+export function foldedFileCallLine(tool, rawPath, theme, cwd, changes) {
+    return `${header(TOOL_ICON[tool], tool, theme)} ${pathDisplay(rawPath, theme, cwd)}${lineChangesDisplay(changes, theme)}`;
 }
 /** `~`-shorten an absolute path the way pi's renderToolPath does (its
  *  render-utils module is not exported from the package root). */
@@ -113,7 +133,8 @@ export function createCrtrWriteToolDefinition(cwd) {
         renderCall(args, theme, context) {
             if (isFoldedContext(context)) {
                 const a = args;
-                const line = foldedFileCallLine('write', str(a?.file_path ?? a?.path), theme, context.cwd ?? cwd);
+                const changes = context.isError ? undefined : { added: countFileLines(str(a?.content)), removed: 0 };
+                const line = foldedFileCallLine('write', str(a?.file_path ?? a?.path), theme, context.cwd ?? cwd, changes);
                 // Reuse the previous component when it is Text-like (the builtin's is a
                 // Text subclass), so fold toggles don't churn component identity.
                 const last = context.lastComponent;

package/dist/clients/attach/session/connection.d.ts

@@ -30,7 +30,7 @@ export interface AttachConnection {
     readonly meta: Pick<NodeMeta, 'cwd' | 'profile_id'>;
     /** The attached node's persona/lifecycle, when this canvas can tell us —
      *  `undefined` for a remote attach until the viewer refetches it. */
-    readonly nodeIdentity: Pick<NodeMeta, 'kind' | 'mode' | 'lifecycle'> | undefined;
+    readonly nodeIdentity: Pick<NodeMeta, 'kind' | 'mode' | 'lifecycle' | 'icon'> | undefined;
     /** The one socket to the node's headless broker, already connected. */
     readonly socket: BrokerClient;
     /** Re-throw a connect-adjacent failure that landed AFTER `connect` resolved.

package/dist/clients/attach/session/editor-frame.d.ts

@@ -14,7 +14,7 @@ export declare function resolveEditorFrameStyles(bashMode: 0 | 1 | 2, thinkingLe
 export interface EditorChromeHooks {
     /** The viewer's live node identity — a `let` runAttach owns and refreshes
      *  (remote attach starts without one), so it MUST stay a getter. */
-    nodeIdentity: () => Pick<NodeMeta, 'kind' | 'mode' | 'lifecycle'> | undefined;
+    nodeIdentity: () => Pick<NodeMeta, 'kind' | 'mode' | 'lifecycle' | 'icon'> | undefined;
     /** The engine's current thinking level, from live session state. */
     thinkingLevel: () => BrokerSnapshot['state']['thinkingLevel'] | undefined;
     /** Repaint the status line — the bash-level segment tracks `bashMode`. */
@@ -36,6 +36,10 @@ export interface EditorChrome {
     /** Kick an async git-status fetch that repaints the top border. */
     pollGit: () => void;
 }
+/** Render the generated task icon on every non-empty editor title. Session
+ * names are persisted independently by pi, so this derives the icon from the
+ * canvas identity again whenever a viewer attaches or reloads. */
+export declare function displayEditorTitle(sessionName: string | undefined, identity: Pick<NodeMeta, 'kind' | 'mode' | 'icon'> | undefined): string;
 /** The editor-chrome collaborator: owns the shell/bash level (`deriveBashMode`
  *  over `editor.onChange` is its ONE writer) and the `/color` chip override,
  *  and paints every frame-attached adornment — border hue, title chip, context