@north-light/crouter 0.3.317 → 0.3.319

package/dist/commands/node-lifecycle-revive.js

@@ -1,217 +1 @@
-// `crtr node lifecycle revive` — bring back ONE named node.
-//
-// Bypasses the daemon: directly relaunches the broker engine for a node that is
-// done, idle, dead, or canceled. Default behavior resumes the saved pi
-// conversation by its absolute session-file path (--session <path>) when that
-// .jsonl still exists, else falls through to a fresh launch. `--fresh` skips
-// the true resume: if the `.jsonl` already exists it CYCLES in place instead
-// (same file, a fresh `crtr-cycle` branch — `resumed:false`), and only starts a
-// genuinely clean session when no `.jsonl` exists yet (also `resumed:false`).
-//
-// `--now` is the on-demand kick for a hanging node (live broker parked on an
-// eligible pi→provider fault): SIGTERM the broker so the daemon's own
-// crash→grace→resume path brings it back, instead of waiting out the schedule.
-//
-// The mass-recovery form — reconnect EVERY disconnected node at once after a
-// reboot/crash — is genuinely graph-wide and stays at `canvas revive --all`
-// (src/commands/revive.ts).
-import { defineLeaf } from '../core/command.js';
-import { InputError } from '../core/io.js';
-import { cliClient, rethrowAsCliError } from './api-client.js';
-// Purity (spec §1/§10, plan B-2): this leaf's transitive RUNTIME import graph
-// must never reach `core/canvas/db.ts` (`openDb`) or `core/canvas/canvas.ts`
-// accessors — a `crtr` CLI process never opens canvas.db. So the revive itself
-// goes through the daemon (`cliClient().reviveNode`), and every helper below is
-// imported from a db-free module: `recordedPidLiveness` (pid.js → fs/ps only),
-// `faultNeedsYou` (status-glyph.js → fault.js), and `fullName` from labels.js
-// DIRECTLY (NOT the canvas barrel `index.js`, which re-exports `openDb`).
-// View-socket readiness comes from the db-free probe owner. The node's active
-// fault and mid-turn state are projected fields on the detail DTO this leaf
-// already fetches. The former direct
-// `reviveNode`/`getNode`/`assertReopenGate`/`waitForBrokerViewSocket`/`isBusy`
-// imports all reached the db barrel and are replaced by the client call + helpers below.
-import { recordedPidLiveness } from '../core/canvas/pid.js';
-import { fullName } from '../core/canvas/labels.js';
-import { faultNeedsYou } from '../core/canvas/status-glyph.js';
-import { waitForViewSocketReady } from '../core/runtime/view-socket.js';
-/** --now eligibility for a live, non-busy fault: a daemon-owned AUTO retry
- *  (kick it early instead of waiting out the schedule), or any fault the
- *  canvas dashboard flags "needs you" (`faultNeedsYou`, status-glyph.ts) — the
- *  disposition that otherwise has NO sanctioned recovery verb.
- *  Both are scoped to `pi→provider`: refuses a client-owned auto retry
- *  (redialing) already in flight, and refuses any OTHER link — notably a
- *  `daemon→node` wedge fault, which --now can't clear (SIGTERM doesn't touch
- *  the runaway subprocess; see `wedged-child-on-runaway-bash`). */
-export function isNowEligibleFault(fault) {
-    if (fault === null || fault.link !== 'pi→provider')
-        return false;
-    if (faultNeedsYou(fault))
-        return true;
-    return fault.retry.by === 'daemon';
-}
-export const nodeReviveLeaf = defineLeaf({
-    name: 'revive',
-    description: 'reopen a window for a done/idle/dead/canceled node',
-    whenToUse: 'you want to bring a dormant node back yourself — reopen a window for one that is done, idle, dead, or canceled: resume a node you closed with `node lifecycle close`, reopen a finished worker for a follow-up, or restart a crashed one now instead of waiting. It resumes the saved conversation by default, or can restart the node clean. You rarely need this for crashes — the daemon auto-revives those; reach for it to bring a node back on demand, to revive a canceled node the daemon will never touch on its own, or to kick a hanging one early (--now). To mass-reconnect EVERY disconnected node at once (after a reboot, a killed login/tmux session, or the daemon being down a while), use `canvas revive --all` instead',
-    help: {
-        name: 'node lifecycle revive',
-        summary: 'relaunch a node\'s broker engine (resuming its saved conversation), or kick a hanging one (--now)',
-        params: [
-            {
-                kind: 'positional',
-                name: 'node',
-                required: true,
-                constraint: 'Node id to revive.',
-            },
-            {
-                kind: 'flag',
-                name: 'fresh',
-                type: 'bool',
-                required: false,
-                default: false,
-                constraint: 'When set, do NOT do a true resume. If the node already has a session `.jsonl`, this instead CYCLES it in place — reuses that SAME file, resets the tree leaf, and roots a fresh `crtr-cycle` branch (a clean-context restart that still carries the file\'s history, output `resumed:false`). Only when no `.jsonl` exists yet does this start a genuinely brand-new session (also `resumed:false`). Default (no --fresh): a true resume — replays the existing `.jsonl` as-is (`resumed:true`).',
-            },
-            {
-                kind: 'flag',
-                name: 'now',
-                type: 'bool',
-                required: false,
-                default: false,
-                constraint: 'On-demand kick of an active-fault node (parked on a `pi→provider` fault, broker still alive). Its broker pid is alive, so an ordinary revive no-ops (double-launch guard) — --now SIGTERMs the live broker instead, so the daemon\'s crash→grace→resume path brings it back in ~20s. Valid for a live `pi→provider` fault that is either a daemon-owned auto retry (kicks it early), or ANY fault the canvas dashboard flags "needs you" (e.g. exhausted retries, an auth fault you just fixed) — that disposition otherwise has no recovery verb. Mutually exclusive with --fresh.',
-            },
-            {
-                kind: 'flag',
-                name: 'reopen',
-                type: 'bool',
-                required: false,
-                default: false,
-                constraint: 'Clear a latched node\'s finalization latch (final_report/finalized_at only — the old report file and every delivered feed event are untouched) before reviving it. Rejected against a node that is not finalized. Mutually exclusive with --now.',
-            },
-        ],
-        output: [
-            { name: 'resumed', type: 'boolean', required: false, constraint: 'True ONLY for a true resume (the existing `.jsonl` replayed as-is). False for a --fresh revive, whether that landed as an in-place CYCLE (an existing `.jsonl` reused with a fresh `crtr-cycle` branch — pi is still told --session, but this is not a resume) or a genuinely fresh launch (no `.jsonl` existed). Absent for a --now kick.' },
-            { name: 'ready', type: 'boolean', required: false, constraint: 'True when the revived broker\'s view.sock accepted a connection before return — the node is immediately attachable/drivable. Absent for a --now kick.' },
-            { name: 'kicked', type: 'boolean', required: false, constraint: 'True when --now SIGTERM\'d the hanging node\'s live broker (the daemon resumes it on the saved session within ~20s). Absent for an ordinary revive.' },
-            { name: 'message', type: 'string', required: false, constraint: 'Kick confirmation naming the signalled node, pid, and the daemon\'s ~20s resume handoff. Present only for --now.' },
-        ],
-        outputKind: 'object',
-        effects: [
-            'Launches the node\'s detached headless broker engine (no tmux window).',
-            'Updates the node\'s canvas record: status=active, intent=null.',
-            'Blocks until the broker\'s view.sock accepts a connection (up to ~30s), so a caller can attach/dial immediately on return.',
-            '--now: SIGTERMs the live broker instead of launching anything (the daemon\'s own crash-grace path resumes it).',
-        ],
-    },
-    run: async (input) => {
-        const now = input['now'] ?? false;
-        const nodeId = input['node'];
-        const fresh = input['fresh'] ?? false;
-        const reopen = input['reopen'] ?? false;
-        if (now && reopen) {
-            throw new InputError({
-                error: 'conflicting_args',
-                message: '`--now` kicks a LIVE broker (nothing to reopen — a finalized node has no live broker); `--reopen` is meaningless there.',
-                next: 'Run `crtr node lifecycle revive <node> --now` on a hanging node, or `crtr node lifecycle revive <node> --reopen` (no --now) to re-task a finalized one.',
-            });
-        }
-        if (now && fresh) {
-            throw new InputError({
-                error: 'conflicting_args',
-                message: '`--now` kicks a live hanging broker (SIGTERM → daemon resumes the SAVED session); `--fresh` is meaningless there.',
-                next: 'Run `crtr node lifecycle revive <node> --now` (resumes), or `crtr node lifecycle revive <node> --fresh` (no --now) to relaunch clean.',
-            });
-        }
-        const client = cliClient();
-        // --now: the on-demand kick for an active fault. The broker is ALIVE (so an
-        // ordinary revive would no-op the double-launch guard) — SIGTERM it so the
-        // daemon's ordinary crash→grace→resume path recovers it on the saved session,
-        // the same thing the daemon does at the auto-recovery grace, just on demand.
-        // Gated on a live pid and an eligible pi→provider fault (`isNowEligibleFault`
-        // above) so it can't be used to nuke a healthy node. This whole path stays
-        // LOCAL: the kick is a direct SIGTERM to the broker pid (there is no revive
-        // API call), and the node detail comes from the daemon read (`getNode`). The
-        // reopen gate is NOT invoked here — --now targets a LIVE broker, and a
-        // finalized node has none (its own live-pid check below refuses it anyway).
-        if (now) {
-            // The detail DTO projects `pi_pid_identity` (the launch-time process-identity
-            // baseline captured alongside `pi_pid`), so the pid-reuse guard is intact:
-            // `recordedPidLiveness(pid, identity)` refuses to treat a recycled pid as
-            // "alive-and-ours", and the SIGTERM below only fires on a positively
-            // confirmed-alive-and-ours pid. Null identity (node predates the field, or
-            // launch-time capture failed) fails open to the trust-isPidAlive branch.
-            let detail;
-            try {
-                detail = await client.getNode(nodeId);
-            }
-            catch (e) {
-                rethrowAsCliError(e);
-            }
-            const pid = detail.pi_pid;
-            const stall = detail.fault ?? null;
-            if (pid == null || recordedPidLiveness(pid, detail.pi_pid_identity ?? null) !== 'alive') {
-                throw new InputError({
-                    error: 'not_hanging',
-                    message: `${nodeId} has no live broker — nothing to kick. --now is for a HANGING node (live broker parked on an active fault).`,
-                    next: 'Revive a dormant node with `crtr node lifecycle revive ' + nodeId + '` (no --now).',
-                });
-            }
-            if (!isNowEligibleFault(stall)) {
-                throw new InputError({
-                    error: 'not_hanging',
-                    message: `${nodeId} is live but has no pi→provider fault eligible for --now (either healthy, or a client-owned retry / non-provider fault already being handled elsewhere) — --now refuses to SIGTERM a node that isn't stuck on a kickable provider fault.`,
-                    next: 'Use --now only on a node the canvas shows as hanging (⚠) with a `pi→provider` fault. For a routine relaunch, omit --now.',
-                });
-            }
-            // The daemon never kills a BUSY engine (its verdict paths all return 'leave'
-            // on an open turn): a node mid-turn is making progress, not wedged —
-            // refuse rather than SIGTERM it mid-flight.
-            if (detail.streaming === true) {
-                throw new InputError({
-                    error: 'busy',
-                    message: `${nodeId} is mid-turn right now (busy) — --now refuses to SIGTERM a working engine; it has recovered on its own.`,
-                    next: 'Re-check the canvas — if it\'s no longer marked hanging (⚠), nothing to do.',
-                });
-            }
-            try {
-                process.kill(pid, 'SIGTERM');
-            }
-            catch {
-                /* best-effort: the broker may have just died; the daemon owns the resume */
-            }
-            return {
-                kicked: true,
-                message: `Sent SIGTERM to ${fullName(detail)} (${nodeId}, pid ${pid}). The daemon will resume it on the saved session within ~20s (crash→grace→resume).`,
-            };
-        }
-        // Ordinary revive: the daemon relaunches the broker (the ONLY sanctioned
-        // launcher). Node-existence validation (`not_found`) and the reopen gate
-        // are both enforced server-side in `handleRevive`; a thrown gate/not-found
-        // error round-trips through `ApiError.details` and is reconstructed into the
-        // identical `InputError` by the shared `apiErrorToCliError` (via
-        // `rethrowAsCliError`).
-        // Wake provenance: when this leaf is running inside a cron's run (the daemon
-        // stamps CRTR_CRON_ID into every run's environment), forward that id so
-        // crtrd can inject the `<crtr-wake>` block and the revived node learns a
-        // CLOCK woke it, not a message. Absent outside a cron run.
-        const cronId = process.env['CRTR_CRON_ID'];
-        let result;
-        try {
-            result = await client.reviveNode(nodeId, {
-                resume: !fresh,
-                reopen,
-                ...(cronId !== undefined && cronId !== '' ? { cron_id: cronId } : {}),
-            });
-        }
-        catch (e) {
-            rethrowAsCliError(e);
-        }
-        // The revive route returns once the broker process is launched, which can be
-        // seconds before its view.sock listens. Clients that attach immediately on
-        // return need this leaf to wait until the socket accepts.
-        const ready = await waitForViewSocketReady(nodeId);
-        return {
-            resumed: result.resumed,
-            ready,
-        };
-    },
-});
+var w=Object.defineProperty;var s=(e,r)=>w(e,"name",{value:r,configurable:!0});import{defineLeaf as g}from"../core/command.js";import{InputError as a}from"../core/io.js";import{cliClient as p,rethrowAsCliError as u}from"./api-client.js";import{recordedPidLiveness as y}from"../core/canvas/pid.js";import{fullName as k}from"../core/canvas/labels.js";import{faultNeedsYou as b}from"../core/canvas/status-glyph.js";import{waitForViewSocketReady as x}from"../core/runtime/view-socket.js";function R(e){return e===null||e.link!=="pi\u2192provider"?!1:b(e)?!0:e.retry.by==="daemon"}s(R,"isNowEligibleFault");const j=g({name:"revive",description:"reopen a window for a done/idle/dead/canceled node",whenToUse:"you want to bring a dormant node back yourself \u2014 reopen a window for one that is done, idle, dead, or canceled: resume a node you closed with `node lifecycle close`, reopen a finished worker for a follow-up, or restart a crashed one now instead of waiting. It resumes the saved conversation by default, or can restart the node clean. You rarely need this for crashes \u2014 the daemon auto-revives those; reach for it to bring a node back on demand, to revive a canceled node the daemon will never touch on its own, or to kick a hanging one early (--now). To mass-reconnect EVERY disconnected node at once (after a reboot, a killed login/tmux session, or the daemon being down a while), use `canvas revive --all` instead",help:{name:"node lifecycle revive",summary:"relaunch a node's broker engine (resuming its saved conversation), or kick a hanging one (--now)",params:[{kind:"positional",name:"node",required:!0,constraint:"Node id to revive."},{kind:"flag",name:"fresh",type:"bool",required:!1,default:!1,constraint:"When set, do NOT do a true resume. If the node already has a session `.jsonl`, this instead CYCLES it in place \u2014 reuses that SAME file, resets the tree leaf, and roots a fresh `crtr-cycle` branch (a clean-context restart that still carries the file's history, output `resumed:false`). Only when no `.jsonl` exists yet does this start a genuinely brand-new session (also `resumed:false`). Default (no --fresh): a true resume \u2014 replays the existing `.jsonl` as-is (`resumed:true`)."},{kind:"flag",name:"now",type:"bool",required:!1,default:!1,constraint:'On-demand kick of an active-fault node (parked on a `pi\u2192provider` fault, broker still alive). Its broker pid is alive, so an ordinary revive no-ops (double-launch guard) \u2014 --now SIGTERMs the live broker instead, so the daemon\'s crash\u2192grace\u2192resume path brings it back in ~20s. Valid for a live `pi\u2192provider` fault that is either a daemon-owned auto retry (kicks it early), or ANY fault the canvas dashboard flags "needs you" (e.g. exhausted retries, an auth fault you just fixed) \u2014 that disposition otherwise has no recovery verb. Mutually exclusive with --fresh.'},{kind:"flag",name:"reopen",type:"bool",required:!1,default:!1,constraint:"Clear a latched node's finalization latch (final_report/finalized_at only \u2014 the old report file and every delivered feed event are untouched) before reviving it. Rejected against a node that is not finalized. Mutually exclusive with --now."}],output:[{name:"resumed",type:"boolean",required:!1,constraint:"True ONLY for a true resume (the existing `.jsonl` replayed as-is). False for a --fresh revive, whether that landed as an in-place CYCLE (an existing `.jsonl` reused with a fresh `crtr-cycle` branch \u2014 pi is still told --session, but this is not a resume) or a genuinely fresh launch (no `.jsonl` existed). Absent for a --now kick."},{name:"ready",type:"boolean",required:!1,constraint:"True when the revived broker's view.sock accepted a connection before return \u2014 the node is immediately attachable/drivable. Absent for a --now kick."},{name:"kicked",type:"boolean",required:!1,constraint:"True when --now SIGTERM'd the hanging node's live broker (the daemon resumes it on the saved session within ~20s). Absent for an ordinary revive."},{name:"message",type:"string",required:!1,constraint:"Kick confirmation naming the signalled node, pid, and the daemon's ~20s resume handoff. Present only for --now."}],outputKind:"object",effects:["Launches the node's detached headless broker engine (no tmux window).","Updates the node's canvas record: status=active, intent=null.","Blocks until the broker's view.sock accepts a connection (up to ~30s), so a caller can attach/dial immediately on return.","--now: SIGTERMs the live broker instead of launching anything (the daemon's own crash-grace path resumes it)."]},run:s(async e=>{const r=e.now??!1,n=e.node,d=e.fresh??!1,l=e.reopen??!1;if(r&&l)throw new a({error:"conflicting_args",message:"`--now` kicks a LIVE broker (nothing to reopen \u2014 a finalized node has no live broker); `--reopen` is meaningless there.",next:"Run `crtr node lifecycle revive <node> --now` on a hanging node, or `crtr node lifecycle revive <node> --reopen` (no --now) to re-task a finalized one."});if(r&&d)throw new a({error:"conflicting_args",message:"`--now` kicks a live hanging broker (SIGTERM \u2192 daemon resumes the SAVED session); `--fresh` is meaningless there.",next:"Run `crtr node lifecycle revive <node> --now` (resumes), or `crtr node lifecycle revive <node> --fresh` (no --now) to relaunch clean."});const c=p();if(r){let o;try{o=await c.getNode(n)}catch(v){u(v)}const t=o.pi_pid,m=o.fault??null;if(t==null||y(t,o.pi_pid_identity??null)!=="alive")throw new a({error:"not_hanging",message:`${n} has no live broker \u2014 nothing to kick. --now is for a HANGING node (live broker parked on an active fault).`,next:"Revive a dormant node with `crtr node lifecycle revive "+n+"` (no --now)."});if(!R(m))throw new a({error:"not_hanging",message:`${n} is live but has no pi\u2192provider fault eligible for --now (either healthy, or a client-owned retry / non-provider fault already being handled elsewhere) \u2014 --now refuses to SIGTERM a node that isn't stuck on a kickable provider fault.`,next:"Use --now only on a node the canvas shows as hanging (\u26A0) with a `pi\u2192provider` fault. For a routine relaunch, omit --now."});if(o.streaming===!0)throw new a({error:"busy",message:`${n} is mid-turn right now (busy) \u2014 --now refuses to SIGTERM a working engine; it has recovered on its own.`,next:"Re-check the canvas \u2014 if it's no longer marked hanging (\u26A0), nothing to do."});try{process.kill(t,"SIGTERM")}catch{}return{kicked:!0,message:`Sent SIGTERM to ${k(o)} (${n}, pid ${t}). The daemon will resume it on the saved session within ~20s (crash\u2192grace\u2192resume).`}}const i=process.env.CRTR_CRON_ID;let h;try{h=await c.reviveNode(n,{resume:!d,reopen:l,...i!==void 0&&i!==""?{cron_id:i}:{}})}catch(o){u(o)}const f=await x(n);return{resumed:h.resumed,ready:f}},"run")});export{R as isNowEligibleFault,j as nodeReviveLeaf};

package/dist/commands/node-snapshot.js

@@ -1,37 +1 @@
-// `crtr node inspect snapshot` — read a dormant node's session snapshot without
-// launching its broker. Re-plumbed onto the API (Stage B-3): the session read
-// itself now runs server-side in crtrd (`GET /v1/nodes/{id}/snapshot`, backed by
-// `core/runtime/node-read.ts`); this leaf is a pure client.
-import { defineLeaf } from '../core/command.js';
-import { cliClient, rethrowAsCliError } from './api-client.js';
-export const nodeSnapshotLeaf = defineLeaf({
-    name: 'snapshot',
-    description: 'read a dormant node session snapshot without launching its broker',
-    whenToUse: 'you need a read-only broker-compatible snapshot of a dormant node; it copies the session JSONL before parsing and never revives the node',
-    tier: 'hidden',
-    help: {
-        name: 'node inspect snapshot',
-        summary: 'read-only dormant node snapshot in the broker welcome shape',
-        params: [{ kind: 'positional', name: 'id', type: 'string', required: true, constraint: 'Canvas node id.' }],
-        output: [
-            { name: 'node_id', type: 'string', required: true, constraint: 'The node id.' },
-            { name: 'snapshot', type: 'object', required: true, constraint: 'BrokerSnapshot-compatible {messages, stats, state, display}; `display` is always empty here — extension display state is live broker process state, not persisted.' },
-            { name: 'commands', type: 'object[]', required: true, constraint: "Builtin slash commands only: {name,description,source:'builtin'}." },
-        ],
-        outputKind: 'object',
-        effects: ['Read-only: crtrd copies the session JSONL to a temp dir, parses the copy, then deletes the temp dir. Does not launch or revive brokers.'],
-        // Full session reconstruction (every message) for tooling, not a
-        // human/agent glance — collapse it in the attach viewer by default.
-        preview: { suppressOutput: true },
-    },
-    run: async (input) => {
-        const id = input['id'];
-        try {
-            const dto = await cliClient().getSnapshot(id);
-            return { node_id: dto.node_id, snapshot: dto.snapshot, commands: dto.commands };
-        }
-        catch (err) {
-            rethrowAsCliError(err);
-        }
-    },
-});
+var o=Object.defineProperty;var n=(t,s)=>o(t,"name",{value:s,configurable:!0});import{defineLeaf as r}from"../core/command.js";import{cliClient as a,rethrowAsCliError as i}from"./api-client.js";const m=r({name:"snapshot",description:"read a dormant node session snapshot without launching its broker",whenToUse:"you need a read-only broker-compatible snapshot of a dormant node; it copies the session JSONL before parsing and never revives the node",tier:"hidden",help:{name:"node inspect snapshot",summary:"read-only dormant node snapshot in the broker welcome shape",params:[{kind:"positional",name:"id",type:"string",required:!0,constraint:"Canvas node id."}],output:[{name:"node_id",type:"string",required:!0,constraint:"The node id."},{name:"snapshot",type:"object",required:!0,constraint:"BrokerSnapshot-compatible {messages, stats, state, display}; `display` is always empty here \u2014 extension display state is live broker process state, not persisted."},{name:"commands",type:"object[]",required:!0,constraint:"Builtin slash commands only: {name,description,source:'builtin'}."}],outputKind:"object",effects:["Read-only: crtrd copies the session JSONL to a temp dir, parses the copy, then deletes the temp dir. Does not launch or revive brokers."],preview:{suppressOutput:!0}},run:n(async t=>{const s=t.id;try{const e=await a().getSnapshot(s);return{node_id:e.node_id,snapshot:e.snapshot,commands:e.commands}}catch(e){i(e)}},"run")});export{m as nodeSnapshotLeaf};

package/dist/commands/node-transcript.js

@@ -1,62 +1 @@
-// `crtr node inspect transcript` — read a node's saved conversation without
-// reviving its broker. The transcript is rendered into a temporary Markdown
-// file and opened read-only in nvim; the persisted session and canvas row are
-// never changed.
-//
-// Re-plumbed onto the API (Stage B-3): the markdown is rendered server-side in
-// crtrd (`GET /v1/nodes/{id}/transcript`, backed by `core/runtime/node-read.ts`).
-// The nvim viewer tail stays local (a viewer surface, not canvas state).
-import { spawnSync } from 'node:child_process';
-import { mkdtempSync, rmSync, writeFileSync } from 'node:fs';
-import { tmpdir } from 'node:os';
-import { join } from 'node:path';
-import { defineLeaf } from '../core/command.js';
-import { InputError } from '../core/io.js';
-import { cliClient, rethrowAsCliError } from './api-client.js';
-function nvimAvailable() {
-    const r = spawnSync('nvim', ['--version'], { stdio: 'ignore' });
-    return r.error === undefined && (r.status === 0 || r.status === null);
-}
-export const nodeTranscriptLeaf = defineLeaf({
-    name: 'transcript',
-    description: 'read a node’s saved conversation without reviving it',
-    whenToUse: 'you have a node id and need to inspect its past conversation without changing its lifecycle or launching an agent',
-    help: {
-        name: 'node inspect transcript',
-        summary: 'open a node’s saved conversation read-only in nvim; never launches or revives its broker',
-        params: [{ kind: 'positional', name: 'node-id', required: true, constraint: 'The node whose saved conversation to inspect.' }],
-        output: [{ name: 'transcript', type: 'string', required: true, constraint: 'Markdown transcript on the non-TTY path.' }],
-        outputKind: 'object',
-        effects: ['TTY: opens a temporary read-only nvim buffer and deletes it after exit. Non-TTY: prints the transcript. Never changes node status or starts a broker.'],
-    },
-    run: async (input) => {
-        const nodeId = input['nodeId'];
-        let transcript;
-        try {
-            transcript = (await cliClient().getTranscript(nodeId)).markdown;
-        }
-        catch (err) {
-            rethrowAsCliError(err);
-        }
-        if (!process.stdout.isTTY)
-            return { transcript };
-        if (!nvimAvailable()) {
-            throw new InputError({
-                error: 'nvim_missing',
-                message: 'nvim is not on PATH — `crtr node inspect transcript` opens saved conversations in nvim',
-                next: 'Install Neovim, then retry.',
-            });
-        }
-        const dir = mkdtempSync(join(tmpdir(), 'crtr-transcript-'));
-        const path = join(dir, 'transcript.md');
-        try {
-            writeFileSync(path, transcript);
-            spawnSync('nvim', ['-R', path], { stdio: 'inherit' });
-        }
-        finally {
-            rmSync(dir, { recursive: true, force: true });
-        }
-        return { transcript };
-    },
-    render: (result) => String(result['transcript']),
-});
+var d=Object.defineProperty;var t=(r,e)=>d(r,"name",{value:e,configurable:!0});import{spawnSync as s}from"node:child_process";import{mkdtempSync as p,rmSync as m,writeFileSync as u}from"node:fs";import{tmpdir as v}from"node:os";import{join as a}from"node:path";import{defineLeaf as f}from"../core/command.js";import{InputError as l}from"../core/io.js";import{cliClient as h,rethrowAsCliError as y}from"./api-client.js";function T(){const r=s("nvim",["--version"],{stdio:"ignore"});return r.error===void 0&&(r.status===0||r.status===null)}t(T,"nvimAvailable");const A=f({name:"transcript",description:"read a node\u2019s saved conversation without reviving it",whenToUse:"you have a node id and need to inspect its past conversation without changing its lifecycle or launching an agent",help:{name:"node inspect transcript",summary:"open a node\u2019s saved conversation read-only in nvim; never launches or revives its broker",params:[{kind:"positional",name:"node-id",required:!0,constraint:"The node whose saved conversation to inspect."}],output:[{name:"transcript",type:"string",required:!0,constraint:"Markdown transcript on the non-TTY path."}],outputKind:"object",effects:["TTY: opens a temporary read-only nvim buffer and deletes it after exit. Non-TTY: prints the transcript. Never changes node status or starts a broker."]},run:t(async r=>{const e=r.nodeId;let n;try{n=(await h().getTranscript(e)).markdown}catch(c){y(c)}if(!process.stdout.isTTY)return{transcript:n};if(!T())throw new l({error:"nvim_missing",message:"nvim is not on PATH \u2014 `crtr node inspect transcript` opens saved conversations in nvim",next:"Install Neovim, then retry."});const i=p(a(v(),"crtr-transcript-")),o=a(i,"transcript.md");try{u(o,n),s("nvim",["-R",o],{stdio:"inherit"})}finally{m(i,{recursive:!0,force:!0})}return{transcript:n}},"run"),render:t(r=>String(r.transcript),"render")});export{A as nodeTranscriptLeaf};

package/dist/commands/node-worktree.js

@@ -1,138 +1 @@
-// `crtr node worktree` manages node-owned managed worktrees.
-import { envNodeId } from '../shared/env.js';
-import { defineBranch, defineLeaf } from '../core/command.js';
-import { InputError } from '../core/io.js';
-import { ApiError } from '../api/index.js';
-import { cliClient } from './api-client.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 — worktree commands run inside a canvas node.',
-            next: 'Run this command from a node process spawned by the runtime.',
-        });
-    }
-    return id.trim();
-}
-// The worktree leaf preserves a RICHER error contract than the generic
-// `rethrowAsCliError`: the daemon's `handlers/worktree.ts` rethrows the core
-// `WorktreeError`'s SPECIFIC code (`dirty_worktree`, `rebase_failed`,
-// `no_managed_worktree`, `unknown_node`, …) as a `CrtrError` carrying
-// `details.{next,received}`, which survive `toErrorBody` into the response.
-// So we surface the code/next/received verbatim rather than collapsing to a
-// status bucket — keeping the pre-API agent-facing contract byte-for-byte.
-function mapWorktreeApiError(err) {
-    if (err instanceof ApiError) {
-        const details = (err.details ?? {});
-        throw new InputError({
-            error: err.code,
-            message: err.message,
-            ...(typeof details.received === 'string' ? { received: details.received } : {}),
-            next: typeof details.next === 'string'
-                ? details.next
-                : 'Inspect the error and adjust the call. See -h for the schema.',
-        });
-    }
-    throw err;
-}
-const worktreeAbandon = defineLeaf({
-    name: 'abandon',
-    description: 'remove a node worktree and preserve any branch work',
-    whenToUse: 'a canceled, dead, or otherwise finished node holds work you will not land now: remove its checkout without reviving it, retain its branch work, and release its worktree ownership so finalization or deletion can continue',
-    help: {
-        name: 'node worktree abandon',
-        summary: 'remove a node-managed checkout, retain its work, and commit dirty changes first',
-        params: [
-            { kind: 'positional', name: 'node', required: true, constraint: 'Node id whose open managed worktree to abandon.' },
-        ],
-        output: [
-            { name: 'node_id', type: 'string', required: true, constraint: 'The node whose worktree was abandoned.' },
-            { name: 'branch', type: 'string', required: true, constraint: 'The branch that retains abandoned work, or the deleted empty branch.' },
-            { name: 'tip_sha', type: 'string', required: true, constraint: 'The preserved work tip, or the deleted empty branch tip.' },
-            { name: 'worktree_path', type: 'string', required: true, constraint: 'The removed managed checkout path.' },
-            { name: 'branch_deleted', type: 'boolean', required: true, constraint: 'Whether the empty branch was deleted; false means the branch retains work or cleanup needs manual completion.' },
-        ],
-        outputKind: 'object',
-        effects: ['Removes the checkout. A clean zero-commit worktree deletes its empty branch. Otherwise commits all worktree state to the branch, retains that branch, records abandoned provenance, and repoints the node cwd to the repository root without changing lifecycle status.'],
-    },
-    run: async (input) => {
-        const nodeId = input['node'];
-        try {
-            return { ...(await cliClient().abandonWorktree(nodeId, { by: envNodeId() ?? 'human' })) };
-        }
-        catch (err) {
-            mapWorktreeApiError(err);
-        }
-    },
-    render: (r) => r['branch_deleted'] === true
-        ? `Managed empty worktree abandoned — checkout and empty branch ${String(r['branch'])} removed.`
-        : `Managed worktree abandoned — checkout removed; branch ${String(r['branch'])} kept at ${String(r['tip_sha'])}.`,
-});
-const worktreeClose = defineLeaf({
-    name: 'close',
-    description: 'land or safely close the current node-managed worktree',
-    whenToUse: 'you are inside the node that owns an open managed worktree and are ready to land its recorded branch into the local base, or to close a moved real branch whose already-delivered content can be safely preserved while its checkout is disposed later',
-    help: {
-        name: 'node worktree close',
-        summary: 'land or safely close the current node-managed worktree',
-        params: [],
-        output: [
-            { name: 'node_id', type: 'string', required: true, constraint: 'The caller node id whose managed worktree was closed.' },
-            { name: 'branch', type: 'string', required: true, constraint: 'The branch whose delivered content is retained: fast-forwarded into the recorded local base in an ordinary close, or preserved unchanged when a moved real branch is authorized for disposal.' },
-            { name: 'landed_sha', type: 'string', required: true, constraint: 'The retained branch tip: fast-forwarded into the local base in an ordinary close, or proven already contained in the local base or its upstream before a moved real branch is authorized for disposal.' },
-            { name: 'worktree_path', type: 'string', required: true, constraint: 'The managed worktree path whose cleanup is deferred until its caller exits.' },
-            { name: 'worktree_removed', type: 'boolean', required: true, constraint: 'Always false for an active caller: its checkout remains intact rather than being removed beneath the node.' },
-            { name: 'worktree_remove_error', type: 'string', required: true, constraint: 'The named deferred-cleanup state and safe manual follow-up after the caller exits.' },
-            { name: 'branch_deleted', type: 'boolean', required: true, constraint: 'False while the deferred-cleanup checkout still has this branch checked out.' },
-            { name: 'branch_delete_error', type: 'string', required: true, constraint: 'The safe branch-cleanup follow-up after the checkout is removed.' },
-            { name: 'base_checkout_stash', type: 'string', required: false, constraint: 'Present when conflicting base-checkout changes were retained in a stash; names the exact stash SHA and command required to recover them.' }
-        ],
-        outputKind: 'object',
-        effects: [
-            'Rebases the worktree onto its recorded local base branch and fast-forwards that base onto it (never pushes to origin), marking the node-managed worktree closed with cleanup pending and leaving the active caller checkout and branch intact. When the recorded branch is gone because ordinary work moved this checkout onto a real branch, and that branch\'s content is already contained in the recorded base, closes by authorizing the checkout\'s later removal instead of landing — preserving that branch rather than deleting it.',
-        ],
-    },
-    run: async () => {
-        const nodeId = requireCallerNode();
-        try {
-            return { ...(await cliClient().closeWorktree(nodeId)) };
-        }
-        catch (err) {
-            mapWorktreeApiError(err);
-        }
-    },
-    render: (r) => {
-        const branch = String(r['branch'] ?? '');
-        const sha = String(r['landed_sha'] ?? '');
-        const path = String(r['worktree_path'] ?? '');
-        let base = `Managed worktree closed — ${branch} at ${sha} is retained.`;
-        const notes = [];
-        if (r['worktree_removed'] === false) {
-            notes.push(String(r['worktree_remove_error'] ?? `worktree checkout at ${path} could not be removed automatically.`));
-        }
-        else {
-            base += ` Worktree removed at ${path}.`;
-        }
-        if (r['branch_deleted'] === false) {
-            notes.push(String(r['branch_delete_error'] ?? `local branch ${branch} could not be deleted automatically.`));
-        }
-        if (typeof r['base_checkout_stash'] === 'string') {
-            notes.push(`Warning: ${r['base_checkout_stash']}`);
-        }
-        if (notes.length > 0)
-            return `${base} Note: ${notes.join(' ')}`;
-        return base;
-    },
-});
-export const nodeWorktreeBranch = defineBranch({
-    name: 'worktree',
-    description: 'manage a node-owned git worktree — land it or explicitly abandon it',
-    whenToUse: 'you need to dispose of a managed checkout: close lands the current node’s work onto its base; abandon removes any node’s checkout while retaining its work on the branch',
-    help: {
-        name: 'node worktree',
-        summary: 'manage a node-owned git worktree — land it, or explicitly abandon its checkout while retaining work',
-        model: 'Close merges work into its recorded base. Abandon removes the checkout without changing lifecycle state; it retains work on the branch and deletes only a clean zero-commit branch.',
-    },
-    children: [worktreeClose, worktreeAbandon],
-});
+var u=Object.defineProperty;var r=(e,t)=>u(e,"name",{value:t,configurable:!0});import{envNodeId as d}from"../shared/env.js";import{defineBranch as m,defineLeaf as s}from"../core/command.js";import{InputError as c}from"../core/io.js";import{ApiError as p}from"../api/index.js";import{cliClient as h}from"./api-client.js";function w(){const e=d();if(e===void 0||e.trim()==="")throw new c({error:"no_node_context",message:"CRTR_NODE_ID is not set \u2014 worktree commands run inside a canvas node.",next:"Run this command from a node process spawned by the runtime."});return e.trim()}r(w,"requireCallerNode");function l(e){if(e instanceof p){const t=e.details??{};throw new c({error:e.code,message:e.message,...typeof t.received=="string"?{received:t.received}:{},next:typeof t.next=="string"?t.next:"Inspect the error and adjust the call. See -h for the schema."})}throw e}r(l,"mapWorktreeApiError");const b=s({name:"abandon",description:"remove a node worktree and preserve any branch work",whenToUse:"a canceled, dead, or otherwise finished node holds work you will not land now: remove its checkout without reviving it, retain its branch work, and release its worktree ownership so finalization or deletion can continue",help:{name:"node worktree abandon",summary:"remove a node-managed checkout, retain its work, and commit dirty changes first",params:[{kind:"positional",name:"node",required:!0,constraint:"Node id whose open managed worktree to abandon."}],output:[{name:"node_id",type:"string",required:!0,constraint:"The node whose worktree was abandoned."},{name:"branch",type:"string",required:!0,constraint:"The branch that retains abandoned work, or the deleted empty branch."},{name:"tip_sha",type:"string",required:!0,constraint:"The preserved work tip, or the deleted empty branch tip."},{name:"worktree_path",type:"string",required:!0,constraint:"The removed managed checkout path."},{name:"branch_deleted",type:"boolean",required:!0,constraint:"Whether the empty branch was deleted; false means the branch retains work or cleanup needs manual completion."}],outputKind:"object",effects:["Removes the checkout. A clean zero-commit worktree deletes its empty branch. Otherwise commits all worktree state to the branch, retains that branch, records abandoned provenance, and repoints the node cwd to the repository root without changing lifecycle status."]},run:r(async e=>{const t=e.node;try{return{...await h().abandonWorktree(t,{by:d()??"human"})}}catch(a){l(a)}},"run"),render:r(e=>e.branch_deleted===!0?`Managed empty worktree abandoned \u2014 checkout and empty branch ${String(e.branch)} removed.`:`Managed worktree abandoned \u2014 checkout removed; branch ${String(e.branch)} kept at ${String(e.tip_sha)}.`,"render")}),k=s({name:"close",description:"land or safely close the current node-managed worktree",whenToUse:"you are inside the node that owns an open managed worktree and are ready to land its recorded branch into the local base, or to close a moved real branch whose already-delivered content can be safely preserved while its checkout is disposed later",help:{name:"node worktree close",summary:"land or safely close the current node-managed worktree",params:[],output:[{name:"node_id",type:"string",required:!0,constraint:"The caller node id whose managed worktree was closed."},{name:"branch",type:"string",required:!0,constraint:"The branch whose delivered content is retained: fast-forwarded into the recorded local base in an ordinary close, or preserved unchanged when a moved real branch is authorized for disposal."},{name:"landed_sha",type:"string",required:!0,constraint:"The retained branch tip: fast-forwarded into the local base in an ordinary close, or proven already contained in the local base or its upstream before a moved real branch is authorized for disposal."},{name:"worktree_path",type:"string",required:!0,constraint:"The managed worktree path whose cleanup is deferred until its caller exits."},{name:"worktree_removed",type:"boolean",required:!0,constraint:"Always false for an active caller: its checkout remains intact rather than being removed beneath the node."},{name:"worktree_remove_error",type:"string",required:!0,constraint:"The named deferred-cleanup state and safe manual follow-up after the caller exits."},{name:"branch_deleted",type:"boolean",required:!0,constraint:"False while the deferred-cleanup checkout still has this branch checked out."},{name:"branch_delete_error",type:"string",required:!0,constraint:"The safe branch-cleanup follow-up after the checkout is removed."},{name:"base_checkout_stash",type:"string",required:!1,constraint:"Present when conflicting base-checkout changes were retained in a stash; names the exact stash SHA and command required to recover them."}],outputKind:"object",effects:["Rebases the worktree onto its recorded local base branch and fast-forwards that base onto it (never pushes to origin), marking the node-managed worktree closed with cleanup pending and leaving the active caller checkout and branch intact. When the recorded branch is gone because ordinary work moved this checkout onto a real branch, and that branch's content is already contained in the recorded base, closes by authorizing the checkout's later removal instead of landing \u2014 preserving that branch rather than deleting it."]},run:r(async()=>{const e=w();try{return{...await h().closeWorktree(e)}}catch(t){l(t)}},"run"),render:r(e=>{const t=String(e.branch??""),a=String(e.landed_sha??""),i=String(e.worktree_path??"");let o=`Managed worktree closed \u2014 ${t} at ${a} is retained.`;const n=[];return e.worktree_removed===!1?n.push(String(e.worktree_remove_error??`worktree checkout at ${i} could not be removed automatically.`)):o+=` Worktree removed at ${i}.`,e.branch_deleted===!1&&n.push(String(e.branch_delete_error??`local branch ${t} could not be deleted automatically.`)),typeof e.base_checkout_stash=="string"&&n.push(`Warning: ${e.base_checkout_stash}`),n.length>0?`${o} Note: ${n.join(" ")}`:o},"render")}),T=m({name:"worktree",description:"manage a node-owned git worktree \u2014 land it or explicitly abandon it",whenToUse:"you need to dispose of a managed checkout: close lands the current node\u2019s work onto its base; abandon removes any node\u2019s checkout while retaining its work on the branch",help:{name:"node worktree",summary:"manage a node-owned git worktree \u2014 land it, or explicitly abandon its checkout while retaining work",model:"Close merges work into its recorded base. Abandon removes the checkout without changing lifecycle state; it retains work on the branch and deletes only a clean zero-commit branch."},children:[k,b]});export{T as nodeWorktreeBranch};

package/dist/commands/node.js

@@ -1,29 +1 @@
-// `crtr node` — create, inspect, message, and manage canvas nodes.
-import { defineBranch } from '../core/command.js';
-import { nodeNew } from './node/create.js';
-import { nodeInspect, nodeFork } from './node/inspect.js';
-import { nodeLifecycle, nodeConfig, nodePromote, nodeYield } from './node/lifecycle.js';
-import { nodeMessage } from './node/message.js';
-import { nodeWaitBranch } from './node/wait.js';
-import { nodeSubscription } from './node/subscription.js';
-import { nodeBash } from './node/bash.js';
-import { pyramidSlash } from './node/pyramid.js';
-import { nodeWorktreeBranch } from './node-worktree.js';
-import { nodeOutcome } from './node/outcome.js';
-export function registerNode() {
-    return defineBranch({
-        name: 'node',
-        slash: pyramidSlash,
-        rootEntry: {
-            concept: 'a unit of the agent runtime — an agent on the canvas with its own context dir and pi vehicle. Spawning nodes is how work gets done here, not an optimization you reach for late',
-            desc: 'spawn, inspect, and navigate nodes on the canvas',
-            useWhen: 'delegating a genuinely independent subtask, or walking the subscription graph. Base nodes work hands-on; orchestrators fan out. Give each child a bounded outcome distinct from your whole assignment so delegation moves work toward completion instead of recursively passing it down. Once delegated, do not duplicate the child’s work; its finish wakes you. Use the help surface for the exact node contract before invoking it.',
-        },
-        help: {
-            name: 'node',
-            summary: 'create, inspect, message, and change canvas nodes',
-            model: 'A node is one agent on the canvas. Immediate actions, durable waits, subscriptions, lifecycle changes, and scheduled crons are separate intent families; choose the family by when the effect happens and what persistent state it changes.',
-        },
-        children: [nodeNew, nodeFork, nodeMessage, nodeWaitBranch, nodeSubscription, nodeOutcome, nodeInspect, nodeLifecycle, nodeWorktreeBranch, nodeConfig, nodePromote, nodeYield, nodeBash],
-    });
-}
+var t=Object.defineProperty;var e=(o,n)=>t(o,"name",{value:n,configurable:!0});import{defineBranch as a}from"../core/command.js";import{nodeNew as i}from"./node/create.js";import{nodeInspect as r,nodeFork as s}from"./node/inspect.js";import{nodeLifecycle as d,nodeConfig as c,nodePromote as m,nodeYield as h}from"./node/lifecycle.js";import{nodeMessage as p}from"./node/message.js";import{nodeWaitBranch as f}from"./node/wait.js";import{nodeSubscription as l}from"./node/subscription.js";import{nodeBash as g}from"./node/bash.js";import{pyramidSlash as u}from"./node/pyramid.js";import{nodeWorktreeBranch as w}from"./node-worktree.js";import{nodeOutcome as y}from"./node/outcome.js";function C(){return a({name:"node",slash:u,rootEntry:{concept:"a unit of the agent runtime \u2014 an agent on the canvas with its own context dir and pi vehicle. Spawning nodes is how work gets done here, not an optimization you reach for late",desc:"spawn, inspect, and navigate nodes on the canvas",useWhen:"delegating a genuinely independent subtask, or walking the subscription graph. Base nodes work hands-on; orchestrators fan out. Give each child a bounded outcome distinct from your whole assignment so delegation moves work toward completion instead of recursively passing it down. Once delegated, do not duplicate the child\u2019s work; its finish wakes you. Use the help surface for the exact node contract before invoking it."},help:{name:"node",summary:"create, inspect, message, and change canvas nodes",model:"A node is one agent on the canvas. Immediate actions, durable waits, subscriptions, lifecycle changes, and scheduled crons are separate intent families; choose the family by when the effect happens and what persistent state it changes."},children:[i,s,p,f,l,y,r,d,w,c,m,h,g]})}e(C,"registerNode");export{C as registerNode};