@north-light/crouter 0.3.318 → 0.3.320

package/dist/commands/push.js

@@ -1,265 +1,9 @@
-// `crtr push` — the one verb up the graph.
-//
-//   crtr push update [body]   — report progress to subscribers
-//   crtr push final  [body]   — finish: write result, mark node done, close window
-//   crtr push result [json]   — answer a pending structured-output request
-//
-// "push" is THE verb a node uses to talk to its managers. `update` reports
-// progress; its --tier sets delivery urgency. The caller's node is resolved from
-// CRTR_NODE_ID (injected by the runtime into every node process). Absent ⇒
-// InputError — push is only meaningful inside a live node.
-//
-// STAGE B-5: this verb is a PURE crtrd API client. Every report goes through
-// `POST /nodes/{id}/reports` (`client.pushReport`); the report file write, the
-// per-subscriber inbox fan, and (final only) the lifecycle transition all happen
-// server-side inside feed `push()` (spec §7.4). This file reaches ZERO canvas
-// state-store code — no `core/feed`, no `core/canvas` accessors, no
-// `core/worktree`. The only node identity read is `CRTR_NODE_ID` (client-side).
-import { envNodeId } from '../shared/env.js';
-import { defineBranch, defineLeaf } from '../core/command.js';
-import { InputError, readStdinRaw } from '../core/io.js';
-import { ApiError } from '../api/index.js';
-import { cliClient, rethrowAsCliError } from './api-client.js';
-import { markStopSignal } from '../core/runtime/stop-signals.js';
-function requireCallerNode() {
-    const id = envNodeId();
-    if (id === undefined || id.trim() === '') {
-        throw new InputError({
-            error: 'no_node_context',
-            message: 'CRTR_NODE_ID is not set — push runs inside a canvas node.',
-            next: 'Run push from a node process spawned by the runtime.',
-        });
-    }
-    return id.trim();
-}
-const PUSH_BLURB = {
-    update: 'report progress to subscribers',
-    final: 'finish: write the canonical result, mark the node done, close its window',
-};
-const PUSH_WHEN_TO_USE = {
-    update: 'you have progress worth surfacing to your managers while work remains in flight. Use normal delivery unless it can wait for their next real wake (--tier deferred) or needs immediate attention (--tier urgent); use push final only when the work is actually done.',
-    final: 'the work this node was spawned to do is complete and you are ready to hand back the canonical result — this writes that result, marks the node done, and closes its window, so it is the LAST thing you do here, not a progress note. Use push update while work is still in flight, and do not reach for final on a node working directly with the user: it has no manager to report up to and would close mid-conversation (the guard blocks it unless you pass --force after the user confirms).',
-};
-/** `crtr push result` — submit the JSON answer to a pending structured-output
- *  request. A pure API client like its siblings: JSON is parsed client-side
- *  only to fail fast with a clean error; validation against the schema, the
- *  result write, the report push, and the schema clear all happen server-side
- *  in `POST /nodes/{id}/result`. */
-function makeResultLeaf() {
-    return defineLeaf({
-        name: 'result',
-        description: 'answer a pending structured-output request with the required JSON result, or decline it',
-        whenToUse: 'your system prompt names a pending structured-output request you must answer. The value is validated against the required schema server-side; a mismatch rejects with field errors and records nothing, so fix and rerun. When the schema cannot be honestly satisfied (blocked, unavailable, bad input), pass `--decline "<reason>" --code <token>` (plus `--retryable` when the same request could succeed later) instead of inventing a value; your requester names the code tokens it accepts. For a terminal request either path IS how the node finishes — never call `crtr push final` alongside it.',
-        help: {
-            name: 'push result',
-            summary: 'answer a pending structured-output request',
-            params: [
-                { kind: 'stdin', name: 'value', required: false, constraint: "The JSON result. Pipe it from a single-quoted heredoc (`<<'EOF'`) to preserve literal bytes. Required unless `--decline` is passed." },
-                { kind: 'flag', name: 'decline', type: 'string', required: false, constraint: 'Decline instead of answering: one plain sentence on why the schema cannot be honestly satisfied (blocked, unavailable, bad input). Requires `--code`. Records a failure outcome with reason `declined` carrying the reason, code, and retryable flag, and clears the request; for a terminal request this finishes the node.' },
-                { kind: 'flag', name: 'code', type: 'string', required: false, constraint: 'With `--decline`: one whitespace-free token (≤ 64 chars) naming the decline class. crouter carries it verbatim; the requester validates it against the tokens it documented for you.' },
-                { kind: 'flag', name: 'retryable', type: 'bool', required: false, default: false, constraint: 'With `--decline`: the same request could succeed if issued again later (a transient block). Omit when the decline is final for this input.' },
-            ],
-            output: [
-                { name: 'mode', type: 'string', required: true, constraint: 'Which request this answered: `terminal` finished the node; `oneoff` left it working.' },
-                { name: 'result_path', type: 'string', required: true, constraint: 'Absolute path of the recorded artifact: the result JSON, or the declined marker when `--decline` was passed.' },
-                { name: 'declined', type: 'object', required: false, constraint: 'Present only when the request was declined: { reason, code, retryable } as recorded.' },
-                { name: 'report_path', type: 'string', required: true, constraint: 'Absolute path of the report pushed alongside the result.' },
-                { name: 'notified', type: 'string[]', required: true, constraint: 'Subscriber node ids that received an inbox pointer.' },
-                { name: 'transitioned', type: 'object', required: false, constraint: 'Present only for a terminal request that flipped the node — { from, to } lifecycle-status transition applied server-side.' },
-            ],
-            outputKind: 'object',
-            effects: [
-                'Validates the value against the pending schema server-side; a mismatch records nothing and the request stays pending.',
-                'Writes the accepted result to nodes/<nodeId>/context/result.json (or the decline to context/declined.json) and clears the pending request.',
-                'A terminal decline records a `failure` outcome with reason `declined` whose `declined` field carries { reason, code, retryable }; the requester sees no value.',
-                'Pushes the mode-matched report: final for a terminal request (the node finishes — same effects as `push final`), update for a one-off request (the node keeps working).',
-            ],
-        },
-        run: async (input) => {
-            const nodeId = requireCallerNode();
-            const decline = typeof input['decline'] === 'string' ? input['decline'].trim() : '';
-            const code = typeof input['code'] === 'string' ? input['code'].trim() : '';
-            let request;
-            if (decline !== '') {
-                if (code === '') {
-                    throw new InputError({ error: 'missing_decline_code', message: 'a decline needs a code', field: 'code', next: 'Pass `--code <token>` — the whitespace-free token your requester documented for this decline class.' });
-                }
-                request = { decline, code, retryable: input['retryable'] === true };
-            }
-            else {
-                if (code !== '' || input['retryable'] === true) {
-                    throw new InputError({ error: 'decline_flags_without_decline', message: '--code and --retryable only apply with --decline', next: 'Pass `--decline "<reason>"` alongside them, or drop them and submit the JSON result.' });
-                }
-                let raw = typeof input['value'] === 'string' ? input['value'].trim() : '';
-                if (raw === '')
-                    raw = (await readStdinRaw()).trim();
-                if (raw === '') {
-                    throw new InputError({ error: 'missing_value', message: 'no result value', field: 'value', next: 'Pass the JSON result as an argument or on stdin, or `--decline "<reason>" --code <token>` when the schema cannot be honestly satisfied.' });
-                }
-                let value;
-                try {
-                    value = JSON.parse(raw);
-                }
-                catch (err) {
-                    throw new InputError({
-                        error: 'bad_result_json',
-                        message: `the result is not valid JSON: ${err.message}`,
-                        field: 'value',
-                        next: 'Pass one valid JSON value matching the requested schema.',
-                    });
-                }
-                request = { value };
-            }
-            try {
-                const result = await cliClient().submitResult(nodeId, request);
-                if (result.mode === 'terminal')
-                    markStopSignal(nodeId, 'pushedFinal');
-                return {
-                    mode: result.mode,
-                    result_path: result.result_path,
-                    report_path: result.report_path,
-                    notified: result.notified,
-                    ...(result.declined === undefined ? {} : { declined: result.declined }),
-                    ...(result.transitioned !== undefined ? { transitioned: result.transitioned } : {}),
-                    ...(result.worktree_auto_dropped === true
-                        ? { worktree_auto_dropped: true, worktree_auto_dropped_path: result.worktree_auto_dropped_path }
-                        : {}),
-                };
-            }
-            catch (err) {
-                rethrowAsCliError(err);
-            }
-        },
-        render: (r) => {
-            const declined = r['declined'];
-            const line = r['mode'] === 'terminal'
-                ? `${declined ? 'Decline recorded' : 'Result recorded'} — node finished; its engine shuts down on next stop. Nothing more to do here: STOP your turn immediately. Reply with just "Done." and nothing else.`
-                : `${declined ? 'One-off request declined' : 'One-off result recorded'} and pushed — the structured-output gate is cleared; continue working normally.`;
-            const declinedLine = declined === undefined ? '' : `\n- code: ${declined.code} (${declined.retryable ? 'retryable' : 'not retryable'})`;
-            return `${line}\n\n- ${declined ? 'declined' : 'result'}: ${r['result_path']}${declinedLine}\n- report: ${r['report_path']}`;
-        },
-    });
-}
-function makePushLeaf(kind) {
-    return defineLeaf({
-        name: kind,
-        description: PUSH_BLURB[kind],
-        whenToUse: PUSH_WHEN_TO_USE[kind],
-        help: {
-            name: `push ${kind}`,
-            summary: PUSH_BLURB[kind],
-            params: [
-                { kind: 'stdin', name: 'body', required: true, constraint: "Report body (markdown). Pipe it from a single-quoted heredoc (`<<'EOF'`) to preserve literal bytes." },
-                ...(kind === 'update'
-                    ? [{ kind: 'flag', name: 'tier', type: 'enum', choices: ['deferred', 'normal', 'urgent'], required: false, default: 'normal', constraint: 'Delivery urgency: deferred holds for the receiver’s next non-deferred wake; normal wakes normally; urgent steers a live receiver and wakes an idle receiver.' }]
-                    : [{ kind: 'flag', name: 'force', type: 'bool', required: false, default: false, constraint: 'Override the guard that blocks `push final` on a node the user is attending (a resident with no one to report up to). Only pass this after the user explicitly confirms they want this node finished.' }]),
-            ],
-            output: [
-                { name: 'report_path', type: 'string', required: true, constraint: 'Absolute path of the written report.' },
-                { name: 'notified', type: 'string[]', required: true, constraint: 'Subscriber node ids that received an inbox pointer.' },
-                ...(kind === 'final'
-                    ? [
-                        { name: 'transitioned', type: 'object', required: false, constraint: 'Present only for a final that flipped the node — { from, to } lifecycle-status transition applied server-side.' },
-                        { name: 'worktree_auto_dropped', type: 'boolean', required: false, constraint: 'Present only when the server closed this node’s managed-worktree record without requiring `node worktree close`; cleanup of an existing checkout remains pending (see worktree_auto_dropped_path).' },
-                        { name: 'worktree_auto_dropped_path', type: 'string', required: false, constraint: 'Present only alongside worktree_auto_dropped: the closed worktree path; an existing checkout remains until pending cleanup.' },
-                    ]
-                    : []),
-            ],
-            outputKind: 'object',
-            effects: [
-                'Writes nodes/<nodeId>/reports/<ts>-<kind>.md (server-side).',
-                'Appends one inbox pointer per subscriber.',
-                ...(kind === 'final'
-                    ? [
-                        'Marks the node done (status + intent) server-side; its engine shuts down on next stop.',
-                        'When this node owns a clean managed worktree already contained in its local base, the server closes its record with cleanup pending instead of blocking on `node worktree close`. A clean worktree whose exact tip exists on any branch on origin may also finalize while retaining its branch and checkout; uncommitted changes or a tip absent from origin still block with open_managed_worktree.',
-                    ]
-                    : []),
-            ],
-        },
-        run: async (input) => {
-            const nodeId = requireCallerNode();
-            let body = typeof input['body'] === 'string' ? input['body'].trim() : '';
-            if (body === '')
-                body = (await readStdinRaw()).trim();
-            if (body === '') {
-                throw new InputError({ error: 'missing_body', message: 'no report body', field: 'body', next: 'Pass the body as an argument or on stdin.' });
-            }
-            const client = cliClient();
-            // A RESIDENT node with no subscribers is human-driven and has no one to
-            // submit a canonical result to: `push final` fans to subscribers, and a
-            // resident root conversation has none. Finishing it would shut its engine
-            // down mid-conversation. Block that unless the user confirms (--force).
-            // Keyed on lifecycle, NOT subscriber-count alone: a TERMINAL node with no
-            // subscribers was deliberately terminalized to owe a final — it
-            // self-completes server-side. This preflight reads the node through the
-            // API (NodeDetailDTO), never canvas.db — no state-store reach.
-            if (kind === 'final' && input['force'] !== true) {
-                let detail = null;
-                try {
-                    detail = await client.getNode(nodeId);
-                }
-                catch (err) {
-                    // A 404 here means the push itself will surface the canonical
-                    // unknown-node error — fall through and let it. Any other API failure
-                    // is a real problem worth surfacing now.
-                    if (!(err instanceof ApiError && err.status === 404)) {
-                        rethrowAsCliError(err);
-                    }
-                }
-                if (detail !== null && detail.lifecycle === 'resident' && detail.edges.subscribers.length === 0) {
-                    throw new InputError({
-                        error: 'no_final_recipient',
-                        message: 'This node is working directly with the user — it has no manager to submit a final result to. `push final` would end the conversation mid-stream.',
-                        next: 'You almost certainly do NOT need to finish here — just keep working with the user. If the user has explicitly asked you to finish and close this node, confirm with them first, then rerun with `crtr push final --force "<result>"`.',
-                    });
-                }
-            }
-            try {
-                const deliveryTier = input['tier'];
-                const result = await client.pushReport(nodeId, {
-                    tier: kind,
-                    body,
-                    ...(deliveryTier === undefined ? {} : { delivery_tier: deliveryTier }),
-                });
-                if (kind === 'final')
-                    markStopSignal(nodeId, 'pushedFinal');
-                return {
-                    report_path: result.report_path,
-                    notified: result.notified,
-                    ...(result.transitioned !== undefined ? { transitioned: result.transitioned } : {}),
-                    ...(result.worktree_auto_dropped === true
-                        ? { worktree_auto_dropped: true, worktree_auto_dropped_path: result.worktree_auto_dropped_path }
-                        : {}),
-                };
-            }
-            catch (err) {
-                rethrowAsCliError(err);
-            }
-        },
-        render: (r) => {
-            const n = Array.isArray(r['notified']) ? r['notified'].length : 0;
-            const line = kind === 'final'
-                ? 'Result recorded — node finished; its engine shuts down on next stop. Nothing more to do here: STOP your turn immediately. Reply with just "Done." and nothing else.'
-                : `Progress report fanned to ${n} subscriber(s).`;
-            const dropNote = r['worktree_auto_dropped'] === true ? `\n\nClosed a clean managed-worktree record at ${String(r['worktree_auto_dropped_path'])} — nothing to land; cleanup remains pending if the checkout still exists.` : '';
-            return `${line}\n\n- report: ${r['report_path']}${dropNote}`;
-        },
-    });
-}
-export function registerPush() {
-    return defineBranch({
-        name: 'push',
-        rootEntry: {
-            concept: 'the one verb up the graph — a node reports to whoever subscribes to it',
-            desc: 'push an update or final report to your subscribers',
-            useWhen: 'sharing progress, raising an alert, or finishing your work',
-        },
-        help: {
-            name: 'push',
-            summary: 'push a report to your subscribers',
-            model: "A push writes a markdown report to the node's reports/ history and fans a lightweight pointer to every subscriber's inbox. Delivery inlines reports under 1,000 characters; each report ref is read with `crtr canvas history read <ref>`. Nothing is pushed automatically — the feed contains only what a node pushes explicitly, so push whenever you want a manager to see something. Pipe markdown via a single-quoted heredoc so it reaches the report literally. `push final` is how ANY node finishes: write the canonical result, mark done, close the window.",
-        },
-        children: [makePushLeaf('update'), makePushLeaf('final'), makeResultLeaf()],
-    });
-}
+var y=Object.defineProperty;var i=(e,r)=>y(e,"name",{value:r,configurable:!0});import{envNodeId as b}from"../shared/env.js";import{defineBranch as _,defineLeaf as u}from"../core/command.js";import{InputError as d,readStdinRaw as c}from"../core/io.js";import{ApiError as k}from"../api/index.js";import{cliClient as h,rethrowAsCliError as l}from"./api-client.js";import{markStopSignal as p}from"../core/runtime/stop-signals.js";function f(){const e=b();if(e===void 0||e.trim()==="")throw new d({error:"no_node_context",message:"CRTR_NODE_ID is not set \u2014 push runs inside a canvas node.",next:"Run push from a node process spawned by the runtime."});return e.trim()}i(f,"requireCallerNode");const m={update:"report progress to subscribers",final:"finish: write the canonical result, mark the node done, close its window"},v={update:"you have progress worth surfacing to your managers while work remains in flight. Use normal delivery unless it can wait for their next real wake (--tier deferred) or needs immediate attention (--tier urgent); use push final only when the work is actually done.",final:"the work this node was spawned to do is complete and you are ready to hand back the canonical result \u2014 this writes that result, marks the node done, and closes its window, so it is the LAST thing you do here, not a progress note. Use push update while work is still in flight, and do not reach for final on a node working directly with the user: it has no manager to report up to and would close mid-conversation (the guard blocks it unless you pass --force after the user confirms)."};function q(){return u({name:"result",description:"answer a pending structured-output request with the required JSON result, or decline it",whenToUse:'your system prompt names a pending structured-output request you must answer. The value is validated against the required schema server-side; a mismatch rejects with field errors and records nothing, so fix and rerun. When the schema cannot be honestly satisfied (blocked, unavailable, bad input), pass `--decline "<reason>" --code <token>` (plus `--retryable` when the same request could succeed later) instead of inventing a value; your requester names the code tokens it accepts. For a terminal request either path IS how the node finishes \u2014 never call `crtr push final` alongside it.',help:{name:"push result",summary:"answer a pending structured-output request",params:[{kind:"stdin",name:"value",required:!1,constraint:"The JSON result. Pipe it from a single-quoted heredoc (`<<'EOF'`) to preserve literal bytes. Required unless `--decline` is passed."},{kind:"flag",name:"decline",type:"string",required:!1,constraint:"Decline instead of answering: one plain sentence on why the schema cannot be honestly satisfied (blocked, unavailable, bad input). Requires `--code`. Records a failure outcome with reason `declined` carrying the reason, code, and retryable flag, and clears the request; for a terminal request this finishes the node."},{kind:"flag",name:"code",type:"string",required:!1,constraint:"With `--decline`: one whitespace-free token (\u2264 64 chars) naming the decline class. crouter carries it verbatim; the requester validates it against the tokens it documented for you."},{kind:"flag",name:"retryable",type:"bool",required:!1,default:!1,constraint:"With `--decline`: the same request could succeed if issued again later (a transient block). Omit when the decline is final for this input."}],output:[{name:"mode",type:"string",required:!0,constraint:"Which request this answered: `terminal` finished the node; `oneoff` left it working."},{name:"result_path",type:"string",required:!0,constraint:"Absolute path of the recorded artifact: the result JSON, or the declined marker when `--decline` was passed."},{name:"declined",type:"object",required:!1,constraint:"Present only when the request was declined: { reason, code, retryable } as recorded."},{name:"report_path",type:"string",required:!0,constraint:"Absolute path of the report pushed alongside the result."},{name:"notified",type:"string[]",required:!0,constraint:"Subscriber node ids that received an inbox pointer."},{name:"transitioned",type:"object",required:!1,constraint:"Present only for a terminal request that flipped the node \u2014 { from, to } lifecycle-status transition applied server-side."}],outputKind:"object",effects:["Validates the value against the pending schema server-side; a mismatch records nothing and the request stays pending.","Writes the accepted result to nodes/<nodeId>/context/result.json (or the decline to context/declined.json) and clears the pending request.","A terminal decline records a `failure` outcome with reason `declined` whose `declined` field carries { reason, code, retryable }; the requester sees no value.","Pushes the mode-matched report: final for a terminal request (the node finishes \u2014 same effects as `push final`), update for a one-off request (the node keeps working)."]},run:i(async e=>{const r=f(),s=typeof e.decline=="string"?e.decline.trim():"",o=typeof e.code=="string"?e.code.trim():"";let a;if(s!==""){if(o==="")throw new d({error:"missing_decline_code",message:"a decline needs a code",field:"code",next:"Pass `--code <token>` \u2014 the whitespace-free token your requester documented for this decline class."});a={decline:s,code:o,retryable:e.retryable===!0}}else{if(o!==""||e.retryable===!0)throw new d({error:"decline_flags_without_decline",message:"--code and --retryable only apply with --decline",next:'Pass `--decline "<reason>"` alongside them, or drop them and submit the JSON result.'});let t=typeof e.value=="string"?e.value.trim():"";if(t===""&&(t=(await c()).trim()),t==="")throw new d({error:"missing_value",message:"no result value",field:"value",next:'Pass the JSON result as an argument or on stdin, or `--decline "<reason>" --code <token>` when the schema cannot be honestly satisfied.'});let n;try{n=JSON.parse(t)}catch(g){throw new d({error:"bad_result_json",message:`the result is not valid JSON: ${g.message}`,field:"value",next:"Pass one valid JSON value matching the requested schema."})}a={value:n}}try{const t=await h().submitResult(r,a);return t.mode==="terminal"&&p(r,"pushedFinal"),{mode:t.mode,result_path:t.result_path,report_path:t.report_path,notified:t.notified,...t.declined===void 0?{}:{declined:t.declined},...t.transitioned!==void 0?{transitioned:t.transitioned}:{},...t.worktree_auto_dropped===!0?{worktree_auto_dropped:!0,worktree_auto_dropped_path:t.worktree_auto_dropped_path}:{}}}catch(t){l(t)}},"run"),render:i(e=>{const r=e.declined,s=e.mode==="terminal"?`${r?"Decline recorded":"Result recorded"} \u2014 node finished; its engine shuts down on next stop. Nothing more to do here: STOP your turn immediately. Reply with just "Done." and nothing else.`:`${r?"One-off request declined":"One-off result recorded"} and pushed \u2014 the structured-output gate is cleared; continue working normally.`,o=r===void 0?"":`
+- code: ${r.code} (${r.retryable?"retryable":"not retryable"})`;return`${s}
+
+- ${r?"declined":"result"}: ${e.result_path}${o}
+- report: ${e.report_path}`},"render")})}i(q,"makeResultLeaf");function w(e){return u({name:e,description:m[e],whenToUse:v[e],help:{name:`push ${e}`,summary:m[e],params:[{kind:"stdin",name:"body",required:!0,constraint:"Report body (markdown). Pipe it from a single-quoted heredoc (`<<'EOF'`) to preserve literal bytes."},...e==="update"?[{kind:"flag",name:"tier",type:"enum",choices:["deferred","normal","urgent"],required:!1,default:"normal",constraint:"Delivery urgency: deferred holds for the receiver\u2019s next non-deferred wake; normal wakes normally; urgent steers a live receiver and wakes an idle receiver."}]:[{kind:"flag",name:"force",type:"bool",required:!1,default:!1,constraint:"Override the guard that blocks `push final` on a node the user is attending (a resident with no one to report up to). Only pass this after the user explicitly confirms they want this node finished."}]],output:[{name:"report_path",type:"string",required:!0,constraint:"Absolute path of the written report."},{name:"notified",type:"string[]",required:!0,constraint:"Subscriber node ids that received an inbox pointer."},...e==="final"?[{name:"transitioned",type:"object",required:!1,constraint:"Present only for a final that flipped the node \u2014 { from, to } lifecycle-status transition applied server-side."},{name:"worktree_auto_dropped",type:"boolean",required:!1,constraint:"Present only when the server closed this node\u2019s managed-worktree record without requiring `node worktree close`; cleanup of an existing checkout remains pending (see worktree_auto_dropped_path)."},{name:"worktree_auto_dropped_path",type:"string",required:!1,constraint:"Present only alongside worktree_auto_dropped: the closed worktree path; an existing checkout remains until pending cleanup."}]:[]],outputKind:"object",effects:["Writes nodes/<nodeId>/reports/<ts>-<kind>.md (server-side).","Appends one inbox pointer per subscriber.",...e==="final"?["Marks the node done (status + intent) server-side; its engine shuts down on next stop.","When this node owns a clean managed worktree already contained in its local base, the server closes its record with cleanup pending instead of blocking on `node worktree close`. A clean worktree whose exact tip exists on any branch on origin may also finalize while retaining its branch and checkout; uncommitted changes or a tip absent from origin still block with open_managed_worktree."]:[]]},run:i(async r=>{const s=f();let o=typeof r.body=="string"?r.body.trim():"";if(o===""&&(o=(await c()).trim()),o==="")throw new d({error:"missing_body",message:"no report body",field:"body",next:"Pass the body as an argument or on stdin."});const a=h();if(e==="final"&&r.force!==!0){let t=null;try{t=await a.getNode(s)}catch(n){n instanceof k&&n.status===404||l(n)}if(t!==null&&t.lifecycle==="resident"&&t.edges.subscribers.length===0)throw new d({error:"no_final_recipient",message:"This node is working directly with the user \u2014 it has no manager to submit a final result to. `push final` would end the conversation mid-stream.",next:'You almost certainly do NOT need to finish here \u2014 just keep working with the user. If the user has explicitly asked you to finish and close this node, confirm with them first, then rerun with `crtr push final --force "<result>"`.'})}try{const t=r.tier,n=await a.pushReport(s,{tier:e,body:o,...t===void 0?{}:{delivery_tier:t}});return e==="final"&&p(s,"pushedFinal"),{report_path:n.report_path,notified:n.notified,...n.transitioned!==void 0?{transitioned:n.transitioned}:{},...n.worktree_auto_dropped===!0?{worktree_auto_dropped:!0,worktree_auto_dropped_path:n.worktree_auto_dropped_path}:{}}}catch(t){l(t)}},"run"),render:i(r=>{const s=Array.isArray(r.notified)?r.notified.length:0,o=e==="final"?'Result recorded \u2014 node finished; its engine shuts down on next stop. Nothing more to do here: STOP your turn immediately. Reply with just "Done." and nothing else.':`Progress report fanned to ${s} subscriber(s).`,a=r.worktree_auto_dropped===!0?`
+
+Closed a clean managed-worktree record at ${String(r.worktree_auto_dropped_path)} \u2014 nothing to land; cleanup remains pending if the checkout still exists.`:"";return`${o}
+
+- report: ${r.report_path}${a}`},"render")})}i(w,"makePushLeaf");function A(){return _({name:"push",rootEntry:{concept:"the one verb up the graph \u2014 a node reports to whoever subscribes to it",desc:"push an update or final report to your subscribers",useWhen:"sharing progress, raising an alert, or finishing your work"},help:{name:"push",summary:"push a report to your subscribers",model:"A push writes a markdown report to the node's reports/ history and fans a lightweight pointer to every subscriber's inbox. Delivery inlines reports under 1,000 characters; each report ref is read with `crtr canvas history read <ref>`. Nothing is pushed automatically \u2014 the feed contains only what a node pushes explicitly, so push whenever you want a manager to see something. Pipe markdown via a single-quoted heredoc so it reaches the report literally. `push final` is how ANY node finishes: write the canonical result, mark done, close the window."},children:[w("update"),w("final"),q()]})}i(A,"registerPush");export{A as registerPush};

package/dist/commands/revive.js

@@ -1,181 +1,10 @@
-// `crtr canvas revive` — mass node recovery.
-//
-// Sweeps EVERY disconnected node (engine not running, resumable session) in
-// one shot — the recovery for a reboot / mass-crash / daemon-down-a-while
-// event. It is a two-step gate: run it once to PREVIEW the candidates
-// (nothing is launched), then confirm to actually revive them.
-//
-// Reviving ONE named node is a per-node lifecycle action and lives instead at
-// `crtr node lifecycle revive <id>` (src/commands/node-lifecycle-revive.ts).
-import { defineLeaf } from '../core/command.js';
-import { InputError } from '../core/io.js';
-import { cliClient } from './api-client.js';
-import { routes } from '../api/index.js';
-// Purity (spec §1/§10, plan B-2): a `crtr` CLI process never opens canvas.db, so
-// this leaf's transitive RUNTIME import graph must not reach `core/canvas/db.ts`
-// or `core/canvas/canvas.ts`. The pre-API imports — `listDisconnected`/`reviveAll`
-// (revive-all.js) and `getNode`/`fullName` (the canvas barrel index.js) — all
-// reached `openDb`, so they are replaced by: the daemon client (`cliClient`),
-// `fullName` from labels.js DIRECTLY (labels.ts has zero runtime imports), and
-// `recordedPidLiveness` (pid.js → fs/ps only). The disconnected PREVIEW predicate
-// is re-implemented client-side over the API's node projections; the authoritative
-// sweep is the daemon's own `POST /nodes/revive-all` (which runs `reviveAll()`
-// server-side).
-import { fullName } from '../core/canvas/labels.js';
-import { recordedPidLiveness } from '../core/canvas/pid.js';
-// revive --all
-export const reviveLeaf = defineLeaf({
-    name: 'revive',
-    description: 'mass-reconnect every disconnected node',
-    whenToUse: 'you need to bring back EVERY disconnected node at once (engine not running but a saved session intact) — the recovery after a reboot, a killed login/tmux session, a mass crash, or the daemon being down a while. You rarely need this for an ordinary crash — the daemon auto-revives those. To bring back ONE named node (a follow-up on a finished worker, a canceled node, or an on-demand kick of a hanging one), use `node lifecycle revive <id>` instead',
-    help: {
-        name: 'canvas revive',
-        summary: 'mass-reconnect every disconnected node (engine not running, resumable saved session)',
-        params: [
-            {
-                kind: 'flag',
-                name: 'all',
-                type: 'bool',
-                required: false,
-                default: false,
-                constraint: 'Required (rejected without it) — confirms this is the graph-wide sweep, not a typo for a single-node revive (that lives at `node lifecycle revive <id>`). Excludes done/canceled (terminal-by-choice). Run it once to PREVIEW the candidates; nothing is launched until you confirm.',
-            },
-            // --force is a DELIBERATELY UNDOCUMENTED confirmation gate (hidden from
-            // -h; see FlagParam.hidden). Silas's intent (2026-06-13): a mass revive
-            // can have large, unforeseen consequences, so the agent must NOT be able
-            // to discover a one-shot bypass by reading the schema. The unforced --all
-            // path PREVIEWS the candidates and instructs the agent to double-check
-            // with the USER before re-running; only then, having been told the flag,
-            // does it pass --force. Documenting it here would defeat that gate.
-            {
-                kind: 'flag',
-                name: 'force',
-                type: 'bool',
-                required: false,
-                default: false,
-                hidden: true,
-                constraint: 'Confirm the sweep (internal gate; see code comment).',
-            },
-        ],
-        output: [
-            { name: 'mode', type: 'string', required: true, constraint: '"preview" (the candidate list, nothing launched) or "revived" (the sweep ran).' },
-            { name: 'candidates', type: 'string', required: false, constraint: 'Preview: the node ids that WOULD be revived (newline-joined). Empty when none are disconnected.' },
-            { name: 'revived', type: 'string', required: false, constraint: 'Sweep: the node ids whose broker engine was relaunched (newline-joined).' },
-            { name: 'failed', type: 'string', required: false, constraint: 'Sweep: node ids whose relaunch threw, with the error (newline-joined). Absent when none failed.' },
-            { name: 'frozen', type: 'string', required: false, constraint: 'Sweep: node ids the live-broker cap turned away (newline-joined). Not failures — the daemon launches each as a slot frees. Absent when none were frozen.' },
-        ],
-        outputKind: 'object',
-        effects: [
-            'Launches the detached headless broker engine (no tmux window) for every disconnected node.',
-            'Updates each revived node\'s canvas record: status=active, intent=null.',
-            'Without --force: launches NOTHING — only previews the disconnected candidates.',
-        ],
-    },
-    run: async (input) => {
-        if (input['all'] !== true) {
-            throw new InputError({
-                error: 'missing_parameter',
-                message: '`canvas revive` is the mass-recovery sweep and requires --all.',
-                next: 'Run `crtr canvas revive --all` to reconnect every disconnected node, or `crtr node lifecycle revive <id>` to bring back one named node.',
-            });
-        }
-        return runReviveAll(input);
-    },
-});
-/** Statuses a node lands in DELIBERATELY (`done`/`canceled`) — the daemon never
- *  auto-revives these and neither does mass-revive. Mirrors
- *  `runtime/revive-all.ts`'s `TERMINAL_BY_CHOICE`, inlined so this leaf never
- *  imports that (db-reaching) module (plan B-2 purity). */
-const TERMINAL_BY_CHOICE = ['done', 'canceled'];
-/** Client-side re-implementation of `runtime/revive-all.ts`'s `isDisconnected`
- *  PREVIEW predicate, over the API's `NodeSummaryDTO` (spec §6 parity is
- *  structural, not byte-identical). Two differences from the server predicate,
- *  both display-only — the --force sweep re-computes authoritatively server-side:
- *   - liveness identity degrades to null (the summary omits `pi_pid_identity`),
- *     so `recordedPidLiveness(pi_pid, null)` uses the trust-isPidAlive path.
- *   - the resumable-session check is deferred to `sessionResumable` below (the
- *     summary carries no session marker; detail carries `pi_session_id`). */
-function passesCheapDisconnectedFilter(s) {
-    if (s.kind === 'human')
-        return false; // the `crtr human` bridge is never a pi engine
-    if (recordedPidLiveness(s.pi_pid, null) === 'alive')
-        return false; // engine running → connected
-    // hasNoNaturalCycle: finished its own work, or terminal-by-choice — never mass-revive.
-    if (s.final_report != null || TERMINAL_BY_CHOICE.includes(s.status))
-        return false;
-    return true;
-}
-/** One line per candidate: `<id>  <full name>  [<status>]`. `fullName` needs the
- *  node's description (its first-task label), which lives only on the detail
- *  projection — so this renders from `NodeDetailDTO`s. */
-function describe(details) {
-    return details
-        .map((d) => `  ${d.node_id}  ${fullName(d)}  [${d.status}]`)
-        .join('\n');
-}
-/** The --all sweep, gated on confirmation. Without `--force` it PREVIEWS the
- *  disconnected candidates and returns WITHOUT launching anything, telling the
- *  agent to double-check with the user first (a mass revive can have large,
- *  unforeseen consequences). With `--force` it delegates the authoritative sweep
- *  to the daemon (`POST /nodes/revive-all` → `reviveAll()` server-side). */
-async function runReviveAll(input) {
-    const force = input['force'] ?? false;
-    const client = cliClient();
-    // Preview: replicate the disconnected set client-side. The cheap filter runs
-    // over the list projection; then each survivor's detail is fetched to confirm a
-    // resumable saved session (`pi_session_id`, the DTO's session proxy — the
-    // summary carries no session marker; `pi_session_file` is not projected, so a
-    // rare file-only node under-lists here, but the --force sweep still revives it).
-    const summaries = await client.listNodes();
-    const shortlist = summaries.filter(passesCheapDisconnectedFilter);
-    const details = [];
-    for (const s of shortlist) {
-        const detail = await client.getNode(s.node_id);
-        if (detail.pi_session_id != null)
-            details.push(detail);
-    }
-    if (details.length === 0) {
-        return {
-            mode: 'preview',
-            candidates: '',
-            message: 'No disconnected nodes — every node with a resumable session already has a running engine. Nothing to revive.',
-        };
-    }
-    if (!force) {
-        const list = describe(details);
-        return {
-            mode: 'preview',
-            candidates: details.map((d) => d.node_id).join('\n'),
-            // Directive for the AGENT (not a documented flag): this is a preview, and a
-            // mass revive can have large, unforeseen consequences — so confirm with the
-            // USER before proceeding, then re-run to actually revive.
-            message: `${details.length} disconnected node(s) WOULD be revived (RESUME). Nothing has been launched yet:\n\n` +
-                `${list}\n\n` +
-                `Reviving all of these at once can have large, unforeseen consequences (a flood of resumed engines, ` +
-                `cost, side effects from each node continuing its work). This is a preview only — DOUBLE-CHECK WITH THE ` +
-                `USER that they want every node above brought back before you proceed. Once they confirm, re-run the ` +
-                `revive with confirmation to actually relaunch them.`,
-        };
-    }
-    const res = await client.request('POST', routes.reviveAll());
-    const out = {
-        mode: 'revived',
-        revived: res.revived.join('\n'),
-        message: `Revived ${res.revived.length} disconnected node(s) (RESUME).`,
-    };
-    if (res.failed.length > 0) {
-        out['failed'] = res.failed.map((f) => `${f.node_id}: ${f.error}`).join('\n');
-    }
-    if (res.frozen.length > 0) {
-        out['frozen'] = res.frozen.join('\n');
-    }
-    const total = res.revived.length + res.failed.length + res.frozen.length;
-    if (total > res.revived.length) {
-        out['message'] =
-            `Revived ${res.revived.length} of ${total} disconnected node(s) (RESUME)` +
-                (res.failed.length > 0 ? `; ${res.failed.length} failed to relaunch (see failed)` : '') +
-                (res.frozen.length > 0 ? `; ${res.frozen.length} frozen at the broker cap and launched as slots free (see frozen)` : '') +
-                '.';
-    }
-    return out;
-}
+var f=Object.defineProperty;var r=(n,i)=>f(n,"name",{value:i,configurable:!0});import{defineLeaf as h}from"../core/command.js";import{InputError as u}from"../core/io.js";import{cliClient as v}from"./api-client.js";import{routes as m}from"../api/index.js";import{fullName as g}from"../core/canvas/labels.js";import{recordedPidLiveness as p}from"../core/canvas/pid.js";const U=h({name:"revive",description:"mass-reconnect every disconnected node",whenToUse:"you need to bring back EVERY disconnected node at once (engine not running but a saved session intact) \u2014 the recovery after a reboot, a killed login/tmux session, a mass crash, or the daemon being down a while. You rarely need this for an ordinary crash \u2014 the daemon auto-revives those. To bring back ONE named node (a follow-up on a finished worker, a canceled node, or an on-demand kick of a hanging one), use `node lifecycle revive <id>` instead",help:{name:"canvas revive",summary:"mass-reconnect every disconnected node (engine not running, resumable saved session)",params:[{kind:"flag",name:"all",type:"bool",required:!1,default:!1,constraint:"Required (rejected without it) \u2014 confirms this is the graph-wide sweep, not a typo for a single-node revive (that lives at `node lifecycle revive <id>`). Excludes done/canceled (terminal-by-choice). Run it once to PREVIEW the candidates; nothing is launched until you confirm."},{kind:"flag",name:"force",type:"bool",required:!1,default:!1,hidden:!0,constraint:"Confirm the sweep (internal gate; see code comment)."}],output:[{name:"mode",type:"string",required:!0,constraint:'"preview" (the candidate list, nothing launched) or "revived" (the sweep ran).'},{name:"candidates",type:"string",required:!1,constraint:"Preview: the node ids that WOULD be revived (newline-joined). Empty when none are disconnected."},{name:"revived",type:"string",required:!1,constraint:"Sweep: the node ids whose broker engine was relaunched (newline-joined)."},{name:"failed",type:"string",required:!1,constraint:"Sweep: node ids whose relaunch threw, with the error (newline-joined). Absent when none failed."},{name:"frozen",type:"string",required:!1,constraint:"Sweep: node ids the live-broker cap turned away (newline-joined). Not failures \u2014 the daemon launches each as a slot frees. Absent when none were frozen."}],outputKind:"object",effects:["Launches the detached headless broker engine (no tmux window) for every disconnected node.","Updates each revived node's canvas record: status=active, intent=null.","Without --force: launches NOTHING \u2014 only previews the disconnected candidates."]},run:r(async n=>{if(n.all!==!0)throw new u({error:"missing_parameter",message:"`canvas revive` is the mass-recovery sweep and requires --all.",next:"Run `crtr canvas revive --all` to reconnect every disconnected node, or `crtr node lifecycle revive <id>` to bring back one named node."});return E(n)},"run")}),w=["done","canceled"];function y(n){return!(n.kind==="human"||p(n.pi_pid,null)==="alive"||n.final_report!=null||w.includes(n.status))}r(y,"passesCheapDisconnectedFilter");function b(n){return n.map(i=>`  ${i.node_id}  ${g(i)}  [${i.status}]`).join(`
+`)}r(b,"describe");async function E(n){const i=n.force??!1,d=v(),l=(await d.listNodes()).filter(y),o=[];for(const t of l){const s=await d.getNode(t.node_id);s.pi_session_id!=null&&o.push(s)}if(o.length===0)return{mode:"preview",candidates:"",message:"No disconnected nodes \u2014 every node with a resumable session already has a running engine. Nothing to revive."};if(!i){const t=b(o);return{mode:"preview",candidates:o.map(s=>s.node_id).join(`
+`),message:`${o.length} disconnected node(s) WOULD be revived (RESUME). Nothing has been launched yet:
+
+${t}
+
+Reviving all of these at once can have large, unforeseen consequences (a flood of resumed engines, cost, side effects from each node continuing its work). This is a preview only \u2014 DOUBLE-CHECK WITH THE USER that they want every node above brought back before you proceed. Once they confirm, re-run the revive with confirmation to actually relaunch them.`}}const e=await d.request("POST",m.reviveAll()),a={mode:"revived",revived:e.revived.join(`
+`),message:`Revived ${e.revived.length} disconnected node(s) (RESUME).`};e.failed.length>0&&(a.failed=e.failed.map(t=>`${t.node_id}: ${t.error}`).join(`
+`)),e.frozen.length>0&&(a.frozen=e.frozen.join(`
+`));const c=e.revived.length+e.failed.length+e.frozen.length;return c>e.revived.length&&(a.message=`Revived ${e.revived.length} of ${c} disconnected node(s) (RESUME)`+(e.failed.length>0?`; ${e.failed.length} failed to relaunch (see failed)`:"")+(e.frozen.length>0?`; ${e.frozen.length} frozen at the broker cap and launched as slots free (see frozen)`:"")+"."),a}r(E,"runReviveAll");export{U as reviveLeaf};

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

@@ -1,83 +1 @@
-// `crtr surface node cycle` — walk live viewers in DFS order.
-import { defineLeaf } from '../../../core/command.js';
-import { cliCanvasSource, getNodeOrNull, rethrowAsCliError } from '../../api-client.js';
-import { currentTmux, focusViewer, nodeInPane } from './placement.js';
-/** Every live node in DFS pre-order across the whole forest. The spawn tree is
- *  the `parent` field; children inherit their parent's row order (created), so
- *  the walk descends into a node's children before moving to its siblings —
- *  exactly "next in pre-order is your first child". Roots are live nodes with no
- *  live parent (a done/dead parent orphans its live children up to the top).
- *  Cycle-safe: a final pass appends any node a cycle kept from being reached. */
-async function liveDfsOrder() {
-    const rows = await cliCanvasSource().listNodes({ status: ['active', 'idle'] }).catch(rethrowAsCliError); // ORDER BY created
-    const liveIds = new Set(rows.map((r) => r.node_id));
-    const childrenOf = new Map();
-    for (const r of rows) {
-        const p = r.parent;
-        if (p != null && liveIds.has(p)) {
-            const arr = childrenOf.get(p) ?? [];
-            arr.push(r.node_id);
-            childrenOf.set(p, arr);
-        }
-    }
-    const out = [];
-    const seen = new Set();
-    const visit = (id) => {
-        if (seen.has(id))
-            return;
-        seen.add(id);
-        out.push(id);
-        for (const c of childrenOf.get(id) ?? [])
-            visit(c);
-    };
-    for (const r of rows)
-        if (r.parent == null || !liveIds.has(r.parent))
-            visit(r.node_id);
-    for (const r of rows)
-        visit(r.node_id); // stragglers (parent cycles)
-    return out;
-}
-export const surfaceNodeCycleLeaf = defineLeaf({
-    name: 'cycle',
-    description: 'DFS-walk to the next/prev live node\'s viewer',
-    whenToUse: 'sweeping the canvas one viewer at a time, descending into children before siblings (bound to Alt+] forward / Alt+[ back). Use `surface node focus` instead to jump straight to a named node',
-    help: {
-        name: 'surface node cycle',
-        summary: 'focus the next/previous live node\'s viewer in DFS pre-order — the canvas walked one viewer at a time, descending into a node\'s children before its siblings (bound to Alt+] forward / Alt+[ back)',
-        params: [
-            { kind: 'flag', name: 'dir', type: 'enum', choices: ['next', 'prev'], required: false, default: 'next', constraint: 'Direction along the pre-order: next (Alt+], rightward/deeper into children) or prev (Alt+[, back). Wraps at the ends.' },
-            { kind: 'flag', name: 'pane', type: 'string', required: false, constraint: 'tmux pane to cycle FROM. Defaults to $TMUX_PANE / your current pane. The Alt+] / Alt+[ bindings pass this for you.' },
-        ],
-        output: [
-            { name: 'focused', type: 'boolean', required: true, constraint: 'True when the neighbor was brought into view.' },
-            { name: 'node_id', type: 'string', required: false, constraint: 'The node now in front of you.' },
-            { name: 'name', type: 'string', required: false, constraint: 'Its display name.' },
-            { name: 'from', type: 'string', required: false, constraint: 'The node you cycled away from.' },
-        ],
-        outputKind: 'object',
-        effects: ['Brings the neighbor\'s viewer forefront beside the caller (like `surface node focus`); the viewer you were watching drops to the background.', 'Opens a parked resident from its saved snapshot without waking it; submitted input wakes it through the normal message path.'],
-    },
-    run: async (input) => {
-        const pane = input['pane'] ?? process.env['TMUX_PANE'] ?? currentTmux()?.pane ?? undefined;
-        const dir = (input['dir'] ?? 'next');
-        const fromId = nodeInPane(pane);
-        if (fromId === undefined)
-            return { focused: false };
-        const order = await liveDfsOrder();
-        const i = order.indexOf(fromId);
-        if (i === -1 || order.length < 2)
-            return { focused: false, node_id: fromId, from: fromId };
-        const step = dir === 'next' ? 1 : -1;
-        const targetId = order[(i + step + order.length) % order.length];
-        const target = await getNodeOrNull(targetId);
-        if (target === null)
-            return { focused: false, from: fromId };
-        // Placement brings the neighbor's viewer forefront beside the caller; the
-        // server keeps an exact parked resident offline until submitted input.
-        const res = await focusViewer(targetId, { cwd: target.cwd, name: target.name, pane });
-        return { focused: res.focused, node_id: targetId, name: target.name, from: fromId };
-    },
-    render: (r) => r['focused'] === true
-        ? `Cycled to "${r['name'] ?? ''}" (${r['node_id']}) — from ${r['from'] ?? '?'}.`
-        : 'No other live node to focus.',
-});
+var f=Object.defineProperty;var c=(n,s)=>f(n,"name",{value:s,configurable:!0});import{defineLeaf as u}from"../../../core/command.js";import{cliCanvasSource as l,getNodeOrNull as p,rethrowAsCliError as h}from"../../api-client.js";import{currentTmux as m,focusViewer as w,nodeInPane as g}from"./placement.js";async function v(){const n=await l().listNodes({status:["active","idle"]}).catch(h),s=new Set(n.map(e=>e.node_id)),d=new Map;for(const e of n){const t=e.parent;if(t!=null&&s.has(t)){const a=d.get(t)??[];a.push(e.node_id),d.set(t,a)}}const o=[],r=new Set,i=c(e=>{if(!r.has(e)){r.add(e),o.push(e);for(const t of d.get(e)??[])i(t)}},"visit");for(const e of n)(e.parent==null||!s.has(e.parent))&&i(e.node_id);for(const e of n)i(e.node_id);return o}c(v,"liveDfsOrder");const _=u({name:"cycle",description:"DFS-walk to the next/prev live node's viewer",whenToUse:"sweeping the canvas one viewer at a time, descending into children before siblings (bound to Alt+] forward / Alt+[ back). Use `surface node focus` instead to jump straight to a named node",help:{name:"surface node cycle",summary:"focus the next/previous live node's viewer in DFS pre-order \u2014 the canvas walked one viewer at a time, descending into a node's children before its siblings (bound to Alt+] forward / Alt+[ back)",params:[{kind:"flag",name:"dir",type:"enum",choices:["next","prev"],required:!1,default:"next",constraint:"Direction along the pre-order: next (Alt+], rightward/deeper into children) or prev (Alt+[, back). Wraps at the ends."},{kind:"flag",name:"pane",type:"string",required:!1,constraint:"tmux pane to cycle FROM. Defaults to $TMUX_PANE / your current pane. The Alt+] / Alt+[ bindings pass this for you."}],output:[{name:"focused",type:"boolean",required:!0,constraint:"True when the neighbor was brought into view."},{name:"node_id",type:"string",required:!1,constraint:"The node now in front of you."},{name:"name",type:"string",required:!1,constraint:"Its display name."},{name:"from",type:"string",required:!1,constraint:"The node you cycled away from."}],outputKind:"object",effects:["Brings the neighbor's viewer forefront beside the caller (like `surface node focus`); the viewer you were watching drops to the background.","Opens a parked resident from its saved snapshot without waking it; submitted input wakes it through the normal message path."]},run:c(async n=>{const s=n.pane??process.env.TMUX_PANE??m()?.pane??void 0,d=n.dir??"next",o=g(s);if(o===void 0)return{focused:!1};const r=await v(),i=r.indexOf(o);if(i===-1||r.length<2)return{focused:!1,node_id:o,from:o};const t=r[(i+(d==="next"?1:-1)+r.length)%r.length],a=await p(t);return a===null?{focused:!1,from:o}:{focused:(await w(t,{cwd:a.cwd,name:a.name,pane:s})).focused,node_id:t,name:a.name,from:o}},"run"),render:c(n=>n.focused===!0?`Cycled to "${n.name??""}" (${n.node_id}) \u2014 from ${n.from??"?"}.`:"No other live node to focus.","render")});export{_ as surfaceNodeCycleLeaf};