@crouton-kit/crouter 0.3.81 → 0.3.83

package/dist/builtin-pi-packages/pi-mode-switch/README.md

@@ -1,6 +1,6 @@
 # pi-mode-switch
 
-Cycle between operating modes with crouter's configurable **Cycle mode** binding (default **Alt+M**) — the way Claude's Shift+Tab cycles plan / accept-edits. Whenever the mode changes, the new mode's operating instructions are injected invisibly before your next message.
+Cycle between operating modes with crouter's configurable **Cycle mode** binding (default **Alt+Shift+P**) — the way Claude's Shift+Tab cycles plan / accept-edits. Whenever the mode changes, the new mode's operating instructions are injected invisibly before your next message.
 
 ## Modes
 
@@ -12,7 +12,7 @@ Cycle between operating modes with crouter's configurable **Cycle mode** binding
 
 ## Usage
 
-- the configured `crtr.mode.cycle` binding (default `Alt+M`) — cycle `normal → spec → plan → normal`
+- the configured `crtr.mode.cycle` binding (default `Alt+Shift+P`) — cycle `normal → spec → plan → normal`
 - `/mode` — cycle without using the shortcut
 - `/mode <normal\|spec\|plan>` — jump to a specific mode
 - the agent can switch its own mode by running the bundled `bin/mode` CLI through its bash tool — e.g. `bash <plugin>/bin/mode normal` after a spec/plan is approved. The command prints that mode's guidance, so the text only enters context at the moment of the switch (no always-on tool)
@@ -33,4 +33,4 @@ The input badge is drawn by wrapping whatever editor is already installed (for e
 
 This package ships inside crouter. `crtr sys setup` registers its built package path with pi; there is no separate repository or package to install.
 
-Run `/reload` in pi after setup. The extension resolves `crtr.mode.cycle` from the sparse `keybindings` object in `~/.crouter/config.json`; missing overrides use Alt+M, multiple gestures all register, and an empty list disables the shortcut. `/mode` remains available when the shortcut is disabled. Pi's stock actions and `~/.pi/agent/keybindings.json` remain untouched.
+Run `/reload` in pi after setup. The extension resolves `crtr.mode.cycle` from the sparse `keybindings` object in `~/.crouter/config.json`; missing overrides use Alt+Shift+P, multiple gestures all register, and an empty list disables the shortcut. `/mode` remains available when the shortcut is disabled. Pi's stock actions and `~/.pi/agent/keybindings.json` remain untouched.

package/dist/clients/attach/__tests__/attach-chrome-remote.test.js

@@ -172,13 +172,21 @@ test('buildCanvasPanelLines suppresses every local-read adornment for a RemoteCa
     // (see the CI-hang postmortem on rebuild-coalescer.test.ts).
     t.after(() => server.close());
     const source = new RemoteCanvasSource(server.url, 'tok');
-    // 'root' has 'a' as a live report → row('a') renders into `reports`.
-    const { reports } = await buildCanvasPanelLines('root', {}, IDENTITY_PALETTE, source);
-    assert.equal(reports.length, 1);
-    const line = reports[0];
+    // The stable family roster shown when attached to 'root' is root-first:
+    // the root row followed by its one live child 'a' (root has no non-human
+    // manager, so it is its own roster root). The poisoned local node id is 'a',
+    // so the load-bearing assertions must target the 'a' ROW specifically —
+    // `reportIds` maps each rendered row to its node id in render order.
+    const { reports, reportIds } = await buildCanvasPanelLines('root', {}, IDENTITY_PALETTE, source);
+    assert.deepEqual(reportIds, ['root', 'a'], 'roster is root-first: the attached root then its live child');
+    assert.equal(reports.length, 2);
+    const line = reports[reportIds.indexOf('a')];
     assert.ok(!line.includes('1000k'), `local telemetry (999999 tokens) must not leak into a remote row: ${line}`);
     assert.ok(!line.includes('POISON'), `poisoned local text must never appear in a remote row: ${line}`);
     assert.ok(!line.includes('⚠'), `a local active fault must not surface as the hanging glyph on a remote row: ${line}`);
+    // The 'a' row is NOT the attached node ('root' is), so a legitimate
+    // you-are-here bar never applies to it — any BG_ATTACHED here could only
+    // come from the poisoned LOCAL focus/attach on id 'a', which must be ignored.
     assert.ok(!line.includes(BG_ATTACHED), `a local focus/attach must not paint a remote row as attached: ${line}`);
 });
 test('GraphOverlay suppresses every local-read adornment for a RemoteCanvasSource AND makes Enter/m/x no-ops, even with conflicting local state for the same node id', async (t) => {

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

@@ -30,6 +30,7 @@ test('attach input dispatches only the current configured action', () => {
         'crtr.attach.graph.toggle': [],
         'crtr.mode.cycle': ['alt+x'],
         'crtr.attach.model-ladder.next': ['alt+z'],
+        'crtr.attach.model-ladder.previous': ['alt+y'],
     });
     const calls = [];
     const actions = {
@@ -38,15 +39,18 @@ test('attach input dispatches only the current configured action', () => {
         'crtr.attach.graph.toggle': () => calls.push('graph'),
         'crtr.mode.cycle': () => calls.push('mode'),
         'crtr.attach.model-ladder.next': () => calls.push('ladder'),
+        'crtr.attach.model-ladder.previous': () => calls.push('ladder-back'),
     };
     assert.equal(dispatchAttachBinding(bindings, '\x18', actions), true);
     assert.equal(dispatchAttachBinding(bindings, '\x04', actions), false, 'old detach must not reach the listener action');
     assert.equal(dispatchAttachBinding(bindings, '\x1bg', actions), false, 'disabled graph must not reach the listener action');
     assert.equal(dispatchAttachBinding(bindings, '\x1bx', actions), true);
-    assert.equal(dispatchAttachBinding(bindings, '\x1bm', actions), false, 'old mode key must not reach the listener action');
+    assert.equal(dispatchAttachBinding(bindings, '\x1bP', actions), false, 'old mode key must not reach the listener action');
     assert.equal(dispatchAttachBinding(bindings, '\x1bz', actions), true);
-    assert.equal(dispatchAttachBinding(bindings, '\x1bM', actions), false, 'old ladder key must not reach the listener action');
-    assert.deepEqual(calls, ['detach', 'mode', 'ladder']);
+    assert.equal(dispatchAttachBinding(bindings, '\x1bm', actions), false, 'old ladder key must not reach the listener action');
+    assert.equal(dispatchAttachBinding(bindings, '\x1by', actions), true);
+    assert.equal(dispatchAttachBinding(bindings, '\x1bM', actions), false, 'old ladder-back key must not reach the listener action');
+    assert.deepEqual(calls, ['detach', 'mode', 'ladder', 'ladder-back']);
     assert.equal(detachHint(bindings), 'Ctrl+X', 'disabled clear-or-detach must fall back to enabled detach');
     const noDetach = resolveKeybindings({ 'crtr.attach.detach': [], 'crtr.attach.clear-or-detach': [] });
     assert.equal(detachHint(noDetach), undefined, 'a disabled pair must not render "Disabled to detach"');

package/dist/clients/attach/__tests__/chat-view-snapshot-ordering.test.js

@@ -0,0 +1,104 @@
+// Regression coverage for the single-writer snapshot ordering in ChatView
+// (chat-view.ts). A large NON-streaming catch-up yields to the event loop
+// mid-build so queued stdin drains; that yield window used to let later broker
+// frames mutate a half-rebuilt transcript. Two races are pinned here:
+//
+//   1. Live turn frames arriving during a yielded welcome must be replayed
+//      AFTER the build finishes (not interleaved), and their streaming/volatility
+//      state must survive — the resuming build's stale non-streaming completion
+//      must not overwrite it.
+//   2. A second welcome delivered while the first build is suspended must
+//      supersede it outright: the newest snapshot wins and the stale build
+//      abandons itself instead of appending into the replaced transcript.
+import assert from 'node:assert/strict';
+import test from 'node:test';
+import { Container, TUI } from '@earendil-works/pi-tui';
+import { AssistantMessageComponent, UserMessageComponent, } from '@earendil-works/pi-coding-agent';
+import { ChatView } from '../chat-view.js';
+/** A headless terminal so TUI.requestRender's scheduled writes are no-ops (the
+ *  test only inspects component state, never real output). */
+function fakeTerminal() {
+    return {
+        start() { },
+        stop() { },
+        async drainInput() { },
+        write() { },
+        get columns() { return 80; },
+        get rows() { return 24; },
+        get kittyProtocolActive() { return false; },
+        moveBy() { },
+        hideCursor() { },
+        showCursor() { },
+        clearLine() { },
+        clearFromCursor() { },
+        clearScreen() { },
+        setTitle() { },
+        setProgress() { },
+    };
+}
+function makeChatView() {
+    const tui = new TUI(fakeTerminal());
+    const container = new Container();
+    const view = new ChatView(tui, container);
+    const internals = view;
+    return { view, historyChildren: () => internals.historyContainer.children, internals };
+}
+/** A non-streaming snapshot of `count` assistant text messages. Enough messages
+ *  (>2× SNAPSHOT_YIELD_EVERY) to guarantee the build suspends at least once. */
+function assistantSnapshot(count, tag) {
+    const messages = Array.from({ length: count }, (_, i) => ({
+        role: 'assistant',
+        content: [{ type: 'text', text: `${tag}-${i}` }],
+        stopReason: 'endTurn',
+    }));
+    return {
+        messages,
+        stats: {},
+        state: { isStreaming: false },
+    };
+}
+const countOf = (children, ctor) => children.filter((c) => c instanceof ctor).length;
+test('live turn frames arriving during a yielded welcome replay after the build and keep streaming state', async () => {
+    const { view, historyChildren, internals } = makeChatView();
+    // Start a large non-streaming catch-up: it appends the first chunk of
+    // components synchronously, then suspends at the first event-loop yield.
+    const build = view.applySnapshot(assistantSnapshot(120, 'snap'));
+    assert.equal(internals.applyingSnapshot, true, 'build is in flight after the first synchronous chunk');
+    // Live turn frames arrive while the build is suspended — these must be
+    // deferred, not applied to the half-rebuilt view.
+    view.handleEvent({ type: 'agent_start' });
+    view.handleEvent({ type: 'message_start', message: { role: 'user', content: 'LIVE' } });
+    await build;
+    const children = historyChildren();
+    // All 120 snapshot assistant components are present and precede the one live
+    // user message that was deferred and replayed at the tail.
+    assert.equal(countOf(children, AssistantMessageComponent), 120, 'every snapshot message survived the build');
+    assert.equal(countOf(children, UserMessageComponent), 1, 'exactly the one deferred live user message landed');
+    const lastReal = [...children].reverse().find((c) => c instanceof UserMessageComponent || c instanceof AssistantMessageComponent);
+    assert.ok(lastReal instanceof UserMessageComponent, 'the live message is appended AFTER the whole snapshot, not interleaved');
+    // The replayed agent_start owns the final volatility/activity state — the
+    // resuming build's stale non-streaming completion did NOT overwrite it.
+    assert.equal(internals.applyingSnapshot, false, 'gate released after the build');
+    assert.equal(internals.historyContainer.volatile, true, 'live turn keeps history volatile (cache bypassed)');
+    assert.notEqual(internals.activityLoader, undefined, 'the working loader from the live agent_start is present');
+    // Cleanup: the live loader runs a spinner interval that would otherwise hold
+    // the event loop (and the test process) open forever.
+    internals.setActivity(undefined);
+});
+test('a second welcome delivered mid-build supersedes the first and the stale build abandons itself', async () => {
+    const { view, historyChildren, internals } = makeChatView();
+    // First large build suspends at its first yield.
+    const first = view.applySnapshot(assistantSnapshot(120, 'first'));
+    assert.equal(internals.snapshotGeneration, 1);
+    // A newer welcome arrives while the first is suspended — resets and rebuilds
+    // synchronously (small, no yield), bumping the generation.
+    const second = view.applySnapshot(assistantSnapshot(3, 'second'));
+    assert.equal(internals.snapshotGeneration, 2, 'the newer welcome opened a new generation');
+    await Promise.all([first, second]);
+    // Only the second snapshot's transcript remains: the stale first build saw the
+    // generation change after resuming and returned without appending its tail.
+    const children = historyChildren();
+    assert.equal(countOf(children, AssistantMessageComponent), 3, 'newest welcome wins; no interleaved stale tail');
+    assert.equal(internals.applyingSnapshot, false, 'gate released');
+    assert.equal(internals.historyContainer.volatile, false, 'second (non-streaming) snapshot set the final state');
+});

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

@@ -1318,84 +1318,56 @@ test('crtr push urgent/final cards collapse to a one-line outcome + report basen
 // ---------------------------------------------------------------------------
 // Batch C — human/memory/pkg summarizers (preview-registry.ts "Batch C")
 // ---------------------------------------------------------------------------
-const HUMAN_ASK_DELIVERED_OUTPUT = [
+// Ask and review now share the single QUEUED_FOLLOW_UP road-sign (prompts.ts):
+// arrival is always just durable queue state, so there is no drained/delivered
+// fork — the card collapses to one posted line.
+const QUEUED_FOLLOW_UP = "Queued for the human. Their answer is pushed to your inbox and wakes you when they respond — never poll, verify it opened, or block. Press ⌥I (or run `hl inbox open` at a terminal) to see the queue.";
+const HUMAN_ASK_QUEUED_OUTPUT = [
     '- job_id: mrASK0001',
     '',
     '**dir:** /Users/silas/Code/cli/crouter',
     '',
-    "**follow_up:** The human's answer is delivered to your inbox when they respond — no need to poll.",
+    `**follow_up:** ${QUEUED_FOLLOW_UP}`,
 ].join('\n');
-const HUMAN_ASK_DRAINED_OUTPUT = [
-    '- job_id: mrASK0002',
-    '',
-    '**dir:** /Users/silas/Code/cli/crouter',
-    '',
-    '**follow_up:** Not in tmux: a human must drain it — run `crtr human inbox` (or re-run inside tmux). The answer then arrives in your inbox.',
-].join('\n');
-test('a crtr human ask card collapses to a posted/drained status + question teaser, not the raw fields', () => {
+test('a crtr human ask card collapses to a posted status + question teaser, not the raw fields', () => {
     const def = createCrtrBashToolDefinition({ command: 'crtr human ask "Should we ship the preview rollout now?"' });
     const collapsed = def
-        .renderResult({ content: [{ type: 'text', text: HUMAN_ASK_DELIVERED_OUTPUT }] }, { expanded: false }, theme, {})
+        .renderResult({ content: [{ type: 'text', text: HUMAN_ASK_QUEUED_OUTPUT }] }, { expanded: false }, theme, {})
         .render(140)
         .join('\n');
     assert.match(collapsed, /<accent>ask posted → waiting on human<\/accent>/);
     assert.match(collapsed, /<muted>Should we ship the preview rollout now\?<\/muted>/);
     assert.doesNotMatch(collapsed, /- job_id:/);
     const expanded = def
-        .renderResult({ content: [{ type: 'text', text: HUMAN_ASK_DELIVERED_OUTPUT }] }, { expanded: true }, theme, {})
+        .renderResult({ content: [{ type: 'text', text: HUMAN_ASK_QUEUED_OUTPUT }] }, { expanded: true }, theme, {})
         .render(140)
         .join('\n');
     assert.match(expanded, /job_id: mrASK0001/);
-    assert.match(expanded, /no need to poll/);
-    const drained = def
-        .renderResult({ content: [{ type: 'text', text: HUMAN_ASK_DRAINED_OUTPUT }] }, { expanded: false }, theme, {})
-        .render(140)
-        .join('\n');
-    assert.match(drained, /<warning>ask posted — drain via `human inbox`<\/warning>/);
-    assert.match(drained, /<muted>Should we ship the preview rollout now\?<\/muted>/);
-    const drainedExpanded = def
-        .renderResult({ content: [{ type: 'text', text: HUMAN_ASK_DRAINED_OUTPUT }] }, { expanded: true }, theme, {})
-        .render(140)
-        .join('\n');
-    assert.match(drainedExpanded, /Not in tmux: a human must drain it/);
+    assert.match(expanded, /wakes you when they respond/);
 });
-const HUMAN_REVIEW_LIVE_OUTPUT = [
+const HUMAN_REVIEW_QUEUED_OUTPUT = [
     '- job_id: mrREV0001',
     '',
     '**dir:** /Users/silas/Code/cli/crouter',
     '',
     '**output:** /Users/silas/Code/cli/crouter/spec.review.md',
     '',
-    "**follow_up:** The document is live on the human's screen for anchored, line-by-line review. The pane tracks the file — edit the .md in place and it re-renders on save, so never cancel and re-present just to show a change. Do not poll, verify it opened, or background this call; end your turn. The human reviews on their own time, and their comments (with any line edits) arrive in your inbox and wake you when they submit.",
+    `**follow_up:** ${QUEUED_FOLLOW_UP}`,
 ].join('\n');
-const HUMAN_REVIEW_DRAINED_OUTPUT = [
-    '- job_id: mrREV0002',
-    '',
-    '**dir:** /Users/silas/Code/cli/crouter',
-    '',
-    '**output:** /Users/silas/Code/cli/crouter/spec.review.md',
-    '',
-    '**follow_up:** Not in tmux: a human must drain it — run `crtr human inbox` (or re-run inside tmux). The answer then arrives in your inbox.',
-].join('\n');
-test('a crtr human review card collapses to a posted/drained status + file basename, not the raw fields', () => {
+test('a crtr human review card collapses to a posted status + file basename, not the raw fields', () => {
     const def = createCrtrBashToolDefinition({ command: 'crtr human review /Users/silas/Code/cli/crouter/spec.md' });
     const collapsed = def
-        .renderResult({ content: [{ type: 'text', text: HUMAN_REVIEW_LIVE_OUTPUT }] }, { expanded: false }, theme, {})
+        .renderResult({ content: [{ type: 'text', text: HUMAN_REVIEW_QUEUED_OUTPUT }] }, { expanded: false }, theme, {})
         .render(140)
         .join('\n');
     assert.match(collapsed, /<accent>review posted: spec\.md → waiting on human<\/accent>/);
     assert.doesNotMatch(collapsed, /- job_id:/);
     const expanded = def
-        .renderResult({ content: [{ type: 'text', text: HUMAN_REVIEW_LIVE_OUTPUT }] }, { expanded: true }, theme, {})
+        .renderResult({ content: [{ type: 'text', text: HUMAN_REVIEW_QUEUED_OUTPUT }] }, { expanded: true }, theme, {})
         .render(140)
         .join('\n');
     assert.match(expanded, /job_id: mrREV0001/);
-    assert.match(expanded, /anchored, line-by-line review/);
-    const drained = def
-        .renderResult({ content: [{ type: 'text', text: HUMAN_REVIEW_DRAINED_OUTPUT }] }, { expanded: false }, theme, {})
-        .render(140)
-        .join('\n');
-    assert.match(drained, /<warning>review posted: spec\.md — drain via `human inbox`<\/warning>/);
+    assert.match(expanded, /wakes you when they respond/);
 });
 const HUMAN_LIST_OUTPUT = [
     '- total: 2',

package/dist/clients/attach/attach-cmd.d.ts

@@ -1,5 +1,4 @@
 import { CombinedAutocompleteProvider } from '@earendil-works/pi-tui';
-import type { BranchDef } from '../../core/command.js';
 import type { BrokerSnapshot, ClientRole } from '../../core/runtime/broker-protocol.js';
 import { type BindingId, type BindingResolution } from '../../core/keybindings/index.js';
 import { type AttachPalette } from './config-load.js';
@@ -52,5 +51,5 @@ export declare function buildAttachAutocompleteProvider(cwd: string, fdPath: str
     name: string;
     description?: string;
 }>, cwd: string, fdPath: string | null) => CombinedAutocompleteProvider): CombinedAutocompleteProvider;
-export declare function registerAttach(): BranchDef;
+export declare function runAttach(nodeId: string, observer: boolean, canvasName?: string): Promise<void>;
 export {};