@crouton-kit/crouter 0.3.27 → 0.3.29

package/dist/builtin-views/workspace-sidebar/tui.mjs

@@ -0,0 +1,142 @@
+// @ts-check
+/**
+ * Workspace Sidebar — the TUI presenter (`render` + `keymap`) for the
+ * `workspace-sidebar` view. Node-only (it uses the host's `Draw` API + the
+ * `_lib/states.mjs` draw helpers).
+ *
+ * `render` paints a two-section rail; keystrokes map to named intents through
+ * `keymap`. All state + data logic lives in `core.mjs`; this file is a pure
+ * read of the logical `RailRow[]`.
+ *
+ * VISUAL LANGUAGE (mirrors the `canvas` view): hierarchy via weight + hue +
+ * position, never boxes. Status glyph hues match `canvas browse` (active=green,
+ * idle=yellow, done=cyan, dead=red, canceled=grey; asks=bright-yellow). Color
+ * never carries meaning alone — every hue pairs with a glyph/weight (NO_COLOR-
+ * safe). The attached node carries a `▸` accent + bold name. ⚑N attention flags
+ * right-flush into a clean column.
+ *
+ * @module workspace-sidebar/tui
+ */
+
+import { loadingState, emptyState, notReadyState } from '../_lib/states.mjs';
+
+/** @typedef {import('./core.mjs').SidebarState} SidebarState */
+/** @typedef {import('./core.mjs').RailRow} RailRow */
+
+// ── Status vocabulary (single source: core/canvas/browse/render.ts) ───────────
+
+/** @type {Record<string,string>} */
+const STATUS_GLYPH = { active: '●', idle: '○', done: '✓', dead: '✗', canceled: '⊘' };
+
+/** Load-bearing status hue — NUMERIC SGR, matching `canvas browse` exactly. */
+/** @type {Record<string,string>} */
+const STATUS_FG = { active: '32', idle: '33', done: '36', dead: '31', canceled: '90' };
+
+/** @param {string} status @returns {import('../../core/tui/draw.js').Style|undefined} */
+function glyphStyle(status) {
+  const fg = STATUS_FG[status];
+  return fg ? { fg } : undefined; // hue only — the glyph SHAPE is the mono carrier
+}
+
+/** Name weight = hierarchy: live work LEADS in bold; terminal nodes recede dim.
+ * @param {string} status @param {boolean} attached
+ * @returns {import('../../core/tui/draw.js').Style|undefined} */
+function nameStyle(status, attached) {
+  if (attached) return { fg: '36', bold: true }; // the attached node — cyan accent
+  if (status === 'active') return { bold: true };
+  if (status === 'done' || status === 'dead' || status === 'canceled') return { dim: true };
+  return undefined;
+}
+
+// ── RailRow → ListItemRow (left spans + right-flushed ⚑N) ──────────────────────
+
+/**
+ * Build one rail list row. A node row: 1-cell gutter (`▸` accent on the attached
+ * node, else blank), optional dim tree prefix, the status glyph (hue), the name
+ * (weight = status / accent when attached), and a right-flushed bright-yellow ⚑N
+ * when the node has pending asks.
+ * @param {RailRow} row
+ * @returns {import('../../core/tui/draw.js').ListItemRow}
+ */
+function rowToItem(row) {
+  if (row.kind === 'header') {
+    return { spans: [{ text: row.text, style: { fg: '36', bold: true } }] };
+  }
+  if (row.kind === 'chrome') {
+    return { spans: [{ text: row.text, style: { dim: true } }] };
+  }
+  // row.kind === 'node'
+  /** @type {import('../../core/tui/draw.js').Span[]} */
+  const spans = [
+    row.attached ? { text: '▸', style: { fg: '36', bold: true } } : { text: ' ' },
+    { text: ' ' },
+  ];
+  if (row.prefix) spans.push({ text: row.prefix, style: { dim: true } });
+  spans.push({ text: STATUS_GLYPH[row.status] || '?', style: glyphStyle(row.status) });
+  spans.push({ text: ' ' });
+  spans.push({ text: row.name, style: nameStyle(row.status, row.attached) });
+  if (row.asks > 0) {
+    return { spans, right: [{ text: `⚑${row.asks}`, style: { fg: '93', bold: true } }] };
+  }
+  return { spans };
+}
+
+// ── render ─────────────────────────────────────────────────────────────────────
+
+/**
+ * Paint the rail, or one of the four standard states. Pure (reads state, calls
+ * draw.*); the only write is storing draw.list's adjusted scroll.
+ * @param {SidebarState} state
+ * @param {import('../../core/tui/draw.js').Draw} draw
+ * @param {import('../../core/tui/draw.js').Rect} content
+ */
+export function render(state, draw, content) {
+  if (content.width <= 0 || content.height <= 0) return;
+
+  if (state.rows.length === 0) {
+    // The copy comes from the typed SourceError's `display` VERBATIM (the
+    // contract display/kind split — we never branch on `kind`); only the glyph +
+    // hue are a presentation map off `display.level`.
+    if (state.srcError) {
+      const d = state.srcError.display;
+      const g = d.level === 'action' ? { glyph: '⊙', fg: '33' } : { glyph: '⚠', fg: '31' };
+      notReadyState(draw, content, {
+        glyph: g.glyph,
+        glyphFg: g.fg,
+        headline: d.headline,
+        explanation: d.explanation,
+        nextStep: d.nextStep,
+      });
+      return;
+    }
+    if (state.lastFetch === 0) {
+      loadingState(draw, content, { rows: Math.min(5, content.height), label: 'Loading…' });
+      return;
+    }
+    emptyState(draw, content, {
+      headline: 'No agents here',
+      secondary: ['Nothing started in this cwd.', 'Press g to refresh.'],
+    });
+    return;
+  }
+
+  const items = state.rows.map((r) => rowToItem(r));
+  const res = draw.list(content, items, state.cursor, state.scroll);
+  state.scroll = res.scroll; // store adjusted scroll back (Draw.list contract)
+}
+
+// ── keymap ───────────────────────────────────────────────────────────────
+
+/**
+ * j/k move the cursor over node rows, ↵ swaps the selected node into the chat
+ * pane (the controller action), g refreshes, q quits. Footer hints come from
+ * these bindings' `hint` fields (the single source of truth).
+ * @type {import('../../core/view/contract.js').KeyBinding<SidebarState>[]}
+ */
+export const keymap = [
+  { keys: ['j', 'down'], intent: 'cursorDown', hint: { keys: 'j/k', label: 'move' } },
+  { keys: ['k', 'up'], intent: 'cursorUp' },
+  { keys: ['return', 'enter'], intent: 'open', hint: { keys: '↵', label: 'open' } },
+  { keys: ['g', 'r'], intent: 'refresh', hint: { keys: 'g', label: 'refresh' } },
+  { keys: ['q'], intent: 'quit', hint: { keys: 'q', label: 'quit' } },
+];

package/dist/builtin-views/workspace-sidebar/web.jsx

@@ -0,0 +1,109 @@
+// @ts-check
+/**
+ * Workspace Sidebar — the WEB presenter for the `workspace-sidebar` view (React
+ * + Tailwind). Browser-only: consumed solely by the web serve path (Vite owns
+ * JSX + Tailwind); NEVER Node-imported. The default export is a pure function of
+ * `state`; DOM events call `dispatch(intentName, payload?)`.
+ *
+ * Same logical model as the TUI presenter (`state.rows` + `state.cursor`) read
+ * from the SAME portable `core.mjs` — zero shared rendering code with `tui.mjs`.
+ * On the web there is no chat pane to drive, so the rail renders as a plain
+ * styled node list (this becomes the sidebar of the future crouter web UI): a
+ * click selects a row, ↵ no-ops via the core's `open` banner. The outer chrome
+ * (title / status / banner / chip) is rendered by `<ViewChrome>`, which wraps
+ * this component — do NOT render it here.
+ *
+ * @module workspace-sidebar/web
+ */
+
+import { Loading, Empty, ErrorState, NotReady } from '@crouton-kit/crouter/web';
+
+/** @typedef {import('./core.mjs').SidebarState} SidebarState */
+/** @typedef {import('./core.mjs').RailRow} RailRow */
+
+// ── Status vocabulary (the web analog of tui.mjs's NUMERIC-SGR maps) ──────────
+
+const STATUS = {
+  active: { glyph: '●', cls: 'text-green-600' },
+  idle: { glyph: '○', cls: 'text-amber-600' },
+  done: { glyph: '✓', cls: 'text-cyan-600' },
+  dead: { glyph: '✗', cls: 'text-red-600' },
+  canceled: { glyph: '⊘', cls: 'text-slate-400' },
+};
+
+/** @param {string} status @param {boolean} attached @returns {string} */
+function nameCls(status, attached) {
+  if (attached) return 'font-bold text-cyan-700';
+  if (status === 'active') return 'font-semibold';
+  if (status === 'done' || status === 'dead' || status === 'canceled') return 'text-slate-400';
+  return '';
+}
+
+// ── Rows (the web analog of tui.mjs's rowToItem) ───────────────────────────────
+
+/** @param {{ row: RailRow, index: number, selected: boolean, onClick: () => void }} props */
+function Row({ row, selected, onClick }) {
+  if (row.kind === 'header') {
+    return <li className="px-2 pt-3 pb-0.5 font-semibold text-cyan-700">{row.text}</li>;
+  }
+  if (row.kind === 'chrome') {
+    return <li className="px-2 text-slate-400">{row.text || '\u00a0'}</li>;
+  }
+  // row.kind === 'node'
+  const st = STATUS[row.status] || { glyph: '?', cls: 'text-slate-400' };
+  const base = `flex items-baseline gap-1 rounded px-2 py-0.5 cursor-pointer ${selected ? 'bg-slate-200' : 'hover:bg-slate-100'}`;
+  return (
+    <li className={base} onClick={onClick}>
+      <span className={`w-3 shrink-0 ${row.attached ? 'font-bold text-cyan-700' : ''}`}>{row.attached ? '▸' : '\u00a0'}</span>
+      {row.prefix ? <span className="whitespace-pre text-slate-400">{row.prefix}</span> : null}
+      <span className={st.cls}>{st.glyph}</span>
+      <span className={nameCls(row.status, row.attached)}>{row.name}</span>
+      {row.asks > 0 ? <span className="ml-auto shrink-0 font-bold text-amber-500">⚑{row.asks}</span> : null}
+    </li>
+  );
+}
+
+// ── The view ───────────────────────────────────────────────────────────────────
+
+/**
+ * @param {import('../../core/view/contract.js').ViewProps<SidebarState>} props
+ */
+export default function WorkspaceSidebar({ state, dispatch }) {
+  if (state.rows.length === 0) {
+    // The copy comes from the typed SourceError's `display` VERBATIM (the
+    // contract display/kind split — never branch on `kind`); only the four-state
+    // component is a presentation map off `display.level` so the hue matches the
+    // TUI (error → red ErrorState, action → amber NotReady).
+    if (state.srcError) {
+      const d = state.srcError.display;
+      const Takeover = d.level === 'error' ? ErrorState : NotReady;
+      return (
+        <Takeover
+          headline={d.headline}
+          explanation={d.explanation}
+          nextStep={d.nextStep}
+          onRetry={() => dispatch('refresh')}
+        />
+      );
+    }
+    if (state.lastFetch === 0) return <Loading label="Loading…" />;
+    return <Empty label="No agents in this cwd." />;
+  }
+
+  return (
+    <ul
+      className="font-mono text-sm outline-none"
+      tabIndex={0}
+      onKeyDown={(e) => {
+        if (e.key === 'j' || e.key === 'ArrowDown') { dispatch('cursorDown'); e.preventDefault(); }
+        else if (e.key === 'k' || e.key === 'ArrowUp') { dispatch('cursorUp'); e.preventDefault(); }
+        else if (e.key === 'Enter') { dispatch('open'); e.preventDefault(); }
+        else if (e.key === 'g') { dispatch('refresh'); }
+      }}
+    >
+      {state.rows.map((row, i) => (
+        <Row key={i} row={row} index={i} selected={i === state.cursor} onClick={() => dispatch('select', i)} />
+      ))}
+    </ul>
+  );
+}

package/dist/cli.js

@@ -3,7 +3,8 @@ import { runCli } from './core/command.js';
 import { buildRoot } from './build-root.js';
 import { maybeBootRoot } from './core/runtime/front-door.js';
 import { maybeAutoUpdate } from './core/auto-update.js';
-import { ensureBootSkill, ensureOfficialMarketplace, ensureProjectScope, ensureSlashCommands } from './core/bootstrap.js';
+import { ensureOfficialMarketplace, ensureProjectScope } from './core/bootstrap.js';
+import { provisionExports } from './core/skill-sync/export.js';
 // The full command tree is assembled in build-root.ts (shared with the
 // listing-completeness test). Root owns only the tagline; every subtree
 // declares its own representation.
@@ -15,8 +16,7 @@ if (maybeBootRoot(root, process.argv)) {
     // bootRoot exec'd pi inline and exited; unreachable.
 }
 ensureOfficialMarketplace(process.argv);
-ensureBootSkill(process.argv);
-ensureSlashCommands(root, process.argv);
+provisionExports(root);
 ensureProjectScope(process.argv);
 maybeAutoUpdate(process.argv);
 runCli(root, process.argv).catch((err) => {

package/dist/clients/attach/__tests__/action-parity.test.js

@@ -0,0 +1,48 @@
+// Regression: the `crtr attach` viewer's InputController wired only a subset of
+// pi's editor `app.*` actions, so several keys that work in pi were dead in the
+// attach surface — most visibly Ctrl+O (toggle tool output) and Ctrl+T (toggle
+// thinking blocks), but also Ctrl+G (external editor), Shift+Tab (cycle thinking
+// level), Shift+Ctrl+P (cycle model backward), and Alt+Up (dequeue). The broker
+// already supported every one of these frames; only the client-side onAction
+// wiring was missing. The fix wires them in input-controller's wire() and adds
+// the ChatView render toggles for the two display-only ones. This assembly lives
+// inside TUI-constructing code with no unit seam, so we guard the wiring at the
+// source level (mirrors onrequest-wired.test.ts).
+// See src/clients/attach/{input-controller,chat-view,attach-cmd}.ts.
+import { test } from 'node:test';
+import assert from 'node:assert/strict';
+import { readFileSync } from 'node:fs';
+import { fileURLToPath } from 'node:url';
+import { dirname, join } from 'node:path';
+const here = dirname(fileURLToPath(import.meta.url));
+const read = (file) => readFileSync(join(here, '..', file), 'utf8').replace(/\s+/g, ' ');
+const inputController = read('input-controller.ts');
+const chatView = read('chat-view.ts');
+const attachCmd = read('attach-cmd.ts');
+test('input-controller wires every previously-dead app.* editor action', () => {
+    for (const action of [
+        'app.tools.expand', // Ctrl+O — toggle tool output
+        'app.thinking.toggle', // Ctrl+T — toggle thinking blocks
+        'app.thinking.cycle', // Shift+Tab — cycle thinking level
+        'app.model.cycleBackward', // Shift+Ctrl+P — cycle model backward
+        'app.message.dequeue', // Alt+Up — restore queued messages
+        'app.editor.external', // Ctrl+G — external editor
+    ]) {
+        assert.match(inputController, new RegExp(`onAction\\(\\s*'${action.replace(/\./g, '\\.')}'`), `input-controller must register onAction('${action}')`);
+    }
+});
+test('cycle_model carries an explicit direction in both directions', () => {
+    assert.match(inputController, /type:\s*'cycle_model',\s*direction:\s*'forward'/);
+    assert.match(inputController, /type:\s*'cycle_model',\s*direction:\s*'backward'/);
+});
+test('ChatView exposes the Ctrl+O / Ctrl+T render toggles', () => {
+    assert.match(chatView, /toggleToolsExpanded\(\)/, 'ChatView needs toggleToolsExpanded()');
+    assert.match(chatView, /toggleThinking\(\)/, 'ChatView needs toggleThinking()');
+    // The toggles must actually fan out to the rendered children, not just flip a flag.
+    assert.match(chatView, /child\.setExpanded\(this\.toolOutputExpanded\)/);
+    assert.match(chatView, /child\.setHideThinkingBlock\(this\.hideThinking\)/);
+});
+test('attach-cmd connects the ChatView toggles to the input controller', () => {
+    assert.match(attachCmd, /onToggleToolsExpand:\s*\(\)\s*=>[\s\S]*chatView\.toggleToolsExpanded\(\)/);
+    assert.match(attachCmd, /onToggleThinking:\s*\(\)\s*=>[\s\S]*chatView\.toggleThinking\(\)/);
+});

package/dist/clients/attach/__tests__/clipboard-image.test.js

@@ -0,0 +1,76 @@
+// Bug-regression: `crtr attach` Ctrl+V reported "no image in the clipboard" even
+// when the clipboard genuinely held an image. Root cause — the macOS reader only
+// tried `pngpaste -`, which is NOT a built-in (`brew install pngpaste`); on a
+// stock Mac its absence returned null, indistinguishable from an empty clipboard.
+//
+// These lock in the platform dispatch (clipboard-image.ts): a MISSING pngpaste
+// must FALL THROUGH to the native osascript read (not collapse to "no image"),
+// and the reader must DISTINGUISH "no clipboard tool" from "clipboard has no
+// image" so the user-facing notice is accurate. The decision logic is pure +
+// injectable precisely so it can be unit-tested without a real clipboard.
+import { test } from 'node:test';
+import assert from 'node:assert/strict';
+import { selectMacOutcome, selectLinuxOutcome, } from '../clipboard-image.js';
+const bytes = (s) => Buffer.from(s);
+test('macOS: missing pngpaste falls through to the native osascript read (the bug)', () => {
+    let nativeCalled = false;
+    const runTool = (cmd) => {
+        assert.equal(cmd, 'pngpaste');
+        return { missing: true }; // pngpaste not installed (stock Mac)
+    };
+    const readNative = () => {
+        nativeCalled = true;
+        return { image: { bytes: bytes('PNGDATA'), mimeType: 'image/png' } };
+    };
+    const out = selectMacOutcome(runTool, readNative);
+    assert.equal(nativeCalled, true, 'native osascript path must run when pngpaste is absent');
+    assert.equal(out.image?.mimeType, 'image/png');
+    assert.equal(out.image?.bytes.toString(), 'PNGDATA');
+});
+test('macOS: pngpaste present takes the fast path and skips osascript', () => {
+    let nativeCalled = false;
+    const runTool = () => ({ bytes: bytes('FASTPNG') });
+    const readNative = () => {
+        nativeCalled = true;
+        return {};
+    };
+    const out = selectMacOutcome(runTool, readNative);
+    assert.equal(nativeCalled, false, 'fast path must not invoke osascript');
+    assert.equal(out.image?.bytes.toString(), 'FASTPNG');
+});
+test('macOS: pngpaste present but clipboard empty still defers to osascript', () => {
+    // pngpaste exits non-zero on an empty clipboard → {} (ran, no image). The
+    // native path is authoritative for the empty-vs-failure distinction.
+    let nativeCalled = false;
+    const runTool = () => ({}); // ran, no bytes
+    const readNative = () => {
+        nativeCalled = true;
+        return {}; // osascript: NO_IMAGE
+    };
+    const out = selectMacOutcome(runTool, readNative);
+    assert.equal(nativeCalled, true);
+    assert.equal(out.image, undefined);
+    assert.equal(out.note, undefined, 'empty clipboard → no note (caller shows the generic notice)');
+});
+test('Linux: no clipboard tool installed surfaces a precise note, not "no image"', () => {
+    const runTool = () => ({ missing: true }); // neither xclip nor wl-paste
+    const out = selectLinuxOutcome(runTool, /* wayland */ false);
+    assert.equal(out.image, undefined);
+    assert.match(out.note ?? '', /install xclip/);
+});
+test('Linux/Wayland: no tool installed names wl-clipboard', () => {
+    const out = selectLinuxOutcome(() => ({ missing: true }), /* wayland */ true);
+    assert.match(out.note ?? '', /wl-clipboard/);
+});
+test('Linux: tool present but clipboard has no image → empty (no note)', () => {
+    const runTool = () => ({}); // xclip ran, no image of that type
+    const out = selectLinuxOutcome(runTool, /* wayland */ false);
+    assert.equal(out.image, undefined);
+    assert.equal(out.note, undefined, 'a tool that ran but found no image is genuinely empty');
+});
+test('Linux: xclip returns PNG bytes', () => {
+    const runTool = (_cmd, args) => args.includes('image/png') ? { bytes: bytes('XPNG') } : {};
+    const out = selectLinuxOutcome(runTool, /* wayland */ false);
+    assert.equal(out.image?.mimeType, 'image/png');
+    assert.equal(out.image?.bytes.toString(), 'XPNG');
+});

package/dist/clients/attach/__tests__/editor-newline.test.js

@@ -0,0 +1,57 @@
+// Regression: in the attach viewer, Alt+Enter did NOTHING — not a newline, not a
+// submit. The editor was SWALLOWING it. Root cause: pi-coding-agent's
+// CustomEditor resolves `@earendil-works/pi-tui` from its OWN node_modules, a
+// SEPARATE module instance from the one `config-load` imports (a non-deduped
+// install). config-load registered the KeybindingsManager only on its copy, but
+// the editor's super reads `getKeybindings()` from ITS instance — stuck at the
+// default `tui.input.newLine = shift+enter`. So the attach `alt+enter → newLine`
+// binding was invisible to the editor: Alt+Enter (`\x1b[13;3u`) matched neither
+// newLine nor submit and fell through. `mirrorKeybindingsToEditor` registers the
+// SAME manager on the editor's pi-tui instance; this test feeds the exact
+// Alt+Enter / Enter byte sequences a terminal sends and asserts the behavior.
+// See mirrorKeybindingsToEditor in src/clients/attach/config-load.ts.
+import { test } from 'node:test';
+import assert from 'node:assert/strict';
+import { mkdtempSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import { TUI, ProcessTerminal } from '@earendil-works/pi-tui';
+import { TitledEditor } from '../titled-editor.js';
+import { createKeybindingsManager, mirrorKeybindingsToEditor } from '../config-load.js';
+// Kitty CSI-u: `\x1b[<codepoint>;<1+mods>u`. enter=13, alt=2 → mods byte 3.
+const ALT_ENTER = '\x1b[13;3u';
+const ENTER = '\r';
+async function buildEditor() {
+    // Empty agent dir → no user keybindings.json, so the binding under test is the
+    // attach DEFAULT (`ATTACH_KEYBINDING_OVERRIDES` adds alt+enter to newLine).
+    const agentDir = mkdtempSync(join(tmpdir(), 'crtr-kb-'));
+    const km = createKeybindingsManager(agentDir);
+    await mirrorKeybindingsToEditor(km); // the fix
+    const tui = new TUI(new ProcessTerminal());
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    return new TitledEditor(tui, { borderColor: (s) => s, selectList: {} }, km, {
+        paddingX: 1,
+    });
+}
+test('attach editor inserts a newline on Alt+Enter (cross-instance binding reaches the editor)', async () => {
+    const editor = await buildEditor();
+    let submitted = null;
+    editor.onSubmit = (t) => {
+        submitted = t;
+    };
+    editor.setText('hello');
+    editor.handleInput(ALT_ENTER);
+    assert.equal(editor.getText(), 'hello\n', 'Alt+Enter must insert a newline, not be swallowed');
+    assert.equal(submitted, null, 'Alt+Enter must not submit');
+});
+test('attach editor still submits on plain Enter', async () => {
+    const editor = await buildEditor();
+    let submitted = null;
+    editor.onSubmit = (t) => {
+        submitted = t;
+    };
+    editor.setText('hello');
+    editor.handleInput(ENTER);
+    assert.equal(submitted, 'hello', 'plain Enter must submit');
+    assert.equal(editor.getText(), '', 'editor clears after submit');
+});

package/dist/clients/attach/__tests__/git-info.test.js

@@ -0,0 +1,31 @@
+// Unit coverage for the pure git-status parser that feeds the attach editor's
+// border (cwd · branch · status symbols). The shell-out is non-blocking and
+// untestable in a unit, but the porcelain-v1 --branch parse is pure and the
+// part that can silently mis-read state, so it is locked in here.
+// See src/clients/attach/git-info.ts.
+import { test } from 'node:test';
+import assert from 'node:assert/strict';
+import { parseGitStatus } from '../git-info.js';
+test('clean tree on a tracked branch', () => {
+    const info = parseGitStatus('repo', '## main...origin/main\n');
+    assert.deepEqual(info, { dir: 'repo', branch: 'main', dirty: false, ahead: 0, behind: 0 });
+});
+test('dirty tree with ahead/behind counts', () => {
+    const info = parseGitStatus('repo', '## feature...origin/feature [ahead 2, behind 3]\n M src/a.ts\n?? new.ts\n');
+    assert.equal(info.branch, 'feature');
+    assert.equal(info.dirty, true);
+    assert.equal(info.ahead, 2);
+    assert.equal(info.behind, 3);
+});
+test('untracked-only branch (no upstream) is still dirty, no counts', () => {
+    const info = parseGitStatus('repo', '## main\n?? scratch.md\n');
+    assert.equal(info.branch, 'main');
+    assert.equal(info.dirty, true);
+    assert.equal(info.ahead, 0);
+    assert.equal(info.behind, 0);
+});
+test('detached HEAD reports no branch', () => {
+    const info = parseGitStatus('repo', '## HEAD (no branch)\n');
+    assert.equal(info.branch, undefined);
+    assert.equal(info.dirty, false);
+});

package/dist/clients/attach/__tests__/onrequest-wired.test.js

@@ -0,0 +1,20 @@
+// Regression: the `crtr attach` viewer built its InputController WITHOUT the
+// `onRequest` hook, so the correlated read-op channel was never wired even
+// though ViewSocketClient.request() was fully implemented. Every native picker
+// (/model, /resume, /fork, /tree, /settings, /scoped-models) therefore degraded
+// to the "isn't available in this viewer" notice — /model couldn't open the
+// model picker. The fix wires `onRequest: (frame) => socket.request(frame)` in
+// attach-cmd. This assembly lives inside a big TUI-constructing function with no
+// seam to unit-test, so this guards the exact wiring at the source level.
+// See src/clients/attach/{attach-cmd,input-controller,slash-commands}.ts.
+import { test } from 'node:test';
+import assert from 'node:assert/strict';
+import { readFileSync } from 'node:fs';
+import { fileURLToPath } from 'node:url';
+import { dirname, join } from 'node:path';
+const src = readFileSync(join(dirname(fileURLToPath(import.meta.url)), '..', 'attach-cmd.ts'), 'utf8');
+test('attach-cmd wires onRequest to socket.request so native pickers work', () => {
+    // The InputController must receive the read-op channel; without it
+    // openPicker() short-circuits to the "isn't available in this viewer" notice.
+    assert.match(src.replace(/\s+/g, ' '), /onRequest:\s*\(frame\)\s*=>\s*socket\.request\(frame\)/, 'attach-cmd must pass onRequest: (frame) => socket.request(frame) to InputController');
+});

package/dist/clients/attach/__tests__/reconnect-giveup.test.js

@@ -0,0 +1,30 @@
+// Regression: the `crtr attach` viewer used to ALWAYS teardown ("broker gone")
+// on a socket close, so a resident broker node's yield→revive cycle dropped the
+// viewer to a shell. The fix holds the pane and re-dials the SAME view.sock
+// while the node is still alive, giving up only when it is genuinely gone. This
+// locks the give-up/keep-reconnecting decision (the bug-prone core) without a
+// socket or tmux. See src/clients/attach/{view-socket,attach-cmd}.ts.
+import { test } from 'node:test';
+import assert from 'node:assert/strict';
+import { reconnectShouldGiveUp } from '../view-socket.js';
+const rowWith = (status) => ({
+    node_id: 'n',
+    status,
+    host_kind: 'broker',
+    intent: null,
+    pi_pid: null,
+});
+test('keeps reconnecting while the node is still alive (active = mid yield/revive)', () => {
+    // A yield leaves status='active' (intent='refresh') — must NOT give up.
+    assert.equal(reconnectShouldGiveUp(rowWith('active')), false);
+    // idle-release revives on the next inbox wake — keep trying (bounded by the
+    // supervisor's own ~30s deadline), do not give up.
+    assert.equal(reconnectShouldGiveUp(rowWith('idle')), false);
+});
+test('gives up the instant the node is genuinely gone', () => {
+    assert.equal(reconnectShouldGiveUp(rowWith('done')), true);
+    assert.equal(reconnectShouldGiveUp(rowWith('dead')), true);
+    assert.equal(reconnectShouldGiveUp(rowWith('canceled')), true);
+    // A reaped row (null) → give up.
+    assert.equal(reconnectShouldGiveUp(null), true);
+});

package/dist/clients/attach/__tests__/slash-quit-copy.test.js

@@ -0,0 +1,42 @@
+// Regression: `/quit` in the attach viewer only sent a `bye` frame + a notice.
+// The broker answers `bye` with socket.end(), which the viewer's close handler
+// treats as a dropped connection and RECONNECTS — so `/quit` never detached (it
+// silently reconnected). The fix routes `/quit` through an `onQuit` hook wired to
+// teardown('detach'). Likewise `/copy` was a dead "not available" stub; it now
+// runs through an `onCopy` hook. This guards the dispatch contract for both.
+// See src/clients/attach/{slash-commands,input-controller,attach-cmd}.ts.
+import { test } from 'node:test';
+import assert from 'node:assert/strict';
+import { dispatchSlashCommand } from '../slash-commands.js';
+function ctx(overrides = {}) {
+    const sent = [];
+    const notices = [];
+    return {
+        send: (f) => sent.push(f),
+        notify: (m) => notices.push(m),
+        sent,
+        notices,
+        ...overrides,
+    };
+}
+test('/quit detaches via onQuit and does NOT send a bare bye (reconnect-loop bug)', () => {
+    let quit = 0;
+    const c = ctx({ onQuit: () => quit++ });
+    const handled = dispatchSlashCommand('/quit', c);
+    assert.equal(handled, true);
+    assert.equal(quit, 1, '/quit must invoke onQuit (teardown), not just send bye');
+    assert.equal(c.sent.length, 0, '/quit must not send a bare bye frame when onQuit is wired');
+});
+test('/quit falls back to a bye frame when onQuit is unwired', () => {
+    const c = ctx();
+    dispatchSlashCommand('/quit', c);
+    assert.deepEqual(c.sent, [{ type: 'bye' }]);
+});
+test('/copy runs through onCopy instead of the dead "not available" stub', () => {
+    let copy = 0;
+    const c = ctx({ onCopy: () => copy++ });
+    const handled = dispatchSlashCommand('/copy', c);
+    assert.equal(handled, true);
+    assert.equal(copy, 1, '/copy must invoke onCopy');
+    assert.equal(c.notices.length, 0, '/copy must not fall through to a notice when onCopy is wired');
+});

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

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

package/dist/clients/attach/__tests__/titled-editor.test.js

@@ -0,0 +1,39 @@
+// Regression: TitledEditor's top border dropped the git-info chip only when the
+// title chip left fewer than 4 free columns — when BOTH chips fit individually
+// but their sum exceeded the terminal width, the fill clamped to 0 and the line
+// came out chipW+infoW wide. pi-tui hard-crashes on any over-wide line:
+//   "Error: Rendered line 3192 exceeds terminal width (75 > 70)"
+// (title chip " ⬢ general (base) continue-crouter-development 0 " = 50 cols,
+// info "crouter · ⎇ main · ●⇡5⇣1" = 25 cols, terminal 70). The fix truncates
+// the info chip to the space the title leaves instead of all-or-nothing.
+// See composeTopBorder in src/clients/attach/titled-editor.ts.
+import { test } from 'node:test';
+import assert from 'node:assert/strict';
+import { visibleWidth } from '@earendil-works/pi-tui';
+import { composeTopBorder } from '../titled-editor.js';
+const titleStyle = (s) => `\x1b[7m ${s} \x1b[27m`;
+const borderColor = (s) => `\x1b[38;2;128;128;128m${s}\x1b[39m`;
+const compose = (width, title, info) => composeTopBorder(width, title, info, titleStyle, borderColor);
+test('crash scenario: chip + info that each fit but overflow together stays at width', () => {
+    const title = '⬢ general (base) continue-crouter-development 0'; // chip = 50 cols
+    const info = `\x1b[38;2;128;128;128mcrouter · \x1b[39m\x1b[38;2;129;162;190m⎇ main\x1b[39m\x1b[38;2;128;128;128m · \x1b[39m\x1b[33m●\x1b[39m⇡5⇣1`; // 25 cols
+    const line = compose(70, title, info);
+    assert.equal(visibleWidth(line), 70, 'line must be exactly terminal width, not 75');
+});
+test('top border never exceeds width across title/info length combinations', () => {
+    const longInfo = `\x1b[33m${'status-info-'.repeat(8)}\x1b[39m`;
+    for (const width of [20, 40, 70, 120]) {
+        for (const title of ['', 'a', 'session', 'x'.repeat(200)]) {
+            for (const info of ['', 'crouter · main', longInfo]) {
+                const line = compose(width, title, info);
+                assert.ok(visibleWidth(line) <= width, `overflow at width=${width} titleLen=${title.length} infoW=${visibleWidth(info)}: got ${visibleWidth(line)}`);
+            }
+        }
+    }
+});
+test('info chip survives intact when there is room for it', () => {
+    const info = 'crouter · main';
+    const line = compose(80, 'sess', info);
+    assert.ok(line.includes(info), 'fitting info must not be truncated or dropped');
+    assert.equal(visibleWidth(line), 80);
+});