@crouton-kit/crouter 0.3.31 → 0.3.33

package/dist/core/runtime/promote.js

@@ -1,6 +1,6 @@
 // Promotion — the worker→orchestrator polymorph (mode→orchestrator).
 //
-// Two stages (the pi-mode-switch pattern):
+// Two stages:
 //   1. Promotion → mode flips to orchestrator (mid-turn). This call flips the
 //      node's mode and (optionally) its KIND, REWRITES its launch spec to that
 //      kind's orchestrator persona (so the next revive comes back as that
@@ -20,6 +20,7 @@
 // never the mere act of spawning a child.
 import { getNode, updateNode } from '../canvas/index.js';
 import { transition } from './lifecycle.js';
+import { ensureDaemon } from '../../daemon/manage.js';
 import { buildLaunchSpec } from './launch.js';
 import { hasRoadmap, seedRoadmap, roadmapPath } from './roadmap.js';
 import { readGoal, goalPath } from './kickoff.js';
@@ -58,7 +59,7 @@ export function promote(nodeId, opts = {}) {
     // Seed a barebones roadmap scaffold if absent so the file exists for a
     // refresh. Pre-fill its Goal from the node's goal doc when present (set at
     // spawn, or captured from the first user message); the node fleshes out the
-    // body next, guided by the kind skill dumped below.
+    // body next, guided by the kind's roadmap memory doc dumped below.
     let roadmapWritten = false;
     if (!hasRoadmap(nodeId)) {
         const goal = readGoal(nodeId);
@@ -68,10 +69,17 @@ export function promote(nodeId, opts = {}) {
     // Flip mode→orchestrator + kind + launch spec. Lifecycle is independent:
     // only set resident when the caller asked for it (the common self-promotion
     // stays terminal/orchestrator — it still reports up + reaps).
+    // If the handle is still the spawn-time kind default (name === old kind),
+    // carry it to the new kind so the "name === kind ⇒ default, drop it" invariant
+    // in fullName() holds across a kind change. Otherwise a node spawned `general`
+    // (name="general") that reshapes to `plan` would surface a stale "general"
+    // handle in front of its real description.
+    const carriesDefaultHandle = node.name === node.kind && targetKind !== node.kind;
     const meta = updateNode(nodeId, {
         kind: targetKind,
         mode: 'orchestrator',
         launch,
+        ...(carriesDefaultHandle ? { name: targetKind } : {}),
         // Persist a newly-chosen tier so it is durable across future revives; omit
         // when unchanged so the existing pin (or persona default) stands.
         ...(opts.model !== undefined ? { model_override: opts.model } : {}),
@@ -90,7 +98,8 @@ export function promote(nodeId, opts = {}) {
  *  so it comes back as an orchestrator, optionally specializing its kind. Sets
  *  intent='refresh'; the stophook shuts the process down on the next stop and
  *  the daemon revives it fresh. */
-export function requestYield(nodeId, opts = {}) {
+export function requestYield(nodeId, opts = {}, deps = {}) {
+    const ensure = deps.ensure ?? ensureDaemon;
     const node = getNode(nodeId);
     if (node === null)
         throw new Error(`unknown node: ${nodeId}`);
@@ -113,6 +122,17 @@ export function requestYield(nodeId, opts = {}) {
         // of an already-orchestrator node.
         promoted = wasBase;
     }
+    // The refresh-revive is the DAEMON's job: the stophook shuts this broker down
+    // on its next stop, and crtrd then sees the dead pid + intent='refresh' and
+    // relaunches it fresh. That handoff is silent if the daemon isn't running — the
+    // broker exits and nothing ever revives it (the viewer redials its view.sock
+    // for ~30s and reports "broker gone"). So ensure the supervisor is alive HERE,
+    // before we arm the yield — the same best-effort ensure spawn/recycle do, on
+    // the one other path that hands a node off to the daemon. Runs in the fresh
+    // `crtr node yield` subprocess, so it always uses current dist (never a stale
+    // in-process hook). Injectable for the regression test that locks in this
+    // ensure (default = ensureDaemon).
+    ensure();
     // Mark the intent; the stophook enacts the shutdown, the daemon the revive.
     transition(nodeId, 'yield');
     const meta = getNode(nodeId);

package/dist/core/runtime/recycle.js

@@ -120,7 +120,7 @@ export async function recycleNode(nodeId, callerPane) {
     // CRTR_SUBTREE groups the fresh root's subtree; FRONT_DOOR is set by the broker
     // host itself, so it is not added here.
     inv.env = { ...inv.env, CRTR_SUBTREE: rootOfSpine(root.node_id) };
-    const ok = recycleBrokerViewer(fresh, pane, inv);
+    const ok = await recycleBrokerViewer(fresh, pane, inv);
     return { recycled: ok, finalized, newRoot: root.node_id, delivered };
 }
 /** Recycle a BROKER root into `pane`: the fresh root is broker-hosted, so its
@@ -131,9 +131,11 @@ export async function recycleNode(nodeId, callerPane) {
  *  `@crtr_node`); it never hosts the engine. Returns false (recycle reports the
  *  pane was not respawned) when the broker never serves — the fresh root row
  *  still exists, broker-hosted, for the daemon to revive. */
-function recycleBrokerViewer(fresh, pane, inv) {
-    headlessBrokerHost.launch(fresh.node_id, inv, { cwd: fresh.cwd, name: fullName(fresh), resuming: false });
-    if (!waitForBrokerViewSocket(fresh.node_id))
+async function recycleBrokerViewer(fresh, pane, inv) {
+    const placed = headlessBrokerHost.launch(fresh.node_id, inv, { cwd: fresh.cwd, name: fullName(fresh), resuming: false });
+    if (placed.pid === null)
+        return false;
+    if (!(await waitForBrokerViewSocket(fresh.node_id, placed.exited)))
         return false;
     // Clear the finalized node's stale `@crtr_node` tag before respawn so the tag
     // never names a done node during the gap before the new `crtr attach` re-tags

package/dist/core/runtime/reset.d.ts

@@ -19,7 +19,10 @@ export interface RelaunchDeps {
     /** Boot the new node's detached broker engine. Default: headlessBrokerHost.launch. */
     launchBroker?: typeof headlessBrokerHost.launch;
     /** Wait for the new broker's view.sock to accept. Default: waitForBrokerViewSocket. */
-    waitForViewSocket?: (nodeId: string) => boolean;
+    waitForViewSocket?: (nodeId: string, exited?: Promise<{
+        code: number | null;
+        signal: NodeJS.Signals | null;
+    }>) => boolean | Promise<boolean>;
     /** Re-exec the viewer pane onto the new node. Default: respawnPaneSync. */
     respawnViewer?: typeof respawnPaneSync;
     /** Tear the old broker down. Default: headlessBrokerHost.teardown. */
@@ -35,7 +38,7 @@ export interface RelaunchRootResult {
  *  is touched, so any pre-commit failure leaves the old root fully intact and
  *  live. Returns null when `oldId` is not a relaunchable root (unknown, a child,
  *  or already parked), or when the new broker failed to launch. */
-export declare function relaunchRoot(oldId: string, deps?: RelaunchDeps): RelaunchRootResult | null;
+export declare function relaunchRoot(oldId: string, deps?: RelaunchDeps): Promise<RelaunchRootResult | null>;
 export interface ResetRootResult {
     /** Descendant node ids torn down. Always empty — a child `/new` reaps nothing. */
     reaped: string[];

package/dist/core/runtime/reset.js

@@ -68,7 +68,7 @@ export function reapDescendants(rootId) {
  *  is touched, so any pre-commit failure leaves the old root fully intact and
  *  live. Returns null when `oldId` is not a relaunchable root (unknown, a child,
  *  or already parked), or when the new broker failed to launch. */
-export function relaunchRoot(oldId, deps = {}) {
+export async function relaunchRoot(oldId, deps = {}) {
     const launchBroker = deps.launchBroker ?? headlessBrokerHost.launch;
     const waitForViewSocket = deps.waitForViewSocket ?? waitForBrokerViewSocket;
     const respawnViewer = deps.respawnViewer ?? respawnPaneSync;
@@ -115,7 +115,7 @@ export function relaunchRoot(oldId, deps = {}) {
         transition(newMeta.node_id, 'crash');
         return null;
     }
-    waitForViewSocket(newMeta.node_id); // best-effort; attach auto-redials on miss
+    await waitForViewSocket(newMeta.node_id, placed.exited); // best-effort; attach auto-redials on miss
     // --- COMMIT: park + reap the old root, re-point the viewer, kill the old
     //     broker. Past this point the new node is the live root. ---
     reapDescendants(oldId); // old workers → canceled + torn down

package/dist/core/runtime/revive.d.ts

@@ -1,5 +1,6 @@
 import { type NodeMeta } from '../canvas/index.js';
 import type { WakeOrigin } from './bearings.js';
+import { headlessBrokerHost } from './host.js';
 /** Pick the `--session` source for a revive. resume=true prefers the absolute
  *  session-file path (immune to cwd; pi opens it directly) and keeps the bare
  *  session id as the fallback for older nodes booted before pi_session_file was
@@ -19,6 +20,9 @@ export interface ReviveResult {
     session: string | null;
     /** True when pi was instructed to resume its saved conversation (`--session <id>`). */
     resumed: boolean;
+    /** Launch handle for the detached broker, so callers can fail fast on its real
+     *  exit before the socket appears. */
+    launch?: ReturnType<typeof headlessBrokerHost.launch>;
 }
 /** Relaunch `nodeId`'s broker engine from its persisted recipe and update canvas
  *  meta. Opens no viewer (engine-only).

package/dist/core/runtime/revive.js

@@ -21,6 +21,7 @@ import { buildPiArgv } from './launch.js';
 import { buildReviveKickoff, drainBearings } from './kickoff.js';
 import { headlessBrokerHost } from './host.js';
 import { isPidAlive } from '../canvas/pid.js';
+import { clearFault } from './fault.js';
 import { clearInjectedDocs } from '../substrate/injected-store.js';
 // ---------------------------------------------------------------------------
 // resumeArgs — which session source a revive resumes from
@@ -72,9 +73,9 @@ export function reviveNode(nodeId, opts) {
             resumed: false,
         };
     }
-    // Every (re)launch is a new cycle — bump the counter so the editor label's
-    // trailing N advances. Mutate the in-memory meta too so buildPiArgv below
-    // builds the label with the incremented count.
+    // Every (re)launch is a new cycle — bump the counter so CRTR_CYCLES and the
+    // footer stay in sync. Mutate the in-memory meta too so buildPiArgv below
+    // launches with the incremented count.
     meta.cycles = (meta.cycles ?? 0) + 1;
     updateNode(nodeId, { cycles: meta.cycles });
     // Decide whether to wake the saved pi conversation or start fresh. Prefer the
@@ -106,19 +107,36 @@ export function reviveNode(nodeId, opts) {
     // opens NO viewer — engine-only; existing viewers reconnect, and a viewer-less
     // node is brought on screen by the next `focus`.
     transition(nodeId, 'revive');
+    // Clear any active fault the instant this node is (re)launched — don't wait
+    // for the fresh agent_start. A revive (auto or on-demand) is the recovery
+    // this marker advertised.
+    clearFault(nodeId);
     // Cancel-on-wake (design §6.4, AC-E1): every revive-for-any-reason (an inbox
     // event, a different wake, a manual focus) drops this node's pending deadline,
     // so the deadline always belongs to the dormancy being left. Writes only the
     // wakeups table, after the atomic transition above.
     cancelDeadlinesFor(nodeId);
-    headlessBrokerHost.launch(nodeId, inv, {
-        cwd: meta.cwd,
-        name: fullName(meta),
-        resuming,
-    });
+    let launched;
+    try {
+        launched = headlessBrokerHost.launch(nodeId, inv, {
+            cwd: meta.cwd,
+            name: fullName(meta),
+            resuming,
+        });
+    }
+    catch (error) {
+        try {
+            transition(nodeId, 'crash');
+        }
+        catch {
+            /* best-effort cleanup */
+        }
+        clearPid(nodeId);
+        throw new Error(`[broker] refusing to revive ${nodeId}: ${error.message}`);
+    }
     // Clear the stale pid so the daemon won't re-fire on it during the new
     // broker's boot. The fresh broker re-records its pid during extension bind; if
     // it never boots, the daemon's boot-grace + surfaceBootFailure own that case.
     clearPid(nodeId);
-    return { window: null, session: meta.tmux_session ?? null, resumed: resuming };
+    return { window: null, session: meta.tmux_session ?? null, resumed: resuming, launch: launched };
 }

package/dist/core/runtime/roadmap.d.ts

@@ -4,7 +4,7 @@ export declare function readRoadmap(nodeId: string): string | null;
 /** Seed a fresh, EXTREMELY BAREBONES roadmap scaffold — just the section
  *  skeleton with one-line prompts. Promotion lays this down so the file exists
  *  for a refresh; the owner fleshes it out as its next act (guided by its
- *  kind's roadmap skill). `goal`/`exitCriteria` pre-fill those sections when
+ *  roadmap memory doc). `goal`/`exitCriteria` pre-fill those sections when
  *  known (e.g. from the node's goal doc). Idempotent only if you intend it —
  *  call sites guard on hasRoadmap to avoid clobbering an evolved map. */
 export declare function seedRoadmap(nodeId: string, opts?: {

package/dist/core/runtime/roadmap.js

@@ -23,7 +23,7 @@ export function readRoadmap(nodeId) {
 /** Seed a fresh, EXTREMELY BAREBONES roadmap scaffold — just the section
  *  skeleton with one-line prompts. Promotion lays this down so the file exists
  *  for a refresh; the owner fleshes it out as its next act (guided by its
- *  kind's roadmap skill). `goal`/`exitCriteria` pre-fill those sections when
+ *  roadmap memory doc). `goal`/`exitCriteria` pre-fill those sections when
  *  known (e.g. from the node's goal doc). Idempotent only if you intend it —
  *  call sites guard on hasRoadmap to avoid clobbering an evolved map. */
 export function seedRoadmap(nodeId, opts = {}) {

package/dist/core/runtime/spawn.d.ts

@@ -11,7 +11,7 @@ export interface BootRootOpts {
  *  inline so THIS terminal becomes the broker's controller-viewer. Does not
  *  return — it process.exit()s when the inline attach exits (detach leaves the
  *  resident broker running, to be reconnected later). */
-export declare function bootRoot(opts: BootRootOpts): NodeMeta;
+export declare function bootRoot(opts: BootRootOpts): Promise<NodeMeta>;
 export interface SpawnChildOpts {
     kind: string;
     mode?: Mode;
@@ -70,4 +70,4 @@ export declare function resolveSpawner(parent: string | undefined, ctxNodeId: st
  *  With `root`: an independent resident root — parent=null, NO subscription back
  *  to the spawner (it carries spawned_by=spawner for provenance only), brought
  *  forefront so a human can pick up the conversation directly. */
-export declare function spawnChild(opts: SpawnChildOpts): SpawnChildResult;
+export declare function spawnChild(opts: SpawnChildOpts): Promise<SpawnChildResult>;

package/dist/core/runtime/spawn.js

@@ -24,11 +24,29 @@ import { registerViewerFocus, openViewerWindow, waitForBrokerViewSocket, viewerS
 import { transition } from './lifecycle.js';
 import { headlessBrokerHost } from './host.js';
 import { ensureDaemon } from '../../daemon/manage.js';
+// ---------------------------------------------------------------------------
+// Shared broker-launch wrapper — catch launch/preflight failures at the call
+// site, mark the node crashed, then rethrow a clear error.
+// ---------------------------------------------------------------------------
+function launchBrokerOrCrash(nodeId, inv, opts) {
+    try {
+        return headlessBrokerHost.launch(nodeId, inv, opts);
+    }
+    catch (error) {
+        try {
+            transition(nodeId, 'crash');
+        }
+        catch {
+            /* best-effort cleanup */
+        }
+        throw new Error(`[broker] refusing to launch ${nodeId}: ${error.message}`);
+    }
+}
 /** Create the front-door root: launch its broker engine, then exec `crtr attach`
  *  inline so THIS terminal becomes the broker's controller-viewer. Does not
  *  return — it process.exit()s when the inline attach exits (detach leaves the
  *  resident broker running, to be reconnected later). */
-export function bootRoot(opts) {
+export async function bootRoot(opts) {
     // crtr is tmux-only: the front door execs `crtr attach` inline in THIS pane to
     // become the root's controller-viewer, so there must be a tmux pane to anchor
     // on. Outside tmux there is no viewer surface — throw with a friendly message
@@ -98,7 +116,7 @@ export function bootRoot(opts) {
     // broker and the viewer reconnects), and THIS terminal execs `crtr attach`
     // inline to become its controller-viewer. The host sets CRTR_FRONT_DOOR.
     inv.env = { ...inv.env, CRTR_SUBTREE: rootOfSpine(meta.node_id) };
-    const placed = headlessBrokerHost.launch(meta.node_id, inv, {
+    const placed = launchBrokerOrCrash(meta.node_id, inv, {
         cwd: opts.cwd,
         name: fullName(meta),
         resuming: false,
@@ -112,7 +130,13 @@ export function bootRoot(opts) {
     // The terminal has nothing to attach to until view.sock accepts. The root is
     // useless without its engine, so a socket timeout IS fatal here (unlike a
     // background child's optional viewer, which is skipped on timeout).
-    if (!waitForBrokerViewSocket(meta.node_id)) {
+    if (!(await waitForBrokerViewSocket(meta.node_id, placed.exited))) {
+        try {
+            transition(meta.node_id, 'crash');
+        }
+        catch {
+            /* best-effort cleanup */
+        }
         throw new Error(`the front-door root broker ${meta.node_id} never bound its view socket — cannot attach.`);
     }
     const attachEnv = { ...process.env, ...viewerSplitEnv() };
@@ -210,7 +234,7 @@ export function resolveSpawner(parent, ctxNodeId, root) {
  *  With `root`: an independent resident root — parent=null, NO subscription back
  *  to the spawner (it carries spawned_by=spawner for provenance only), brought
  *  forefront so a human can pick up the conversation directly. */
-export function spawnChild(opts) {
+export async function spawnChild(opts) {
     try {
         ensureDaemon();
     }
@@ -292,7 +316,7 @@ export function spawnChild(opts) {
     // gets NO viewer — spawning it returns once the engine is launched and a human
     // opens a viewer on demand via `crtr node focus` / `crtr attach`. A --root gets
     // one foreground viewer below.
-    const placed = headlessBrokerHost.launch(meta.node_id, inv, {
+    const placed = launchBrokerOrCrash(meta.node_id, inv, {
         cwd: meta.cwd,
         name: fullName(meta),
         resuming: false,
@@ -313,7 +337,7 @@ export function spawnChild(opts) {
     // returns null) or the socket never binds — `focus` opens a viewer later.
     let window = null;
     let session = null;
-    if (root && here !== null && waitForBrokerViewSocket(meta.node_id)) {
+    if (root && here !== null && await waitForBrokerViewSocket(meta.node_id, placed.exited)) {
         const viewer = openViewerWindow(meta.node_id, here.session, { name: fullName(meta), cwd: opts.cwd });
         if (viewer !== null && viewer.pane !== null && viewer.pane !== '') {
             session = here.session;

package/dist/core/runtime/stop-guard.js

@@ -26,12 +26,17 @@ export function evaluateStop(nodeId, signals) {
         return { action: 'allow', reason: 'finished' };
     if (signals.askedHuman)
         return { action: 'allow', reason: 'escalated' };
+    // Already-terminal stored state wins before any stall logic: a node that is
+    // done/dead/canceled is not waiting to be re-prompted.
+    const node = getNode(nodeId);
+    if (node !== null && (node.status === 'done' || node.status === 'dead' || node.status === 'canceled')) {
+        return { action: 'allow', reason: 'finished' };
+    }
     // A RESIDENT node is interactable / human-driven and is never forced to submit
     // a final: stopping to go dormant is always legitimate (the inbox or the human
     // wakes it). Keyed on lifecycle, not parent — whether it has a parent doesn't
     // matter, only whether it's resident. Roots are resident by birth default, so
     // this still covers "don't nag the human's root" while generalizing it.
-    const node = getNode(nodeId);
     if (node !== null && node.lifecycle === 'resident') {
         return { action: 'allow', reason: 'dormant' };
     }

package/dist/core/runtime/tmux-chrome.d.ts

@@ -1 +1 @@
-export { installMenuBinding, installNavBindings, installViewNavBindings, sendKeysEnter } from './tmux.js';
+export { installMenuBinding, installNavBindings, installViewNavBindings, sendKeysEnter, displayMessage, paneCurrentPath } from './tmux.js';

package/dist/core/runtime/tmux-chrome.js

@@ -1,4 +1,4 @@
 // tmux-chrome.ts — chrome seam (§2.1): stateless keybind/input verbs.
 // The ONLY non-placement module allowed to import the tmux driver, per the
 // §5.1 lint. Re-exports the menu/nav/send-keys verbs callers (spawn, chord) need.
-export { installMenuBinding, installNavBindings, installViewNavBindings, sendKeysEnter } from './tmux.js';
+export { installMenuBinding, installNavBindings, installViewNavBindings, sendKeysEnter, displayMessage, paneCurrentPath } from './tmux.js';

package/dist/core/runtime/tmux.d.ts

@@ -72,6 +72,18 @@ export declare function closeWindow(window: string): boolean;
  *  root relaunch to re-title the viewer window when its pane is re-pointed at
  *  the freshly-minted node. Best-effort; false if tmux fails. */
 export declare function renameWindow(window: string, name: string): boolean;
+/** Break a single PANE out into a BRAND-NEW window of its own (`tmux break-pane
+ *  -d`). `-d` keeps the new window in the background (does not switch the client
+ *  to it); `-s <pane>` names the source pane — the §2.2 HARD DRIVER INVARIANT, so
+ *  the break never falls back to tmux's global current pane. The pane keeps its
+ *  durable `%id` across the move (only its window changes), so callers can keep
+ *  using the same pane handle. Returns the new `{window, pane}` location, or null
+ *  if tmux fails. Used by `canvas tmux-spread` to lift the caller's viewer into a
+ *  fresh window before tiling sibling viewers beside it. */
+export declare function breakPane(pane: string): {
+    window: string;
+    pane: string;
+} | null;
 /** Close a single PANE. Its window closes automatically once this was the last
  *  pane, but sibling panes survive — so co-located nodes (several agents sharing
  *  one window via swap-pane focus) are torn down one at a time instead of all
@@ -122,6 +134,11 @@ export declare function listLivePanes(): Set<string> | null;
  *  '#{pane_current_path}'`). Used to preserve a view monitor's cwd across a
  *  view-cycle respawn so project-scoped views still resolve. Null if tmux fails. */
 export declare function paneCurrentPath(pane: string): string | null;
+/** Flash a transient status-line toast on the client showing `pane` (or the
+ *  current client when `pane` is omitted). `ms` sets the display duration. Used
+ *  by `crtr canvas issue new` to confirm a capture from inside its popup.
+ *  Best-effort; never throws. */
+export declare function displayMessage(message: string, pane?: string, ms?: number): boolean;
 /** Set a PANE-scoped tmux option (`tmux set-option -p -t <pane> <name> <value>`).
  *  Used to tag a pane with the view id it currently hosts (`@crtr_view`) so the
  *  view-nav cycle can read it back and switch to the next/prev view in place.
@@ -169,6 +186,17 @@ export declare function windowAlive(session: string | null | undefined, window:
 /** Activate a window within its session (same-session navigation). Equivalent
  *  to `tmux select-window -t <session>:<window>`. Best-effort; never throws. */
 export declare function selectWindow(session: string, window: string): boolean;
+/** Apply a named tmux layout to a window (`tmux select-layout -t <window>
+ *  <layout>`). `canvas tmux-spread` calls it with `tiled` to evenly grid every
+ *  viewer pane in the spread window (and between splits, to redistribute space so
+ *  the next split has room). Best-effort; false if tmux fails. */
+export declare function selectLayout(window: string, layout: string): boolean;
+/** Make a pane the ACTIVE pane in its window (`tmux select-pane -t <pane>`). A
+ *  `split-window -d` keeps the CALLER active, so a freshly-opened viewer pane is
+ *  not focused until this runs — `focus` calls it so picking a node (e.g. from the
+ *  alt+g graph) lands the keyboard on the new viewer. Best-effort; false if tmux
+ *  fails. */
+export declare function selectPane(pane: string): boolean;
 /** Switch the tmux client to a different session (cross-session focus). Runs
  *  `tmux switch-client -t <session>`. Best-effort; never throws. The caller is
  *  responsible for following up with selectWindow to land on the right window. */
@@ -177,12 +205,7 @@ export declare function switchClient(session: string): boolean;
  *  (`tmux send-keys -t <pane> '<text>' Enter`). Requires the pane's editor be
  *  empty, same limitation as the menu's `/promote` item. Best-effort. */
 export declare function sendKeysEnter(pane: string, text: string): boolean;
-/** Bind Alt+C to the crouter action menu. Best-effort; false if tmux fails.
- *  The built-in items (promote/resume/demote/detach/close) are static; the canvas-nav
- *  chords (default g→graph, m→manager + any custom prefixBind) are appended
- *  from `canvasNav.prefixBinds`, each routed through `crtr canvas chord` (or, for
- *  the `__graph__` sentinel, a `send-keys '/graph'`) so the menu stays static
- *  while behaviour is config-driven. */
+/** Bind Alt+C to the crouter action menu. Best-effort; false if tmux fails. */
 export declare function installMenuBinding(): boolean;
 /** Bind Alt+] (forward) and Alt+[ (back) to the DFS canvas walk. Best-effort;
  *  false if either bind fails. NOTE: Alt+[ is only delivered cleanly when the