@north-light/crouter 0.3.317 → 0.3.319

package/dist/commands/canvas-roster.js

@@ -1,69 +1 @@
-import { defineLeaf } from '../core/command.js';
-import { cliClient, rethrowAsCliError } from './api-client.js';
-export const canvasRosterLeaf = defineLeaf({
-    name: 'roster',
-    description: 'emit the lean canvas topology roster as structured data',
-    whenToUse: 'you need a fast, set-based roster of every canvas node + subscribes_to edges for a browser or viewer poll loop; use `canvas snapshot` for the enriched on-demand view (ctx tokens, streaming, hanging, last activity)',
-    tier: 'hidden',
-    help: {
-        name: 'canvas roster',
-        summary: 'lean, set-based canvas topology roster (recurring poll target)',
-        params: [],
-        output: [
-            { name: 'generated_at', type: 'string', required: true, constraint: 'ISO timestamp when the roster was generated.' },
-            {
-                name: 'nodes',
-                type: 'object[]',
-                required: true,
-                constraint: 'Lean node rows plus attention_count for the returned node set.',
-            },
-            {
-                name: 'subscriptions',
-                type: 'object',
-                required: true,
-                constraint: 'Authoritative subscribes_to adjacency map: each node id maps to its publisher/child node ids in edge order.',
-            },
-            {
-                name: 'edges',
-                type: 'object[]',
-                required: true,
-                constraint: 'Subscription edges with from_id, to_id, active, and created fields.',
-            },
-        ],
-        outputKind: 'object',
-        effects: [
-            'Read-only: two indexed canvas.db scans server-side (nodes, subscribes_to edges) plus a bounded attention-count read for the returned node ids.',
-        ],
-        // Machine-readable dump for the browser/attach roster poll, not for an
-        // agent/human to glance at — collapse it in the attach viewer by default.
-        preview: { suppressOutput: true },
-    },
-    run: async () => {
-        // The lean roster (rosterNodes + rosterEdges, exactly two indexed queries,
-        // no enrichRows/per-row getNode) is built server-side in crtrd
-        // (`GET /v1/canvas/roster`). Attention counts stay a SEPARATE bounded read
-        // (`POST /v1/canvas/attention/counts`) — never folded into the roster query
-        // itself, which must stay indexed-scan-only.
-        const dto = await cliClient().canvasRoster().catch((err) => rethrowAsCliError(err));
-        const ids = dto.nodes.map((n) => n.node_id);
-        let counts = {};
-        try {
-            counts = ids.length > 0 ? (await cliClient().attentionCounts(ids)).counts : {};
-        }
-        catch {
-            // Ticket counts decorate the authoritative roster topology.
-        }
-        const nodes = dto.nodes.map((n) => ({ ...n, attention_count: counts[n.node_id] ?? 0 }));
-        const subscriptions = {};
-        for (const n of dto.nodes)
-            subscriptions[n.node_id] = [];
-        for (const e of dto.edges) {
-            const list = subscriptions[e.from_id];
-            if (list !== undefined)
-                list.push(e.to_id);
-            else
-                subscriptions[e.from_id] = [e.to_id];
-        }
-        return { generated_at: dto.generated_at, nodes, subscriptions, edges: dto.edges };
-    },
-});
+var c=Object.defineProperty;var a=(t,o)=>c(t,"name",{value:o,configurable:!0});import{defineLeaf as u}from"../core/command.js";import{cliClient as d,rethrowAsCliError as p}from"./api-client.js";const h=u({name:"roster",description:"emit the lean canvas topology roster as structured data",whenToUse:"you need a fast, set-based roster of every canvas node + subscribes_to edges for a browser or viewer poll loop; use `canvas snapshot` for the enriched on-demand view (ctx tokens, streaming, hanging, last activity)",tier:"hidden",help:{name:"canvas roster",summary:"lean, set-based canvas topology roster (recurring poll target)",params:[],output:[{name:"generated_at",type:"string",required:!0,constraint:"ISO timestamp when the roster was generated."},{name:"nodes",type:"object[]",required:!0,constraint:"Lean node rows plus attention_count for the returned node set."},{name:"subscriptions",type:"object",required:!0,constraint:"Authoritative subscribes_to adjacency map: each node id maps to its publisher/child node ids in edge order."},{name:"edges",type:"object[]",required:!0,constraint:"Subscription edges with from_id, to_id, active, and created fields."}],outputKind:"object",effects:["Read-only: two indexed canvas.db scans server-side (nodes, subscribes_to edges) plus a bounded attention-count read for the returned node ids."],preview:{suppressOutput:!0}},run:a(async()=>{const t=await d().canvasRoster().catch(e=>p(e)),o=t.nodes.map(e=>e.node_id);let n={};try{n=o.length>0?(await d().attentionCounts(o)).counts:{}}catch{}const i=t.nodes.map(e=>({...e,attention_count:n[e.node_id]??0})),s={};for(const e of t.nodes)s[e.node_id]=[];for(const e of t.edges){const r=s[e.from_id];r!==void 0?r.push(e.to_id):s[e.from_id]=[e.to_id]}return{generated_at:t.generated_at,nodes:i,subscriptions:s,edges:t.edges}},"run")});export{h as canvasRosterLeaf};

package/dist/commands/canvas-snapshot.js

@@ -1,34 +1 @@
-import { defineLeaf } from '../core/command.js';
-import { cliClient, rethrowAsCliError } from './api-client.js';
-export const canvasSnapshotLeaf = defineLeaf({
-    name: 'snapshot',
-    description: 'emit the browser canvas roster as structured data',
-    whenToUse: 'you need a machine-readable roster of every canvas node for a browser or local tool; use dashboard for the human-readable tree',
-    tier: 'hidden',
-    help: {
-        name: 'canvas snapshot',
-        summary: 'machine-readable snapshot of the whole canvas roster',
-        params: [],
-        output: [
-            { name: 'generated_at', type: 'string', required: true, constraint: 'ISO timestamp when the snapshot was generated.' },
-            { name: 'nodes', type: 'object[]', required: true, constraint: 'NodeSummary rows for browser canvas rendering.' },
-            { name: 'subscriptions', type: 'object', required: true, constraint: 'Authoritative subscribes_to adjacency map: each node id maps to its publisher/child node ids in edge order.' },
-        ],
-        outputKind: 'object',
-        effects: ['Read-only: queries canvas.db, focus rows, telemetry files, and pending human-reply counts.'],
-        // Machine-readable dump for the browser canvas, not for an agent/human to
-        // glance at — collapse it in the attach viewer by default.
-        preview: { suppressOutput: true },
-    },
-    run: async () => {
-        // The enriched roster (dashboardRowsAll + enrichRows) and the subscribes_to
-        // adjacency are built server-side in crtrd (`GET /v1/canvas/snapshot`).
-        try {
-            const dto = await cliClient().canvasSnapshot();
-            return { generated_at: dto.generated_at, nodes: dto.nodes, subscriptions: dto.subscriptions };
-        }
-        catch (err) {
-            rethrowAsCliError(err);
-        }
-    },
-});
+var a=Object.defineProperty;var r=(e,t)=>a(e,"name",{value:t,configurable:!0});import{defineLeaf as s}from"../core/command.js";import{cliClient as n,rethrowAsCliError as o}from"./api-client.js";const u=s({name:"snapshot",description:"emit the browser canvas roster as structured data",whenToUse:"you need a machine-readable roster of every canvas node for a browser or local tool; use dashboard for the human-readable tree",tier:"hidden",help:{name:"canvas snapshot",summary:"machine-readable snapshot of the whole canvas roster",params:[],output:[{name:"generated_at",type:"string",required:!0,constraint:"ISO timestamp when the snapshot was generated."},{name:"nodes",type:"object[]",required:!0,constraint:"NodeSummary rows for browser canvas rendering."},{name:"subscriptions",type:"object",required:!0,constraint:"Authoritative subscribes_to adjacency map: each node id maps to its publisher/child node ids in edge order."}],outputKind:"object",effects:["Read-only: queries canvas.db, focus rows, telemetry files, and pending human-reply counts."],preview:{suppressOutput:!0}},run:r(async()=>{try{const e=await n().canvasSnapshot();return{generated_at:e.generated_at,nodes:e.nodes,subscriptions:e.subscriptions}}catch(e){o(e)}},"run")});export{u as canvasSnapshotLeaf};

package/dist/commands/canvas-use.js

@@ -1,61 +1 @@
-// `crtr canvas use` — durably select which remote-capable read commands
-// (such as `node inspect list/show`) default onto: a named remote
-// target, or back to local. A single leaf, not a branch — there is exactly
-// one decision here (pick a target, or go local), not a family of verbs.
-import { defineLeaf } from '../core/command.js';
-import { InputError } from '../core/io.js';
-import { updateState } from '../core/config.js';
-import { getRemoteCanvasTarget } from '../core/remote-canvas-target.js';
-const SCOPE = 'user';
-export const canvasUseLeaf = defineLeaf({
-    name: 'use',
-    description: 'select the durable default canvas for read commands (a remote target, or local)',
-    whenToUse: 'switching what remote-capable read commands such as `node inspect list/show` read from by default, without passing `--canvas <name>` on every invocation \u2014 select a remote target registered via `crtr canvas config add`, or switch back to local. A command\u2019s own `--canvas <name>` flag always overrides this for that one call.',
-    help: {
-        name: 'canvas use',
-        summary: 'select the durable default canvas (a registered remote target, or local) for read commands',
-        params: [
-            { kind: 'positional', name: 'name', required: false, constraint: 'A remote canvas target registered via `crtr canvas config add`. Mutually exclusive with --local; exactly one of the two is required.' },
-            { kind: 'flag', name: 'local', type: 'bool', required: false, constraint: 'Switch back to the local canvas. Mutually exclusive with <name>.' },
-        ],
-        output: [],
-        outputKind: 'object',
-        effects: ['Writes state.json\u2019s activeCanvas (user scope).'],
-    },
-    run: async (input) => {
-        const name = input['name'];
-        const local = input['local'] === true;
-        if (name !== undefined && local) {
-            throw new InputError({
-                error: 'ambiguous_scope',
-                message: '<name> and --local are mutually exclusive',
-                next: 'Pass a target name to go remote, or --local to go local \u2014 not both.',
-            });
-        }
-        if (name === undefined && !local) {
-            throw new InputError({
-                error: 'missing_target',
-                message: 'nothing to select \u2014 pass a target name or --local',
-                next: 'Pass a target name (see `crtr canvas config list`) to go remote, or --local to go local.',
-            });
-        }
-        if (local) {
-            updateState(SCOPE, (s) => {
-                s.activeCanvas = null;
-            });
-            return {};
-        }
-        if (getRemoteCanvasTarget(name, SCOPE) === undefined) {
-            throw new InputError({
-                error: 'not_found',
-                message: `no remote canvas target named '${name}'`,
-                next: 'List configured targets with `crtr canvas config list`, or register one with `crtr canvas config add`.',
-            });
-        }
-        updateState(SCOPE, (s) => {
-            s.activeCanvas = name;
-        });
-        return {};
-    },
-    render: () => 'Canvas selection updated.'
-});
+var i=Object.defineProperty;var r=(a,e)=>i(a,"name",{value:e,configurable:!0});import{defineLeaf as l}from"../core/command.js";import{InputError as n}from"../core/io.js";import{updateState as c}from"../core/config.js";import{getRemoteCanvasTarget as m}from"../core/remote-canvas-target.js";const s="user",h=l({name:"use",description:"select the durable default canvas for read commands (a remote target, or local)",whenToUse:"switching what remote-capable read commands such as `node inspect list/show` read from by default, without passing `--canvas <name>` on every invocation \u2014 select a remote target registered via `crtr canvas config add`, or switch back to local. A command\u2019s own `--canvas <name>` flag always overrides this for that one call.",help:{name:"canvas use",summary:"select the durable default canvas (a registered remote target, or local) for read commands",params:[{kind:"positional",name:"name",required:!1,constraint:"A remote canvas target registered via `crtr canvas config add`. Mutually exclusive with --local; exactly one of the two is required."},{kind:"flag",name:"local",type:"bool",required:!1,constraint:"Switch back to the local canvas. Mutually exclusive with <name>."}],output:[],outputKind:"object",effects:["Writes state.json\u2019s activeCanvas (user scope)."]},run:r(async a=>{const e=a.name,t=a.local===!0;if(e!==void 0&&t)throw new n({error:"ambiguous_scope",message:"<name> and --local are mutually exclusive",next:"Pass a target name to go remote, or --local to go local \u2014 not both."});if(e===void 0&&!t)throw new n({error:"missing_target",message:"nothing to select \u2014 pass a target name or --local",next:"Pass a target name (see `crtr canvas config list`) to go remote, or --local to go local."});if(t)return c(s,o=>{o.activeCanvas=null}),{};if(m(e,s)===void 0)throw new n({error:"not_found",message:`no remote canvas target named '${e}'`,next:"List configured targets with `crtr canvas config list`, or register one with `crtr canvas config add`."});return c(s,o=>{o.activeCanvas=e}),{}},"run"),render:r(()=>"Canvas selection updated.","render")});export{h as canvasUseLeaf};

package/dist/commands/canvas.js

@@ -1,49 +1 @@
-// `crtr canvas` — observe and supervise the whole graph.
-//
-// Where `node` operates on one node and `push` is a node's own spine write
-// verb, `canvas` is the bird's-eye / supervisor surface over the entire canvas:
-// render the subscription forest (`dashboard`), see who is blocked on a human
-// (`attention`), and mass-reconnect disconnected nodes (`revive --all`). It assembles leaves/branches
-// the sibling command files own, so each piece declares its own help one level
-// down.
-import { defineBranch } from '../core/command.js';
-import { dashboardLeaf } from './dashboard.js';
-import { canvasSnapshotLeaf } from './canvas-snapshot.js';
-import { canvasRosterLeaf } from './canvas-roster.js';
-import { browseLeaf } from './canvas-browse.js';
-import { reviveLeaf } from './revive.js';
-import { attentionBranch } from './attention.js';
-import { chordLeaf } from './chord.js';
-import { canvasPruneLeaf } from './canvas-prune.js';
-import { historyBranch } from './canvas-history.js';
-import { issueNewLeaf } from './canvas-issue.js';
-import { canvasConfigBranch } from './canvas-config.js';
-import { canvasUseLeaf } from './canvas-use.js';
-export const issueBranch = defineBranch({
-    name: 'issue',
-    description: 'capture a quick todo/idea/bug into a GitHub issue (or a .todos/ note)',
-    whenToUse: 'the alt+c \u2192 i chord uses this; capture a passing thought without leaving your pane',
-    tier: 'hidden',
-    help: {
-        name: 'canvas issue',
-        summary: 'capture a quick todo/idea/bug into a GitHub issue',
-        model: 'Quick brain-dump capture, bound to the alt+c \u2192 i \u2192 (idea|bug) prefix chord. `new` reads a free-text note, auto-generates the title via a headless pi call, and files it with `gh issue create --label <type>` when the pane\u2019s cwd is a GitHub repo, else writes `<git-root>/.todos/<slug>.md`. Meant for the chord/popup, not hand-running.',
-    },
-    children: [issueNewLeaf],
-});
-export function registerCanvas() {
-    return defineBranch({
-        name: 'canvas',
-        rootEntry: {
-            concept: 'the whole agent graph at a glance — render it, see who is blocked, mass-revive disconnected nodes, and find or re-read prior node reports/context artifacts',
-            desc: 'bird\'s-eye view, supervision, and report/artifact history for the entire canvas',
-            useWhen: 'surveying the full graph, finding blocked agents, mass-reviving every disconnected node, or finding/re-reading prior reports/artifacts; run `crtr canvas -h`',
-        },
-        help: {
-            name: 'canvas',
-            summary: 'observe and supervise the whole agent graph',
-            model: 'Canvas-wide operations, distinct from per-node work (`node`) and a node\'s own spine write verb (`push`). `dashboard` renders the subscription forest as a tree; `browse` opens an interactive full-screen navigator (tabs/tree/search) over the whole canvas and resumes the chosen node; `attention` aggregates pending replies from the user across the graph; `revive --all` mass-reconnects every disconnected node (bringing back ONE named node is `node lifecycle revive <id>` instead); `history` searches and recalls the content record (reports + context docs) of past work in a cwd; `prune` bounds growth by deleting terminal nodes past a TTL. `config` registers/lists remote canvas targets (preview endpoint + relay token); `use` switches remote-capable read commands such as `node inspect` onto a configured target or back to local.',
-        },
-        children: [dashboardLeaf, canvasSnapshotLeaf, canvasRosterLeaf, browseLeaf, attentionBranch, reviveLeaf, historyBranch, chordLeaf, issueBranch, canvasPruneLeaf, canvasConfigBranch, canvasUseLeaf],
-    });
-}
+var o=Object.defineProperty;var e=(a,t)=>o(a,"name",{value:t,configurable:!0});import{defineBranch as r}from"../core/command.js";import{dashboardLeaf as n}from"./dashboard.js";import{canvasSnapshotLeaf as s}from"./canvas-snapshot.js";import{canvasRosterLeaf as i}from"./canvas-roster.js";import{browseLeaf as c}from"./canvas-browse.js";import{reviveLeaf as d}from"./revive.js";import{attentionBranch as h}from"./attention.js";import{chordLeaf as p}from"./chord.js";import{canvasPruneLeaf as u}from"./canvas-prune.js";import{historyBranch as m}from"./canvas-history.js";import{issueNewLeaf as f}from"./canvas-issue.js";import{canvasConfigBranch as l}from"./canvas-config.js";import{canvasUseLeaf as g}from"./canvas-use.js";const v=r({name:"issue",description:"capture a quick todo/idea/bug into a GitHub issue (or a .todos/ note)",whenToUse:"the alt+c \u2192 i chord uses this; capture a passing thought without leaving your pane",tier:"hidden",help:{name:"canvas issue",summary:"capture a quick todo/idea/bug into a GitHub issue",model:"Quick brain-dump capture, bound to the alt+c \u2192 i \u2192 (idea|bug) prefix chord. `new` reads a free-text note, auto-generates the title via a headless pi call, and files it with `gh issue create --label <type>` when the pane\u2019s cwd is a GitHub repo, else writes `<git-root>/.todos/<slug>.md`. Meant for the chord/popup, not hand-running."},children:[f]});function U(){return r({name:"canvas",rootEntry:{concept:"the whole agent graph at a glance \u2014 render it, see who is blocked, mass-revive disconnected nodes, and find or re-read prior node reports/context artifacts",desc:"bird's-eye view, supervision, and report/artifact history for the entire canvas",useWhen:"surveying the full graph, finding blocked agents, mass-reviving every disconnected node, or finding/re-reading prior reports/artifacts; run `crtr canvas -h`"},help:{name:"canvas",summary:"observe and supervise the whole agent graph",model:"Canvas-wide operations, distinct from per-node work (`node`) and a node's own spine write verb (`push`). `dashboard` renders the subscription forest as a tree; `browse` opens an interactive full-screen navigator (tabs/tree/search) over the whole canvas and resumes the chosen node; `attention` aggregates pending replies from the user across the graph; `revive --all` mass-reconnects every disconnected node (bringing back ONE named node is `node lifecycle revive <id>` instead); `history` searches and recalls the content record (reports + context docs) of past work in a cwd; `prune` bounds growth by deleting terminal nodes past a TTL. `config` registers/lists remote canvas targets (preview endpoint + relay token); `use` switches remote-capable read commands such as `node inspect` onto a configured target or back to local."},children:[n,s,i,c,h,d,m,p,v,u,l,g]})}e(U,"registerCanvas");export{v as issueBranch,U as registerCanvas};

package/dist/commands/chord.js

@@ -1,241 +1 @@
-// `crtr canvas chord` — the tmux prefix-menu dispatcher.
-//
-// The alt+c display-menu can't see the cursor node or read config at popup time
-// — it only knows the active pane. So the menu hands this leaf a resolved `--run`
-// string plus the originating pane id; this dispatcher resolves the node in that
-// pane, interpolates the node vars, and execs `crtr <argv>` with no shell.
-//
-// execFile/spawn (never `sh -c`) keeps the argv literal, so shell metacharacters
-// in config data cannot inject.
-import { spawn, execFile } from 'node:child_process';
-import { promisify } from 'node:util';
-import { defineLeaf } from '../core/command.js';
-import { InputError } from '../core/io.js';
-import { cliCanvasSource, getNodeOrNull } from './api-client.js';
-import { fullName } from '../core/canvas/labels.js';
-import { getPaneOption } from '../core/runtime/tmux-chrome.js';
-const pexec = promisify(execFile);
-/** The live node whose viewer pane carries the `@crtr_node` tag. Reimplemented
- *  here rather than importing node.ts's `nodeInPane` (which reaches openDb via the
- *  canvas accessors) so this dispatcher's import graph stays db-free. Under the
- *  headless-broker model every engine runs DETACHED (window=null), so the pane tag
- *  is the ONLY node handle. A stale tag is ignored
- *  (the tagged node must still be live), validated through the daemon API. */
-async function nodeInPane(pane) {
-    if (pane === undefined || pane === '')
-        return undefined;
-    const tagged = getPaneOption(pane, '@crtr_node');
-    if (tagged === undefined || tagged === '')
-        return undefined;
-    const meta = await getNodeOrNull(tagged);
-    if (meta !== null && (meta.status === 'active' || meta.status === 'idle'))
-        return tagged;
-    return undefined;
-}
-/** Template vars available to a `run` string. Single-valued vars interpolate
- *  in place (preserving spaces, e.g. a node name); `{pane}` is the active tmux
- *  pane id; `{subtree}` is multi-valued and a bare `{subtree}` token expands to
- *  several argv elements. */
-async function buildVars(selfId, pane) {
-    const source = cliCanvasSource();
-    const [node, subs, viewIds] = await Promise.all([
-        source.getNode(selfId),
-        source.subscribersOf(selfId),
-        source.view(selfId),
-    ]);
-    const manager = subs[0]?.node_id ?? '';
-    return {
-        id: selfId,
-        self: selfId,
-        pane,
-        lane: selfId,
-        name: node !== null ? fullName(node) : selfId,
-        manager,
-        subtree: viewIds.join(' '),
-    };
-}
-function parseRun(run) {
-    const out = [];
-    let cur = '';
-    let quoted = null;
-    let escaped = false;
-    let inToken = false;
-    const push = () => {
-        if (!inToken)
-            return;
-        out.push(cur);
-        cur = '';
-        inToken = false;
-    };
-    for (let i = 0; i < run.length; i++) {
-        const ch = run[i];
-        if (escaped) {
-            cur += ch;
-            inToken = true;
-            escaped = false;
-            continue;
-        }
-        if (quoted === 'single') {
-            if (ch === "'") {
-                quoted = null;
-            }
-            else {
-                cur += ch;
-                inToken = true;
-            }
-            continue;
-        }
-        if (quoted === 'double') {
-            if (ch === '"') {
-                quoted = null;
-            }
-            else if (ch === '\\') {
-                escaped = true;
-            }
-            else {
-                cur += ch;
-                inToken = true;
-            }
-            continue;
-        }
-        if (/\s/.test(ch)) {
-            push();
-            continue;
-        }
-        if (ch === "'") {
-            quoted = 'single';
-            inToken = true;
-            continue;
-        }
-        if (ch === '"') {
-            quoted = 'double';
-            inToken = true;
-            continue;
-        }
-        if (ch === '\\') {
-            escaped = true;
-            inToken = true;
-            continue;
-        }
-        cur += ch;
-        inToken = true;
-    }
-    if (escaped) {
-        cur += '\\';
-        inToken = true;
-    }
-    if (quoted !== null) {
-        throw new InputError({
-            error: 'bad_run',
-            message: 'invalid canvas run string: unterminated quote',
-            next: 'Fix the bind in config.json and try again.',
-        });
-    }
-    push();
-    return out;
-}
-/** Split a `run` string argv-style and interpolate the template vars. A bare
- *  `{subtree}` token expands to several argv elements; every other placeholder
- *  is substituted in place (kept as one element so a multi-word name survives
- *  as a single argument under execFile). */
-function interpolateArgv(run, vars) {
-    const out = [];
-    for (const tok of parseRun(run)) {
-        if (tok === '{subtree}') {
-            for (const part of (vars['subtree'] ?? '').split(/\s+/).filter((p) => p !== ''))
-                out.push(part);
-            continue;
-        }
-        out.push(tok.replace(/\{(\w+)\}/g, (_, name) => vars[name] ?? ''));
-    }
-    return out;
-}
-async function dispatch(argv, interactive) {
-    if (argv.length === 0)
-        return;
-    if (interactive) {
-        await new Promise((resolve) => {
-            try {
-                const child = spawn('crtr', argv, { stdio: 'inherit' });
-                child.once('error', () => resolve());
-                child.once('close', () => resolve());
-            }
-            catch {
-                resolve();
-            }
-        });
-        return;
-    }
-    try {
-        await pexec('crtr', argv, { timeout: 15_000 });
-    }
-    catch {
-        /* best-effort: the keystroke just acts; errors are surfaced by the inner cmd */
-    }
-}
-export const chordLeaf = defineLeaf({
-    name: 'chord',
-    description: 'tmux prefix-menu dispatcher (bound by alt+c; not run by hand)',
-    whenToUse: 'never directly — the alt+c menu routes node-relative actions through it',
-    tier: 'hidden',
-    help: {
-        name: 'canvas chord',
-        summary: 'tmux prefix-menu dispatcher — resolve the node in --pane, interpolate --run against it, and exec `crtr <argv>`. Bound by the alt+c menu; not meant to be run by hand.',
-        params: [
-            {
-                kind: 'flag',
-                name: 'pane',
-                type: 'string',
-                required: false,
-                constraint: 'tmux pane id whose node the chord acts on. Defaults to $TMUX_PANE / your current pane.',
-            },
-            {
-                kind: 'flag',
-                name: 'run',
-                type: 'string',
-                required: true,
-                constraint: 'The argv string to run as crtr, after node vars resolve.',
-            },
-            {
-                kind: 'flag',
-                name: 'interactive',
-                type: 'bool',
-                required: false,
-                constraint: 'When true, inherit stdio so popup forms can read from the popup tty.',
-            },
-        ],
-        output: [
-            { name: 'ran', type: 'boolean', required: true, constraint: 'True when an action was dispatched.' },
-            { name: 'node_id', type: 'string', required: false, constraint: 'The node the chord resolved against.' },
-            { name: 'action', type: 'string', required: false, constraint: 'What ran: a crtr argv string or "noop".' },
-        ],
-        outputKind: 'object',
-        effects: ['Runs a `crtr` subcommand per the resolved bind.'],
-    },
-    run: async (input) => {
-        const rawPane = input['pane'];
-        const pane = rawPane !== undefined && rawPane !== '' ? rawPane : process.env['TMUX_PANE'];
-        const run = input['run']?.trim();
-        const interactive = input['interactive'] === true;
-        if (run === undefined || run === '') {
-            throw new InputError({
-                error: 'missing_run',
-                message: 'no run string provided',
-                next: 'Pass --run <argv-string> from the menu renderer.',
-            });
-        }
-        const selfId = await nodeInPane(pane);
-        if (selfId === undefined) {
-            throw new InputError({
-                error: 'no_node',
-                message: 'no node found in this pane',
-                next: 'Run from inside an agent\'s pane, or pass --pane <pane-id>.',
-            });
-        }
-        const argv = interpolateArgv(run, await buildVars(selfId, pane ?? ''));
-        if (argv.length === 0)
-            return { ran: false, node_id: selfId, action: 'noop' };
-        await dispatch(argv, interactive);
-        return { ran: true, node_id: selfId, action: `crtr ${argv.join(' ')}` };
-    },
-});
+var f=Object.defineProperty;var u=(e,r)=>f(e,"name",{value:r,configurable:!0});import{spawn as l,execFile as p}from"node:child_process";import{promisify as m}from"node:util";import{defineLeaf as h}from"../core/command.js";import{InputError as d}from"../core/io.js";import{cliCanvasSource as g,getNodeOrNull as w}from"./api-client.js";import{fullName as b}from"../core/canvas/labels.js";import{getPaneOption as y}from"../core/runtime/tmux-chrome.js";const v=m(p);async function x(e){if(e===void 0||e==="")return;const r=y(e,"@crtr_node");if(r===void 0||r==="")return;const n=await w(r);if(n!==null&&(n.status==="active"||n.status==="idle"))return r}u(x,"nodeInPane");async function _(e,r){const n=g(),[i,o,t]=await Promise.all([n.getNode(e),n.subscribersOf(e),n.view(e)]),s=o[0]?.node_id??"";return{id:e,self:e,pane:r,lane:e,name:i!==null?b(i):e,manager:s,subtree:t.join(" ")}}u(_,"buildVars");function q(e){const r=[];let n="",i=null,o=!1,t=!1;const s=u(()=>{t&&(r.push(n),n="",t=!1)},"push");for(let c=0;c<e.length;c++){const a=e[c];if(o){n+=a,t=!0,o=!1;continue}if(i==="single"){a==="'"?i=null:(n+=a,t=!0);continue}if(i==="double"){a==='"'?i=null:a==="\\"?o=!0:(n+=a,t=!0);continue}if(/\s/.test(a)){s();continue}if(a==="'"){i="single",t=!0;continue}if(a==='"'){i="double",t=!0;continue}if(a==="\\"){o=!0,t=!0;continue}n+=a,t=!0}if(o&&(n+="\\",t=!0),i!==null)throw new d({error:"bad_run",message:"invalid canvas run string: unterminated quote",next:"Fix the bind in config.json and try again."});return s(),r}u(q,"parseRun");function P(e,r){const n=[];for(const i of q(e)){if(i==="{subtree}"){for(const o of(r.subtree??"").split(/\s+/).filter(t=>t!==""))n.push(o);continue}n.push(i.replace(/\{(\w+)\}/g,(o,t)=>r[t]??""))}return n}u(P,"interpolateArgv");async function T(e,r){if(e.length!==0){if(r){await new Promise(n=>{try{const i=l("crtr",e,{stdio:"inherit"});i.once("error",()=>n()),i.once("close",()=>n())}catch{n()}});return}try{await v("crtr",e,{timeout:15e3})}catch{}}}u(T,"dispatch");const F=h({name:"chord",description:"tmux prefix-menu dispatcher (bound by alt+c; not run by hand)",whenToUse:"never directly \u2014 the alt+c menu routes node-relative actions through it",tier:"hidden",help:{name:"canvas chord",summary:"tmux prefix-menu dispatcher \u2014 resolve the node in --pane, interpolate --run against it, and exec `crtr <argv>`. Bound by the alt+c menu; not meant to be run by hand.",params:[{kind:"flag",name:"pane",type:"string",required:!1,constraint:"tmux pane id whose node the chord acts on. Defaults to $TMUX_PANE / your current pane."},{kind:"flag",name:"run",type:"string",required:!0,constraint:"The argv string to run as crtr, after node vars resolve."},{kind:"flag",name:"interactive",type:"bool",required:!1,constraint:"When true, inherit stdio so popup forms can read from the popup tty."}],output:[{name:"ran",type:"boolean",required:!0,constraint:"True when an action was dispatched."},{name:"node_id",type:"string",required:!1,constraint:"The node the chord resolved against."},{name:"action",type:"string",required:!1,constraint:'What ran: a crtr argv string or "noop".'}],outputKind:"object",effects:["Runs a `crtr` subcommand per the resolved bind."]},run:u(async e=>{const r=e.pane,n=r!==void 0&&r!==""?r:process.env.TMUX_PANE,i=e.run?.trim(),o=e.interactive===!0;if(i===void 0||i==="")throw new d({error:"missing_run",message:"no run string provided",next:"Pass --run <argv-string> from the menu renderer."});const t=await x(n);if(t===void 0)throw new d({error:"no_node",message:"no node found in this pane",next:"Run from inside an agent's pane, or pass --pane <pane-id>."});const s=P(i,await _(t,n??""));return s.length===0?{ran:!1,node_id:t,action:"noop"}:(await T(s,o),{ran:!0,node_id:t,action:`crtr ${s.join(" ")}`})},"run")});export{F as chordLeaf};