@north-light/crouter 0.3.318 → 0.3.320

package/dist/commands/surface/node/focus.js

@@ -1,81 +1 @@
-// `crtr surface node focus` — bring one viewer forward.
-import { defineLeaf } from '../../../core/command.js';
-import { InputError } from '../../../core/io.js';
-import { isFinishedWork, isLiveStatus } from '../../../core/canvas/node-order.js';
-import { cliClient, rethrowAsCliError } from '../../api-client.js';
-import { currentTmux, displayPopup, focusViewer, shellQuote } from './placement.js';
-export const surfaceNodeFocusLeaf = defineLeaf({
-    name: 'focus',
-    description: 'bring a node into view without waking parked or finished work',
-    whenToUse: 'you want to bring a specific node into view — a live node opens beside your pane, while a parked resident opens its saved conversation without waking until input is submitted. FINISHED work — a terminal worker, or any node that pushed a final report — opens its saved transcript instead of being put back to work. Use `node lifecycle revive` to deliberately relaunch finished work anyway. Use `surface node cycle` to walk neighbors, and `node message send` to steer without leaving where you are',
-    help: {
-        name: 'surface node focus',
-        summary: 'bring a node into view — attach live, open a parked resident without waking it, or inspect finished work as a saved transcript',
-        params: [
-            { kind: 'positional', name: 'node', required: true, constraint: 'Node id to focus.' },
-            { kind: 'flag', name: 'new-pane', type: 'bool', required: false, constraint: 'Always open a NEW viewer SIDE-BY-SIDE with your current pane instead of moving/reusing the node\'s existing viewer. Two agents on screen at once (F4).' },
-            { kind: 'flag', name: 'in-place', type: 'bool', required: false, constraint: 'Re-exec the --pane pane ONTO this node, REPLACING whatever viewer it showed (a swap in place, not a split beside). Backs the attach viewer\'s subagent scroll+swap (↓ into the reports roster, Enter dives into the child right in your pane). MUST be driven from OUTSIDE that pane\'s process tree (e.g. `tmux run-shell`) — respawn-pane -k kills whatever runs in it. Mutually exclusive with --new-pane.' },
-            { kind: 'flag', name: 'pane', type: 'string', required: false, constraint: 'tmux pane id to focus beside (default: caller TMUX_PANE). Used by the canvas browser popup to focus back into the originating pane.' },
-        ],
-        output: [
-            { name: 'focused', type: 'boolean', required: true, constraint: 'True when the node\'s viewer was brought into view.' },
-            { name: 'session', type: 'string', required: false, constraint: 'The tmux session the viewer lives in.' },
-            { name: 'revived', type: 'boolean', required: true, constraint: 'True when focusing had to recover a non-parked node\'s broker; false for an already attached viewer, an offline parked resident, or saved-transcript inspection.' },
-            { name: 'in_place', type: 'boolean', required: true, constraint: 'True when an existing viewer was navigated to (no new pane); false when a fresh viewer pane was opened or moved beside you.' },
-        ],
-        outputKind: 'object',
-        effects: ['For active/idle nodes: opens/moves the one surface-attach viewer beside the caller, or navigates to its existing viewer.', 'For an unfinalized parked resident: opens the normal conversation viewer from its saved snapshot without launching a broker or changing lifecycle; submitting input sends the durable human message that wakes it.', 'For finished work (a terminal node, or any node with a final report): opens a read-only saved transcript popup. It does not launch a broker or change node status.', 'With --new-pane/--in-place on a conversation viewer: controls whether the viewer splits beside or replaces the caller pane.'],
-    },
-    run: async (input) => {
-        const id = input['node'];
-        const node = await cliClient()
-            .getNode(id)
-            .catch((err) => rethrowAsCliError(err, 'List nodes with `crtr node inspect list`.'));
-        // A kind:'human' node is a control-plane ASK (a page on the human's
-        // screen), NOT a pi conversation — it has no session. Reviving one boots a
-        // confused blank "you have been revived" pi, so refuse rather than focus it.
-        // (The nav/resume UIs already hide human nodes; this guards a hand-typed id.)
-        if (node.kind === 'human') {
-            throw new InputError({
-                error: 'not_focusable',
-                message: `node ${id} is a human-ask (kind:human), not a conversation — it has no pi session to focus.`,
-                next: `The pending question is queued for the user; see it with \`crtr human list\`, or retract it with \`crtr human cancel ${id}\`.`,
-            });
-        }
-        // Every focus needs a pane to place the viewer or popup into. Resolve it ONCE
-        // here and fail loudly when there is none: both downstream paths would
-        // otherwise return `focused: false` with no explanation, which reads as the
-        // command silently doing nothing.
-        const pane = input['pane'] ?? process.env['TMUX_PANE'] ?? currentTmux()?.pane;
-        if (pane === undefined || pane === '') {
-            throw new InputError({
-                error: 'no_pane',
-                message: `no tmux pane to focus ${id} into — surfaces need a tmux server, and this call has neither --pane nor a caller pane.`,
-                next: `Run it from inside tmux, pass \`--pane <id>\`, or read the node without a surface: \`crtr node inspect transcript ${id}\`.`,
-            });
-        }
-        // Opening history is not resuming work — but a non-live STATUS does not by
-        // itself mean the node finished anything. Finished work (a terminal worker, or
-        // any node that pushed a final report) is archive: show its persisted
-        // transcript, because reviving it would set completed work back in motion, and
-        // `node lifecycle revive` remains the explicit way to do that on purpose.
-        // A RESIDENT node with no final report never finished — its parked `done`
-        // falls through to the conversation path, where focus can seat its saved
-        // snapshot without launching an engine.
-        if (!isLiveStatus(node.status) && isFinishedWork({ lifecycle: node.lifecycle, finalized: node.final_report != null })) {
-            const focused = displayPopup(pane, node.cwd, `crtr node inspect transcript ${shellQuote(id)}`);
-            return { focused, session: null, revived: false, in_place: false };
-        }
-        // Local viewer tail: open/move the normal conversation viewer beside the
-        // caller. The server owns the serialized live-vs-parked decision; pure tmux
-        // operations own pane placement.
-        const res = await focusViewer(id, {
-            cwd: node.cwd,
-            name: node.name,
-            pane,
-            newPane: input['newPane'] === true,
-            inPlace: input['inPlace'] === true,
-        });
-        return { focused: res.focused, session: res.session, revived: res.revived, in_place: res.inPlace };
-    },
-});
+var d=Object.defineProperty;var o=(t,e)=>d(t,"name",{value:e,configurable:!0});import{defineLeaf as c}from"../../../core/command.js";import{InputError as s}from"../../../core/io.js";import{isFinishedWork as u,isLiveStatus as p}from"../../../core/canvas/node-order.js";import{cliClient as l,rethrowAsCliError as h}from"../../api-client.js";import{currentTmux as w,displayPopup as f,focusViewer as v,shellQuote as m}from"./placement.js";const E=c({name:"focus",description:"bring a node into view without waking parked or finished work",whenToUse:"you want to bring a specific node into view \u2014 a live node opens beside your pane, while a parked resident opens its saved conversation without waking until input is submitted. FINISHED work \u2014 a terminal worker, or any node that pushed a final report \u2014 opens its saved transcript instead of being put back to work. Use `node lifecycle revive` to deliberately relaunch finished work anyway. Use `surface node cycle` to walk neighbors, and `node message send` to steer without leaving where you are",help:{name:"surface node focus",summary:"bring a node into view \u2014 attach live, open a parked resident without waking it, or inspect finished work as a saved transcript",params:[{kind:"positional",name:"node",required:!0,constraint:"Node id to focus."},{kind:"flag",name:"new-pane",type:"bool",required:!1,constraint:"Always open a NEW viewer SIDE-BY-SIDE with your current pane instead of moving/reusing the node's existing viewer. Two agents on screen at once (F4)."},{kind:"flag",name:"in-place",type:"bool",required:!1,constraint:"Re-exec the --pane pane ONTO this node, REPLACING whatever viewer it showed (a swap in place, not a split beside). Backs the attach viewer's subagent scroll+swap (\u2193 into the reports roster, Enter dives into the child right in your pane). MUST be driven from OUTSIDE that pane's process tree (e.g. `tmux run-shell`) \u2014 respawn-pane -k kills whatever runs in it. Mutually exclusive with --new-pane."},{kind:"flag",name:"pane",type:"string",required:!1,constraint:"tmux pane id to focus beside (default: caller TMUX_PANE). Used by the canvas browser popup to focus back into the originating pane."}],output:[{name:"focused",type:"boolean",required:!0,constraint:"True when the node's viewer was brought into view."},{name:"session",type:"string",required:!1,constraint:"The tmux session the viewer lives in."},{name:"revived",type:"boolean",required:!0,constraint:"True when focusing had to recover a non-parked node's broker; false for an already attached viewer, an offline parked resident, or saved-transcript inspection."},{name:"in_place",type:"boolean",required:!0,constraint:"True when an existing viewer was navigated to (no new pane); false when a fresh viewer pane was opened or moved beside you."}],outputKind:"object",effects:["For active/idle nodes: opens/moves the one surface-attach viewer beside the caller, or navigates to its existing viewer.","For an unfinalized parked resident: opens the normal conversation viewer from its saved snapshot without launching a broker or changing lifecycle; submitting input sends the durable human message that wakes it.","For finished work (a terminal node, or any node with a final report): opens a read-only saved transcript popup. It does not launch a broker or change node status.","With --new-pane/--in-place on a conversation viewer: controls whether the viewer splits beside or replaces the caller pane."]},run:o(async t=>{const e=t.node,n=await l().getNode(e).catch(r=>h(r,"List nodes with `crtr node inspect list`."));if(n.kind==="human")throw new s({error:"not_focusable",message:`node ${e} is a human-ask (kind:human), not a conversation \u2014 it has no pi session to focus.`,next:`The pending question is queued for the user; see it with \`crtr human list\`, or retract it with \`crtr human cancel ${e}\`.`});const a=t.pane??process.env.TMUX_PANE??w()?.pane;if(a===void 0||a==="")throw new s({error:"no_pane",message:`no tmux pane to focus ${e} into \u2014 surfaces need a tmux server, and this call has neither --pane nor a caller pane.`,next:`Run it from inside tmux, pass \`--pane <id>\`, or read the node without a surface: \`crtr node inspect transcript ${e}\`.`});if(!p(n.status)&&u({lifecycle:n.lifecycle,finalized:n.final_report!=null}))return{focused:f(a,n.cwd,`crtr node inspect transcript ${m(e)}`),session:null,revived:!1,in_place:!1};const i=await v(e,{cwd:n.cwd,name:n.name,pane:a,newPane:t.newPane===!0,inPlace:t.inPlace===!0});return{focused:i.focused,session:i.session,revived:i.revived,in_place:i.inPlace}},"run")});export{E as surfaceNodeFocusLeaf};

package/dist/commands/surface/node/id.js

@@ -1,38 +1 @@
-// `crtr surface node id` — copy a viewer's node id.
-import { defineLeaf } from '../../../core/command.js';
-import { InputError } from '../../../core/io.js';
-import { writeClipboardText } from '../../../core/clipboard-text.js';
-import { displayMessage } from '../../../core/runtime/tmux-chrome.js';
-import { nodeInPane } from './placement.js';
-export const surfaceNodeIdLeaf = defineLeaf({
-    name: 'id',
-    description: 'copy the focused node id to the system clipboard',
-    whenToUse: 'you need the id of the node in a tmux pane for a follow-up command or external reference',
-    help: {
-        name: 'surface node id',
-        summary: 'copy the node resolved from a tmux pane to the system clipboard',
-        params: [
-            { kind: 'flag', name: 'pane', type: 'string', required: false, constraint: 'tmux pane id whose focused node to copy. Defaults to $TMUX_PANE / your current pane.' },
-        ],
-        output: [
-            { name: 'node_id', type: 'string', required: true, constraint: 'The focused node id copied to the system clipboard.' },
-        ],
-        outputKind: 'object',
-        effects: ['Writes the focused node id to the system clipboard and shows a transient tmux confirmation.'],
-    },
-    run: async (input) => {
-        const pane = input['pane'] ?? process.env['TMUX_PANE'];
-        const nodeId = nodeInPane(pane);
-        if (nodeId === undefined) {
-            displayMessage('crtr: no node in pane', pane);
-            throw new InputError({ error: 'no_node', message: 'no node found in this pane', next: 'Pass --pane <pane-id> for a pane showing an active node.' });
-        }
-        if (!writeClipboardText(nodeId)) {
-            displayMessage('crtr: copy failed', pane);
-            throw new InputError({ error: 'clipboard_write_failed', message: 'could not write the node id to the system clipboard', next: 'Make a system clipboard tool available, then retry.' });
-        }
-        displayMessage('crtr: node id copied', pane);
-        return { node_id: nodeId };
-    },
-    render: (r) => `Copied node id: ${r['node_id']}`,
-});
+var a=Object.defineProperty;var t=(o,e)=>a(o,"name",{value:e,configurable:!0});import{defineLeaf as i}from"../../../core/command.js";import{InputError as d}from"../../../core/io.js";import{writeClipboardText as s}from"../../../core/clipboard-text.js";import{displayMessage as r}from"../../../core/runtime/tmux-chrome.js";import{nodeInPane as p}from"./placement.js";const y=i({name:"id",description:"copy the focused node id to the system clipboard",whenToUse:"you need the id of the node in a tmux pane for a follow-up command or external reference",help:{name:"surface node id",summary:"copy the node resolved from a tmux pane to the system clipboard",params:[{kind:"flag",name:"pane",type:"string",required:!1,constraint:"tmux pane id whose focused node to copy. Defaults to $TMUX_PANE / your current pane."}],output:[{name:"node_id",type:"string",required:!0,constraint:"The focused node id copied to the system clipboard."}],outputKind:"object",effects:["Writes the focused node id to the system clipboard and shows a transient tmux confirmation."]},run:t(async o=>{const e=o.pane??process.env.TMUX_PANE,n=p(e);if(n===void 0)throw r("crtr: no node in pane",e),new d({error:"no_node",message:"no node found in this pane",next:"Pass --pane <pane-id> for a pane showing an active node."});if(!s(n))throw r("crtr: copy failed",e),new d({error:"clipboard_write_failed",message:"could not write the node id to the system clipboard",next:"Make a system clipboard tool available, then retry."});return r("crtr: node id copied",e),{node_id:n}},"run"),render:t(o=>`Copied node id: ${o.node_id}`,"render")});export{y as surfaceNodeIdLeaf};

package/dist/commands/surface/node/pin.js

@@ -1,42 +1 @@
-// `crtr surface node pin` — navigator pin control for a viewer.
-import { defineLeaf } from '../../../core/command.js';
-import { InputError } from '../../../core/io.js';
-import { displayMessage } from '../../../core/runtime/tmux-chrome.js';
-import { loadPins, savePins } from '../../../core/canvas/browse/pins.js';
-import { nodeInPane } from './placement.js';
-export const surfaceNodePinLeaf = defineLeaf({
-    name: 'pin',
-    description: 'pin or unpin the node in a tmux pane in the canvas navigator',
-    whenToUse: 'you want the conversation in this pane starred at the top of your canvas navigator (the same pin `canvas browse` toggles), without opening the navigator to do it',
-    help: {
-        name: 'surface node pin',
-        summary: 'toggle the canvas-navigator pin on the node resolved from a tmux pane — a local, per-user view preference that sorts the node to the top of your navigator and fills its Pinned tab, mutating nothing on the canvas',
-        params: [
-            { kind: 'flag', name: 'pane', type: 'string', required: false, constraint: 'tmux pane id whose focused node to pin. Defaults to $TMUX_PANE / your current pane.' },
-        ],
-        output: [
-            { name: 'node_id', type: 'string', required: true, constraint: 'The node whose pin was toggled.' },
-            { name: 'pinned', type: 'boolean', required: true, constraint: 'True when the node is now pinned, false when the pin was removed.' },
-        ],
-        outputKind: 'object',
-        effects: ['Toggles the node in the per-user navigator pin set and shows a transient tmux confirmation.'],
-    },
-    run: async (input) => {
-        const pane = input['pane'] ?? process.env['TMUX_PANE'];
-        const nodeId = nodeInPane(pane);
-        if (nodeId === undefined) {
-            displayMessage('crtr: no node in pane', pane);
-            throw new InputError({ error: 'no_node', message: 'no node found in this pane', next: 'Pass --pane <pane-id> for a pane showing an active node.' });
-        }
-        const pins = loadPins();
-        const pinned = !pins.has(nodeId);
-        if (pinned)
-            pins.add(nodeId);
-        else
-            pins.delete(nodeId);
-        savePins(pins);
-        displayMessage(pinned ? 'crtr: conversation pinned' : 'crtr: conversation unpinned', pane);
-        return { node_id: nodeId, pinned };
-    },
-    render: (r) => (r['pinned'] === true ? `Pinned ${r['node_id']} in the canvas navigator.` : `Unpinned ${r['node_id']}.`),
-});
+var s=Object.defineProperty;var i=(n,e)=>s(n,"name",{value:e,configurable:!0});import{defineLeaf as d}from"../../../core/command.js";import{InputError as p}from"../../../core/io.js";import{displayMessage as r}from"../../../core/runtime/tmux-chrome.js";import{loadPins as u,savePins as c}from"../../../core/canvas/browse/pins.js";import{nodeInPane as h}from"./placement.js";const y=d({name:"pin",description:"pin or unpin the node in a tmux pane in the canvas navigator",whenToUse:"you want the conversation in this pane starred at the top of your canvas navigator (the same pin `canvas browse` toggles), without opening the navigator to do it",help:{name:"surface node pin",summary:"toggle the canvas-navigator pin on the node resolved from a tmux pane \u2014 a local, per-user view preference that sorts the node to the top of your navigator and fills its Pinned tab, mutating nothing on the canvas",params:[{kind:"flag",name:"pane",type:"string",required:!1,constraint:"tmux pane id whose focused node to pin. Defaults to $TMUX_PANE / your current pane."}],output:[{name:"node_id",type:"string",required:!0,constraint:"The node whose pin was toggled."},{name:"pinned",type:"boolean",required:!0,constraint:"True when the node is now pinned, false when the pin was removed."}],outputKind:"object",effects:["Toggles the node in the per-user navigator pin set and shows a transient tmux confirmation."]},run:i(async n=>{const e=n.pane??process.env.TMUX_PANE,o=h(e);if(o===void 0)throw r("crtr: no node in pane",e),new p({error:"no_node",message:"no node found in this pane",next:"Pass --pane <pane-id> for a pane showing an active node."});const t=u(),a=!t.has(o);return a?t.add(o):t.delete(o),c(t),r(a?"crtr: conversation pinned":"crtr: conversation unpinned",e),{node_id:o,pinned:a}},"run"),render:i(n=>n.pinned===!0?`Pinned ${n.node_id} in the canvas navigator.`:`Unpinned ${n.node_id}.`,"render")});export{y as surfaceNodePinLeaf};

package/dist/commands/surface/node/placement.js

@@ -1,134 +1 @@
-// `crtr surface node` — pure tmux placement for node viewers.
-import { envHomeOverride } from '../../../shared/env.js';
-import { closePane, currentTmux, displayPopup, ensureSession, getPaneOption, listLivePanes, openNodeWindow, paneCurrentPath, paneExists, paneLocation, panePid, paneStartCommand, renameWindow, respawnPaneInPlace, respawnPaneSync, selectLayout, selectPane, selectWindow, setPaneOption, shellQuote, splitWindow, switchClient, viewerSplitEnv, windowOfPane, } from '../../../core/runtime/placement-tmux.js';
-import { cliClient, rethrowAsCliError } from '../../api-client.js';
-export { closePane, currentTmux, displayPopup, paneCurrentPath, paneExists, panePid, paneStartCommand, respawnPaneInPlace, respawnPaneSync, shellQuote, viewerSplitEnv };
-export function viewerEnv() {
-    const crtrHome = envHomeOverride();
-    return crtrHome !== undefined ? { CRTR_HOME: crtrHome } : {};
-}
-/** Internal startup policy for viewers opened by focus/navigation. Direct
- * `surface attach` has no marker and keeps its activating default. */
-function focusViewerEnv() {
-    return { ...viewerEnv(), CRTR_ATTACH_WAKE_PARKED: '0' };
-}
-/** The live viewer pane for `nodeId` (the pane a surface-attach viewer tagged
- *  `@crtr_node`), or undefined. Pure tag scan over live panes. */
-export function viewerPaneOf(nodeId) {
-    const panes = listLivePanes();
-    if (panes === null)
-        return undefined;
-    for (const pane of panes) {
-        if (getPaneOption(pane, '@crtr_node') === nodeId)
-            return pane;
-    }
-    return undefined;
-}
-/** Open a fresh surface-attach viewer SPLIT beside `callerPane` and rebalance
- *  its window to even side-by-side widths. Pure tmux. */
-function openBesideCaller(callerPane, nodeId, cwd, callerSession, revived) {
-    const opened = splitWindow(callerPane, { cwd, env: focusViewerEnv(), command: `crtr surface attach to ${nodeId}` });
-    if (opened === null)
-        return { focused: false, session: null, inPlace: false, revived };
-    const loc = paneLocation(opened);
-    if (loc !== null)
-        selectLayout(loc.window, 'even-horizontal');
-    selectPane(opened);
-    return { focused: true, session: loc?.session ?? callerSession, inPlace: false, revived };
-}
-/** Bring a node's ONE viewer forefront beside (or navigated to) the caller —
- *  the pure-tmux port of placement.ts `focus()`. The server (`ensureAttach`)
- *  owns the broker revive + the view.sock accept-wait; the `@crtr_node` pane tag
- *  is the viewer registry. crtr is tmux-only: no caller pane ⇒ not focused. */
-export async function focusViewer(nodeId, opts) {
-    const callerPane = opts.pane ?? process.env['TMUX_PANE'] ?? currentTmux()?.pane;
-    if (callerPane === undefined || callerPane === '') {
-        return { focused: false, session: null, inPlace: false, revived: false };
-    }
-    // (a) Server ensures a live broker is attachable, but leaves an exact parked
-    // resident untouched. This policy is unconditional so an active→parked race
-    // is decided at the daemon's synchronous fleet/launch boundary.
-    const attach = await cliClient()
-        .ensureAttach(nodeId, { resume: true, revive: true, wakeParked: false })
-        .catch(rethrowAsCliError);
-    const revived = attach.revived;
-    const callerSession = paneLocation(callerPane)?.session ?? null;
-    // (b0) --in-place → the caller pane BECOMES this node's viewer, replacing what
-    //      it showed. Must be driven from OUTSIDE that pane's process tree.
-    if (opts.inPlace === true) {
-        const priorNodeId = getPaneOption(callerPane, '@crtr_node');
-        const existing = viewerPaneOf(nodeId);
-        if (existing !== undefined && existing !== callerPane && paneExists(existing))
-            closePane(existing);
-        try {
-            setPaneOption(callerPane, '@crtr_node', '');
-        }
-        catch { /* best-effort */ }
-        const window = windowOfPane(callerPane);
-        const env = priorNodeId !== undefined && priorNodeId !== ''
-            ? { ...focusViewerEnv(), CRTR_ATTACH_ROSTER: priorNodeId }
-            : focusViewerEnv();
-        const ok = respawnPaneSync({ pane: callerPane, cwd: opts.cwd, env, command: `crtr surface attach to ${nodeId}` });
-        if (ok && window !== null)
-            renameWindow(window, opts.name);
-        return { focused: ok, session: callerSession, inPlace: true, revived };
-    }
-    // (b) --new-pane → always a fresh viewer beside the caller; drop any prior
-    //     viewer this node holds elsewhere (one viewer per node).
-    if (opts.newPane === true) {
-        const prior = viewerPaneOf(nodeId);
-        if (prior !== undefined && paneExists(prior))
-            closePane(prior);
-        return openBesideCaller(callerPane, nodeId, opts.cwd, callerSession, revived);
-    }
-    // (c) Reuse the node's existing tagged viewer wherever it already lives.
-    const existing = viewerPaneOf(nodeId);
-    if (existing !== undefined) {
-        const loc = paneLocation(existing);
-        if (loc !== null) {
-            switchClient(loc.session);
-            selectWindow(loc.session, loc.window);
-            selectPane(existing);
-            return { focused: true, session: loc.session, inPlace: true, revived };
-        }
-    }
-    // (d) No live viewer → open one beside the caller.
-    return openBesideCaller(callerPane, nodeId, opts.cwd, callerSession, revived);
-}
-/** Open a viewer for a freshly-spawned --root node in a FRESH WINDOW in the
- *  caller's current tmux session (the --root spawn-viewer path). Pure tmux; the
- *  broker is already launching server-side, so the attach pane self-polls the
- *  cold socket. Returns the opened window/session, empty when not in tmux. */
-export function openSpawnViewer(nodeId, cwd, name) {
-    const loc = currentTmux();
-    const session = loc?.session;
-    if (session === undefined || session === '')
-        return {};
-    ensureSession(session, cwd);
-    const opened = openNodeWindow({ session, name, cwd, env: viewerEnv(), command: `crtr surface attach to ${nodeId}` });
-    if (opened === null)
-        return {};
-    selectWindow(session, opened.window);
-    selectPane(opened.pane);
-    return { window: opened.window, session };
-}
-/** The node "in front of you" in a tmux pane, resolved PURELY from the pane's
- *  `@crtr_node` tag. Defaults to $TMUX_PANE / the caller's current pane when
- *  `pane` is omitted — shared by `node lifecycle recycle` / `node lifecycle
- *  demote` / `node config --lifecycle` / `node lifecycle close` / `surface node cycle`,
- *  and the `canvas chord` leaf.
- *
- *  A `crtr surface attach` viewer self-tags its pane with the node it views
- *  (`@crtr_node`) — the tag IS the handle (a broker engine runs DETACHED with
- *  window=null, so there is no window→node fallback). Kept SYNC + tag-only: the
- *  CLI does not read canvas state to confirm the tagged node is
- *  still live, so a stale tag (attach SIGKILLed without clearing) resolves until
- *  the pane is respawned. Callers that mutate then re-validate the id via the
- *  API (getNode 404 → clean error). */
-export function nodeInPane(pane) {
-    const resolvePane = pane ?? process.env['TMUX_PANE'] ?? currentTmux()?.pane;
-    if (resolvePane === undefined || resolvePane === '')
-        return undefined;
-    const tagged = getPaneOption(resolvePane, '@crtr_node');
-    return tagged !== undefined && tagged !== '' ? tagged : undefined;
-}
+var R=Object.defineProperty;var s=(r,e)=>R(r,"name",{value:e,configurable:!0});import{envHomeOverride as O}from"../../../shared/env.js";import{closePane as l,currentTmux as u,displayPopup as S,ensureSession as g,getPaneOption as d,listLivePanes as y,openNodeWindow as H,paneCurrentPath as W,paneExists as w,paneLocation as p,panePid as N,paneStartCommand as k,renameWindow as L,respawnPaneInPlace as M,respawnPaneSync as C,selectLayout as V,selectPane as P,selectWindow as E,setPaneOption as $,shellQuote as K,splitWindow as U,switchClient as X,viewerSplitEnv as z,windowOfPane as B}from"../../../core/runtime/placement-tmux.js";import{cliClient as D,rethrowAsCliError as Q}from"../../api-client.js";function T(){const r=O();return r!==void 0?{CRTR_HOME:r}:{}}s(T,"viewerEnv");function v(){return{...T(),CRTR_ATTACH_WAKE_PARKED:"0"}}s(v,"focusViewerEnv");function m(r){const e=y();if(e!==null){for(const n of e)if(d(n,"@crtr_node")===r)return n}}s(m,"viewerPaneOf");function x(r,e,n,f,t){const i=U(r,{cwd:n,env:v(),command:`crtr surface attach to ${e}`});if(i===null)return{focused:!1,session:null,inPlace:!1,revived:t};const c=p(i);return c!==null&&V(c.window,"even-horizontal"),P(i),{focused:!0,session:c?.session??f,inPlace:!1,revived:t}}s(x,"openBesideCaller");async function G(r,e){const n=e.pane??process.env.TMUX_PANE??u()?.pane;if(n===void 0||n==="")return{focused:!1,session:null,inPlace:!1,revived:!1};const t=(await D().ensureAttach(r,{resume:!0,revive:!0,wakeParked:!1}).catch(Q)).revived,i=p(n)?.session??null;if(e.inPlace===!0){const o=d(n,"@crtr_node"),a=m(r);a!==void 0&&a!==n&&w(a)&&l(a);try{$(n,"@crtr_node","")}catch{}const h=B(n),A=o!==void 0&&o!==""?{...v(),CRTR_ATTACH_ROSTER:o}:v(),_=C({pane:n,cwd:e.cwd,env:A,command:`crtr surface attach to ${r}`});return _&&h!==null&&L(h,e.name),{focused:_,session:i,inPlace:!0,revived:t}}if(e.newPane===!0){const o=m(r);return o!==void 0&&w(o)&&l(o),x(n,r,e.cwd,i,t)}const c=m(r);if(c!==void 0){const o=p(c);if(o!==null)return X(o.session),E(o.session,o.window),P(c),{focused:!0,session:o.session,inPlace:!0,revived:t}}return x(n,r,e.cwd,i,t)}s(G,"focusViewer");function J(r,e,n){const t=u()?.session;if(t===void 0||t==="")return{};g(t,e);const i=H({session:t,name:n,cwd:e,env:T(),command:`crtr surface attach to ${r}`});return i===null?{}:(E(t,i.window),P(i.pane),{window:i.window,session:t})}s(J,"openSpawnViewer");function Y(r){const e=r??process.env.TMUX_PANE??u()?.pane;if(e===void 0||e==="")return;const n=d(e,"@crtr_node");return n!==void 0&&n!==""?n:void 0}s(Y,"nodeInPane");export{l as closePane,u as currentTmux,S as displayPopup,G as focusViewer,Y as nodeInPane,J as openSpawnViewer,W as paneCurrentPath,w as paneExists,N as panePid,k as paneStartCommand,M as respawnPaneInPlace,C as respawnPaneSync,K as shellQuote,T as viewerEnv,m as viewerPaneOf,z as viewerSplitEnv};

package/dist/commands/surface-edit.js

@@ -1,157 +1 @@
-// `crtr surface edit <file>` — open a file in the user's $EDITOR in a new pane.
-//
-// A genuine viewer-placement decision, so it lives under `surface` alongside
-// view/attach/workspace/tmux-spread. It reuses the §5.1 import-lint front door
-// (splitWindow / currentTmux / paneLocation re-exported through placement),
-// never importing tmux.ts directly.
-//
-// AGENT-TRIGGERED is the primary path: a node's engine runs in a HEADLESS broker
-// with no $TMUX of its own, yet the tmux CLI reaches the running server over its
-// socket regardless (exactly how the headless daemon places every viewer pane).
-// So we do NOT gate on the caller's $TMUX. surface edit opens the editor NEXT TO
-// THE PANE THAT OPENED IT — the resolution, in order:
-//   1. explicit --pane
-//   2. $TMUX_PANE            (a human running this from their own pane)
-//   3. this node's VIEWER pane via paneOfNode($CRTR_NODE_ID) — the pane carrying
-//      this node's @crtr_node tag, set by ANY viewer (attach, focus, spawn). We
-//      scan the tag, NOT the focus table, which a bare `surface attach` never
-//      writes — so attach-viewed nodes resolve correctly.
-//   4. the attached client's active pane
-// If none resolve, the caller has no pane on screen (a BACKGROUND node with no
-// viewer): there is genuinely no "pane that opened it" to sit beside, so we do
-// NOT invent a location — a clean no_pane error. The agent surfaces the file the
-// normal way (a report/push with the path) and it opens beside the node the
-// moment it IS being watched. (Inventing a window per background caller would
-// spew disconnected editor windows into whatever session happened to be attached.)
-//
-// The editor is `$EDITOR` expanded by the new pane's own shell against the
-// inherited tmux server env (like every crtr chrome pane) — no broker-side env
-// read, no host assumption. tmux-native throughout: a web-only surface has no
-// pane to split and resolves to the no_pane error, never a caller of this.
-import { envNodeId } from '../shared/env.js';
-import { existsSync, statSync } from 'node:fs';
-import { isAbsolute, resolve } from 'node:path';
-import { defineLeaf } from '../core/command.js';
-import { InputError } from '../core/io.js';
-import { currentTmux, splitWindow, paneLocation, paneOfNode, } from '../core/runtime/placement-tmux.js';
-import { shellQuote } from '../shared/shell-quote.js';
-/** Resolve the pane the editor should open BESIDE — the pane that opened this
- *  command: explicit --pane, the caller's own $TMUX_PANE, the pane where THIS
- *  node is being watched (its `@crtr_node`-tagged pane, whatever viewer put it
- *  there — attach, focus, spawn), or the attached client's active pane. Null when
- *  no pane on the server shows the node (it's headless with no viewer) — there is
- *  no "pane that opened it" to sit beside. */
-function resolveTargetPane(explicit) {
-    const flag = explicit?.trim();
-    if (flag !== undefined && flag !== '')
-        return flag;
-    const envPane = process.env['TMUX_PANE'];
-    if (envPane !== undefined && envPane !== '')
-        return envPane;
-    // Agent path: split beside the pane where THIS node is being watched. Resolve
-    // it by the authoritative @crtr_node tag (set by any viewer) — NOT the focus
-    // table, which a bare `surface attach` never writes.
-    const nodeId = envNodeId();
-    if (nodeId !== undefined && nodeId !== '') {
-        const pane = paneOfNode(nodeId);
-        if (pane !== null)
-            return pane;
-    }
-    return currentTmux()?.pane ?? null;
-}
-/** The command the new pane runs. The pane INHERITS the tmux server environment
- *  (like every crtr chrome pane — the subagent viewer panes get theirs the same
- *  way), and a tmux server started from the human's interactive shell captured
- *  their $EDITOR there. So we reference $EDITOR by name and let the pane's own
- *  shell expand it against the inherited env — no broker-side env read, no host
- *  assumption. If $EDITOR/$VISUAL are genuinely unset the pane surfaces that
- *  itself; we don't guess a fallback. */
-const EDITOR_EXPR = '${EDITOR:-${VISUAL}}';
-export const surfaceEditLeaf = defineLeaf({
-    name: 'edit',
-    description: "open a file in the user's $EDITOR in a new pane beside the pane that opened this command",
-    whenToUse: "you (an agent) want the user to SEE a file WHILE THEY'RE WATCHING YOU — open it in their $EDITOR in a new pane split beside this node's viewer pane, without them hunting for it. Works headless (the broker reaches the tmux server over its socket). Requires this node to be on screen (a viewer open) or a caller pane; a background node with no viewer gets a no_pane error — report the path instead and it opens beside you once watched",
-    help: {
-        name: 'surface edit',
-        summary: "Open <file> in a new pane running the user's $EDITOR (else $VISUAL), split beside THE PANE THAT OPENED THIS: an explicit --pane, the caller's own $TMUX_PANE, or this node's viewer pane (the pane where the user is watching it). Works from a HEADLESS broker (the tmux server is reached over its socket, no $TMUX needed). A background node with no viewer on screen has no pane to sit beside -> no_pane error. The split is -d, so focus is unchanged",
-        params: [
-            {
-                kind: 'positional',
-                name: 'file',
-                required: true,
-                constraint: 'Path to open. Relative paths resolve against the current working directory.',
-            },
-            {
-                kind: 'flag',
-                name: 'pane',
-                type: 'string',
-                required: false,
-                constraint: "tmux pane id to split beside. Defaults to $TMUX_PANE, else the pane showing this node (its @crtr_node tag), else the attached client's active pane.",
-            },
-            {
-                kind: 'flag',
-                name: 'vertical',
-                type: 'bool',
-                required: false,
-                constraint: 'Split top/bottom instead of the default left/right.',
-            },
-        ],
-        output: [
-            { name: 'pane', type: 'string', required: true, constraint: 'The new pane id running the editor.' },
-            { name: 'session', type: 'string', required: false, constraint: 'The session the editor pane lives in.' },
-            { name: 'file', type: 'string', required: true, constraint: 'The resolved absolute path opened.' },
-        ],
-        outputKind: 'object',
-        effects: [
-            "Opens a NEW pane running the user's $EDITOR (else $VISUAL) on <file> beside the target pane (tmux split-window -d; focus unchanged). Reaches the tmux server over its socket, so it works from a headless broker.",
-            "The editor is $EDITOR expanded by the new pane's own shell against the inherited tmux server env — the same way subagent viewer panes get their env. tmux-native: a web-only surface has no pane to split, so it resolves to a no_pane error rather than being a caller of this.",
-            'Requires a pane that opened it to sit beside — this node’s on-screen viewer, an explicit --pane, or a caller pane. A background node with no viewer errors (no_pane); it does NOT invent a window in some attached session.',
-        ],
-    },
-    run: async (input) => {
-        const raw = input['file'].trim();
-        if (raw === '') {
-            throw new InputError({ error: 'no_file', message: 'no file given', field: 'file', next: 'Pass a path to open.' });
-        }
-        const file = isAbsolute(raw) ? raw : resolve(process.cwd(), raw);
-        if (existsSync(file) && statSync(file).isDirectory()) {
-            throw new InputError({
-                error: 'is_directory',
-                message: `${file} is a directory`,
-                field: 'file',
-                next: 'Pass a file path (surface edit opens a single file in $EDITOR).',
-            });
-        }
-        const target = resolveTargetPane(input['pane']);
-        if (target === null) {
-            throw new InputError({
-                error: 'no_pane',
-                message: 'no pane to open the editor beside — this node has no viewer on screen (it is running in the background).',
-                next: 'Open a viewer on this node (`crtr surface node focus <id>` / `crtr surface attach`) and retry, pass --pane <pane-id>, or run from inside a tmux pane. To just point the user at a file, report its path instead.',
-            });
-        }
-        const command = `${EDITOR_EXPR} ${shellQuote(file)}`;
-        const pane = splitWindow(target, {
-            cwd: process.cwd(),
-            env: {},
-            command,
-            vertical: input['vertical'] === true,
-        });
-        if (pane === null) {
-            throw new InputError({
-                error: 'split_failed',
-                message: `tmux split-window failed for ${target}`,
-                next: 'Ensure the pane still exists and the tmux window has room (try a wider window).',
-            });
-        }
-        return {
-            pane,
-            session: paneLocation(pane)?.session ?? undefined,
-            file,
-        };
-    },
-    render: (out) => {
-        const o = out;
-        return `opened ${o.file} in a new pane (${o.pane})`;
-    },
-});
+var d=Object.defineProperty;var s=(n,e)=>d(n,"name",{value:e,configurable:!0});import{envNodeId as p}from"../shared/env.js";import{existsSync as h,statSync as l}from"node:fs";import{isAbsolute as c,resolve as u}from"node:path";import{defineLeaf as f}from"../core/command.js";import{InputError as o}from"../core/io.js";import{currentTmux as w,splitWindow as m,paneLocation as g,paneOfNode as v}from"../core/runtime/placement-tmux.js";import{shellQuote as T}from"../shared/shell-quote.js";function E(n){const e=n?.trim();if(e!==void 0&&e!=="")return e;const t=process.env.TMUX_PANE;if(t!==void 0&&t!=="")return t;const r=p();if(r!==void 0&&r!==""){const i=v(r);if(i!==null)return i}return w()?.pane??null}s(E,"resolveTargetPane");const b="${EDITOR:-${VISUAL}}",_=f({name:"edit",description:"open a file in the user's $EDITOR in a new pane beside the pane that opened this command",whenToUse:"you (an agent) want the user to SEE a file WHILE THEY'RE WATCHING YOU \u2014 open it in their $EDITOR in a new pane split beside this node's viewer pane, without them hunting for it. Works headless (the broker reaches the tmux server over its socket). Requires this node to be on screen (a viewer open) or a caller pane; a background node with no viewer gets a no_pane error \u2014 report the path instead and it opens beside you once watched",help:{name:"surface edit",summary:"Open <file> in a new pane running the user's $EDITOR (else $VISUAL), split beside THE PANE THAT OPENED THIS: an explicit --pane, the caller's own $TMUX_PANE, or this node's viewer pane (the pane where the user is watching it). Works from a HEADLESS broker (the tmux server is reached over its socket, no $TMUX needed). A background node with no viewer on screen has no pane to sit beside -> no_pane error. The split is -d, so focus is unchanged",params:[{kind:"positional",name:"file",required:!0,constraint:"Path to open. Relative paths resolve against the current working directory."},{kind:"flag",name:"pane",type:"string",required:!1,constraint:"tmux pane id to split beside. Defaults to $TMUX_PANE, else the pane showing this node (its @crtr_node tag), else the attached client's active pane."},{kind:"flag",name:"vertical",type:"bool",required:!1,constraint:"Split top/bottom instead of the default left/right."}],output:[{name:"pane",type:"string",required:!0,constraint:"The new pane id running the editor."},{name:"session",type:"string",required:!1,constraint:"The session the editor pane lives in."},{name:"file",type:"string",required:!0,constraint:"The resolved absolute path opened."}],outputKind:"object",effects:["Opens a NEW pane running the user's $EDITOR (else $VISUAL) on <file> beside the target pane (tmux split-window -d; focus unchanged). Reaches the tmux server over its socket, so it works from a headless broker.","The editor is $EDITOR expanded by the new pane's own shell against the inherited tmux server env \u2014 the same way subagent viewer panes get their env. tmux-native: a web-only surface has no pane to split, so it resolves to a no_pane error rather than being a caller of this.","Requires a pane that opened it to sit beside \u2014 this node\u2019s on-screen viewer, an explicit --pane, or a caller pane. A background node with no viewer errors (no_pane); it does NOT invent a window in some attached session."]},run:s(async n=>{const e=n.file.trim();if(e==="")throw new o({error:"no_file",message:"no file given",field:"file",next:"Pass a path to open."});const t=c(e)?e:u(process.cwd(),e);if(h(t)&&l(t).isDirectory())throw new o({error:"is_directory",message:`${t} is a directory`,field:"file",next:"Pass a file path (surface edit opens a single file in $EDITOR)."});const r=E(n.pane);if(r===null)throw new o({error:"no_pane",message:"no pane to open the editor beside \u2014 this node has no viewer on screen (it is running in the background).",next:"Open a viewer on this node (`crtr surface node focus <id>` / `crtr surface attach`) and retry, pass --pane <pane-id>, or run from inside a tmux pane. To just point the user at a file, report its path instead."});const i=`${b} ${T(t)}`,a=m(r,{cwd:process.cwd(),env:{},command:i,vertical:n.vertical===!0});if(a===null)throw new o({error:"split_failed",message:`tmux split-window failed for ${r}`,next:"Ensure the pane still exists and the tmux window has room (try a wider window)."});return{pane:a,session:g(a)?.session??void 0,file:t}},"run"),render:s(n=>{const e=n;return`opened ${e.file} in a new pane (${e.pane})`},"render")});export{_ as surfaceEditLeaf};

package/dist/commands/surface-inbox.js

@@ -1,98 +1 @@
-// `crtr surface inbox` — the tmux keybinding's target for the human inbox.
-//
-// A screen-facing viewer control, not a ticket verb: it delivers the private
-// attach-control action to one live viewer and focuses it. The human reaches
-// their own inbox through the inbox-toggle key (or `/inbox` in the viewer,
-// which toggles in-process and never shells out here).
-import { defineLeaf } from '../core/command.js';
-import { currentTmux, displayClientMessage, liveViewerPanes, paneLocation, selectPane, selectWindow, sendAttachControl, switchClient, } from '../core/runtime/placement-tmux.js';
-const NO_VIEWER_MESSAGE = 'No crouter viewer is running — attach to a node first (crtr surface attach to <node>).';
-function tmuxSocketFromEnvironment() {
-    const socket = process.env['TMUX']?.split(',')[0]?.trim();
-    return socket === undefined || socket === '' ? undefined : socket;
-}
-function paneForInvocation(explicit) {
-    if (explicit !== undefined && explicit !== '')
-        return explicit;
-    const fromEnv = process.env['TMUX_PANE'];
-    if (fromEnv !== undefined && fromEnv !== '')
-        return fromEnv;
-    return currentTmux()?.pane;
-}
-function newestViewer(a, b) {
-    if (a.stampMs !== b.stampMs)
-        return b.stampMs - a.stampMs;
-    if (a.pane === b.pane)
-        return 0;
-    return a.pane < b.pane ? -1 : 1;
-}
-function selectViewer(viewers, targetPane, clientSession) {
-    const targeted = targetPane === undefined ? undefined : viewers.find((viewer) => viewer.pane === targetPane);
-    if (targeted !== undefined)
-        return targeted;
-    const inClientSession = clientSession === undefined ? [] : viewers.filter((viewer) => viewer.session === clientSession);
-    return [...(inClientSession.length > 0 ? inClientSession : viewers)].sort(newestViewer)[0];
-}
-function focusViewer(viewer, targetPane, clientSession) {
-    if (viewer.pane === targetPane)
-        return;
-    const location = paneLocation(viewer.pane);
-    if (location === null) {
-        selectPane(viewer.pane);
-        return;
-    }
-    if (clientSession !== location.session)
-        switchClient(location.session);
-    selectWindow(location.session, location.window);
-    selectPane(viewer.pane);
-}
-export const surfaceInboxLeaf = defineLeaf({
-    name: 'inbox',
-    description: 'human inbox toggle dispatcher (bound to the inbox-toggle key; not run by hand)',
-    whenToUse: 'never directly — the inbox-toggle keybinding routes the user’s own request through it. An agent that wants a decision uses crtr human send; how the user reaches their inbox is theirs.',
-    tier: 'hidden',
-    hookEligible: false,
-    help: {
-        name: 'surface inbox',
-        summary: 'deliver the human inbox toggle to a live viewer',
-        guide: 'Selection prefers the target pane, then the resolved client session by newest viewer stamp, then newest globally; ties use pane id. The viewer decides whether the delivered toggle opens or closes the surface.',
-        params: [
-            { kind: 'flag', name: 'tmux-socket', type: 'path', required: false, constraint: 'Tmux server socket. Omit to use the first field of $TMUX.' },
-            { kind: 'flag', name: 'tmux-client', type: 'string', required: false, constraint: 'Tmux client name for the status-line message and client-session context.' },
-            { kind: 'flag', name: 'target-pane', type: 'string', required: false, constraint: 'Viewer pane to prefer. Omit to use $TMUX_PANE or the current tmux pane as the selection target.' },
-            { kind: 'flag', name: 'quiet', type: 'bool', required: false, default: false, constraint: 'Suppress the structured command result. A no-viewer status-line message is still shown.' },
-        ],
-        output: [
-            { name: 'action', type: 'opened | skipped', required: true, constraint: 'opened means the private inbox toggle sequence was delivered to a live viewer; it does not assert that the surface is now open. skipped means delivery did not happen.' },
-            { name: 'message', type: 'string', required: false, constraint: 'Present when action is skipped. With no live viewer, the same message is also shown in the tmux status line.' },
-        ],
-        outputKind: 'object',
-        effects: ['Sends the private inbox attach-control sequence to one live viewer and focuses that viewer unless it is already the target pane. Never opens a popup, launches a viewer, or wakes a node. With --quiet, suppresses only the structured result.'],
-    },
-    run: async (input) => {
-        const quiet = input['quiet'];
-        const socket = input['tmuxSocket'] ?? tmuxSocketFromEnvironment();
-        const client = input['tmuxClient'];
-        const targetPane = paneForInvocation(input['targetPane']);
-        if (socket === undefined) {
-            const outcome = { action: 'skipped', message: 'the inbox needs tmux' };
-            return quiet ? undefined : outcome;
-        }
-        const viewers = liveViewerPanes(socket);
-        const targetViewer = targetPane === undefined ? undefined : viewers.find((viewer) => viewer.pane === targetPane);
-        const clientSession = targetViewer?.session ?? (targetPane === undefined ? undefined : paneLocation(targetPane)?.session) ?? currentTmux()?.session;
-        const viewer = selectViewer(viewers, targetPane, clientSession);
-        if (viewer === undefined) {
-            displayClientMessage(socket, client, NO_VIEWER_MESSAGE);
-            const outcome = { action: 'skipped', message: NO_VIEWER_MESSAGE };
-            return quiet ? undefined : outcome;
-        }
-        if (!sendAttachControl(socket, viewer.pane, 'crtr.attach.inbox.toggle')) {
-            const outcome = { action: 'skipped', message: 'could not deliver the inbox toggle to the selected viewer' };
-            return quiet ? undefined : outcome;
-        }
-        focusViewer(viewer, targetPane, clientSession);
-        const outcome = { action: 'opened' };
-        return quiet ? undefined : outcome;
-    },
-});
+var h=Object.defineProperty;var o=(e,t)=>h(e,"name",{value:t,configurable:!0});import{defineLeaf as m}from"../core/command.js";import{currentTmux as c,displayClientMessage as g,liveViewerPanes as w,paneLocation as l,selectPane as f,selectWindow as v,sendAttachControl as x,switchClient as k}from"../core/runtime/placement-tmux.js";const p="No crouter viewer is running \u2014 attach to a node first (crtr surface attach to <node>).";function b(){const e=process.env.TMUX?.split(",")[0]?.trim();return e===void 0||e===""?void 0:e}o(b,"tmuxSocketFromEnvironment");function y(e){if(e!==void 0&&e!=="")return e;const t=process.env.TMUX_PANE;return t!==void 0&&t!==""?t:c()?.pane}o(y,"paneForInvocation");function q(e,t){return e.stampMs!==t.stampMs?t.stampMs-e.stampMs:e.pane===t.pane?0:e.pane<t.pane?-1:1}o(q,"newestViewer");function M(e,t,s){const n=t===void 0?void 0:e.find(r=>r.pane===t);if(n!==void 0)return n;const i=s===void 0?[]:e.filter(r=>r.session===s);return[...i.length>0?i:e].sort(q)[0]}o(M,"selectViewer");function E(e,t,s){if(e.pane===t)return;const n=l(e.pane);if(n===null){f(e.pane);return}s!==n.session&&k(n.session),v(n.session,n.window),f(e.pane)}o(E,"focusViewer");const C=m({name:"inbox",description:"human inbox toggle dispatcher (bound to the inbox-toggle key; not run by hand)",whenToUse:"never directly \u2014 the inbox-toggle keybinding routes the user\u2019s own request through it. An agent that wants a decision uses crtr human send; how the user reaches their inbox is theirs.",tier:"hidden",hookEligible:!1,help:{name:"surface inbox",summary:"deliver the human inbox toggle to a live viewer",guide:"Selection prefers the target pane, then the resolved client session by newest viewer stamp, then newest globally; ties use pane id. The viewer decides whether the delivered toggle opens or closes the surface.",params:[{kind:"flag",name:"tmux-socket",type:"path",required:!1,constraint:"Tmux server socket. Omit to use the first field of $TMUX."},{kind:"flag",name:"tmux-client",type:"string",required:!1,constraint:"Tmux client name for the status-line message and client-session context."},{kind:"flag",name:"target-pane",type:"string",required:!1,constraint:"Viewer pane to prefer. Omit to use $TMUX_PANE or the current tmux pane as the selection target."},{kind:"flag",name:"quiet",type:"bool",required:!1,default:!1,constraint:"Suppress the structured command result. A no-viewer status-line message is still shown."}],output:[{name:"action",type:"opened | skipped",required:!0,constraint:"opened means the private inbox toggle sequence was delivered to a live viewer; it does not assert that the surface is now open. skipped means delivery did not happen."},{name:"message",type:"string",required:!1,constraint:"Present when action is skipped. With no live viewer, the same message is also shown in the tmux status line."}],outputKind:"object",effects:["Sends the private inbox attach-control sequence to one live viewer and focuses that viewer unless it is already the target pane. Never opens a popup, launches a viewer, or wakes a node. With --quiet, suppresses only the structured result."]},run:o(async e=>{const t=e.quiet,s=e.tmuxSocket??b(),n=e.tmuxClient,i=y(e.targetPane);if(s===void 0)return t?void 0:{action:"skipped",message:"the inbox needs tmux"};const r=w(s),d=(i===void 0?void 0:r.find(a=>a.pane===i))?.session??(i===void 0?void 0:l(i)?.session)??c()?.session,u=M(r,i,d);return u===void 0?(g(s,n,p),t?void 0:{action:"skipped",message:p}):x(s,u.pane,"crtr.attach.inbox.toggle")?(E(u,i,d),t?void 0:{action:"opened"}):t?void 0:{action:"skipped",message:"could not deliver the inbox toggle to the selected viewer"}},"run")});export{C as surfaceInboxLeaf};