@north-light/crouter 0.3.317 → 0.3.319

package/dist/commands/node/message.js

@@ -1,161 +1 @@
-// `crtr node message` — immediate inbox delivery and typed-output requests.
-import { envNodeId } from '../../shared/env.js';
-import { defineBranch, defineLeaf } from '../../core/command.js';
-import { InputError } from '../../core/io.js';
-import { OUTPUT_SCHEMA_CONSTRAINTS, OUTPUT_SCHEMA_TRANSPORT, parseOutputSchemaValue } from '../../core/runtime/structured-output.js';
-import { cliClient, getNodeOrNull, rethrowAsCliError } from '../api-client.js';
-function requireNonBlankDiscriminant(input, name) {
-    const value = input[name];
-    if (value !== undefined && (typeof value !== 'string' || value.trim() === '')) {
-        const flag = name.replace(/[A-Z]/g, (letter) => `-${letter.toLowerCase()}`);
-        throw new InputError({ error: 'empty_discriminant', message: `--${flag} must contain non-whitespace text`, received: typeof value === 'string' ? value : String(value), field: flag, next: `Pass a non-empty --${flag} value, or omit the flag.` });
-    }
-}
-async function resolveMsgTarget(input, hasBody) {
-    const to = input['to']?.trim();
-    const self = input['self'] === true;
-    const hasTo = to !== undefined && to !== '';
-    if (hasTo === self) {
-        throw new InputError({
-            error: 'bad_target',
-            message: hasTo && self ? '--to and --self are mutually exclusive' : hasBody ? 'no target given — the message body is not a node id' : 'exactly one of --to or --self is required',
-            field: hasTo ? undefined : 'to',
-            next: hasTo ? 'Pass --to <node-id> or --self.' : hasBody ? 'Pass the node id with --to <node-id> and provide the message body as a positional argument or on stdin, or use --self.' : 'Pass --to <node-id> or --self.',
-        });
-    }
-    if (self) {
-        const id = envNodeId();
-        if (id === undefined || id === '') {
-            throw new InputError({ error: 'no_node', message: 'no node to target with --self (CRTR_NODE_ID unset)', next: 'Run from inside a node, or pass --to <node-id>.' });
-        }
-        return { targetId: id, isSelf: true };
-    }
-    const exists = await getNodeOrNull(to);
-    if (exists === null) {
-        throw new InputError({ error: 'not_found', message: `no node: ${to}`, field: 'to', next: 'List nodes with `crtr node inspect list`.' });
-    }
-    return { targetId: to, isSelf: false };
-}
-function messageOutput() {
-    return [
-        { name: 'revived', type: 'boolean', required: false, constraint: 'True when this request synchronously revived the target; ordinary durable delivery to an active or idle dormant target queues lifecycle revival instead.' },
-        { name: 'guidance', type: 'string', required: true, constraint: 'Immediate action confirmation.' },
-    ];
-}
-function missingMessageTargetForBody(input) {
-    const to = input['to']?.trim();
-    if ((to !== undefined && to !== '') || input['self'] === true)
-        return undefined;
-    return {
-        message: 'no target given — the positional argument is the message body, not a node id',
-        field: 'to',
-        next: 'Pass the node id with --to <node-id> and pipe the message body on stdin, or use --self.',
-    };
-}
-function messageSendParams() {
-    return [
-        { kind: 'stdin', name: 'body', required: false, constraint: 'Visible message body. Required unless --situational-context is supplied.', positionalStdinConflict: missingMessageTargetForBody },
-        { kind: 'flag', name: 'to', type: 'string', required: false, constraint: 'Target an existing node by id. Exactly one of --to or --self is required.' },
-        { kind: 'flag', name: 'self', type: 'bool', required: false, constraint: 'Target the calling node. Exactly one of --to or --self is required.' },
-        { kind: 'flag', name: 'tier', type: 'enum', choices: ['critical', 'urgent', 'normal', 'deferred'], required: false, default: 'normal', constraint: 'Delivery urgency. Deferred never wakes an idle node, except a terminal one, which has no later cycle to read it on and is raised to urgent.' },
-        { kind: 'flag', name: 'situational-context', type: 'string', required: false, constraint: 'Non-empty hidden ambient context delivered beside the message, or alone.' },
-        { kind: 'flag', name: 'reopen', type: 'bool', required: false, constraint: 'Re-task the target: commits it resident and clears any finalization latch before delivery. Valid for live, parked, and finalized targets.' },
-    ];
-}
-function messageRequestParams() {
-    return [
-        { kind: 'stdin', name: 'body', required: false, constraint: 'Visible message body. The schema alone is a complete request.', positionalStdinConflict: missingMessageTargetForBody },
-        { kind: 'flag', name: 'to', type: 'string', required: false, constraint: 'Target an existing node by id. Exactly one of --to or --self is required.' },
-        { kind: 'flag', name: 'self', type: 'bool', required: false, constraint: 'Target the calling node. Exactly one of --to or --self is required.' },
-        { kind: 'flag', name: 'tier', type: 'enum', choices: ['critical', 'urgent', 'normal'], required: false, default: 'normal', constraint: 'Delivery urgency. Every accepted tier queues lifecycle revival for an active or idle dormant target because the request must be answered; deferred is rejected for that reason.' },
-        { kind: 'flag', name: 'output-schema', type: 'string', required: true, constraint: `JSON Schema the result must satisfy. ${OUTPUT_SCHEMA_TRANSPORT} The target answers with \`crtr push result\` (or declines with \`crtr push result --decline "<reason>" --code <token>\`), then keeps working. ${OUTPUT_SCHEMA_CONSTRAINTS}` },
-        { kind: 'flag', name: 'situational-context', type: 'string', required: false, constraint: 'Non-empty hidden ambient context delivered beside the message, or alone.' },
-        { kind: 'flag', name: 'reopen', type: 'bool', required: false, hidden: true, constraint: 'Clear a finalized target latch before delivery or fresh revive.' },
-    ];
-}
-async function runMessageEngine(input) {
-    const situationalContextSupplied = input['situationalContext'] !== undefined;
-    const situationalContextRaw = input['situationalContext']?.trim();
-    if (situationalContextSupplied && situationalContextRaw === '') {
-        throw new InputError({ error: 'empty_situational_context', message: '--situational-context must contain non-whitespace text', field: 'situational-context', next: 'Pass non-whitespace text, or omit --situational-context.' });
-    }
-    const bodyRaw = input['body'];
-    const body = bodyRaw !== undefined ? bodyRaw.trim() : undefined;
-    const hasBody = body !== undefined && body !== '';
-    const { targetId } = await resolveMsgTarget(input, hasBody);
-    const tierRaw = input['tier'];
-    const hasTier = tierRaw !== undefined && tierRaw !== '';
-    const outputSchemaParsed = parseOutputSchemaValue(input['outputSchema']);
-    const outputSchema = outputSchemaParsed !== null ? JSON.stringify(outputSchemaParsed) : null;
-    const hasSituational = situationalContextRaw !== undefined && situationalContextRaw !== '';
-    const reopen = input['reopen'] === true;
-    if (outputSchema !== null && tierRaw === 'deferred') {
-        throw new InputError({ error: 'output_schema_deferred_tier', message: '--output-schema cannot combine with --tier deferred because the target must answer', field: 'tier', next: 'Use normal, urgent, or critical tier, or drop --output-schema.' });
-    }
-    const senderFrom = envNodeId();
-    const client = cliClient();
-    if (!hasBody && !hasSituational && outputSchema === null) {
-        throw new InputError({ error: 'empty_body', message: 'a message body is required unless --output-schema or --situational-context is supplied', field: 'body', next: 'Pass the message on stdin, or supply one of the documented alternatives.' });
-    }
-    const tier = (hasTier ? tierRaw : 'normal');
-    const res = await client.sendMessage(targetId, {
-        body: body ?? '',
-        tier,
-        ...(reopen ? { reopen: true } : {}),
-        ...(hasSituational ? { situational_context: situationalContextRaw } : {}),
-        ...(outputSchema !== null ? { output_schema: outputSchema } : {}),
-        ...(senderFrom !== undefined ? { from: senderFrom } : {}),
-    }).catch(rethrowAsCliError);
-    const guidance = res.revived
-        ? 'Delivered — the dormant target was revived to receive it.'
-        : tier !== 'deferred'
-            ? 'Delivered.'
-            : res.delivered_tier === undefined
-                ? "Delivered — held for the target's next natural cycle; not revived."
-                : 'Delivered — the target is terminal and takes no later cycle, so it was raised to urgent rather than held.';
-    return { revived: res.revived, guidance };
-}
-const nodeMessageSend = defineLeaf({
-    name: 'send',
-    description: 'deliver an inbox message to an existing node immediately',
-    whenToUse: 'a target chosen with `--to <node-id>` or `--self` should have information or new direction now — steering a worker mid-task, handing over a finding it needs, correcting a wrong turn, or waking a dormant node with fresh work. The target reads it and decides what to do with it. Use `node message request` instead when you need an answer back in a shape you specify, and `node subscription add` when the target should keep receiving this node’s pushes rather than this one delivery',
-    help: {
-        name: 'node message send',
-        summary: 'deliver an inbox message to an existing node immediately',
-        params: messageSendParams(),
-        output: messageOutput(),
-        outputKind: 'object',
-        effects: ['Appends one inbox entry. Critical, urgent, and normal delivery queues lifecycle revival for an active or idle dormant target; deferred waits for its next natural cycle.', '--reopen commits the target resident and clears any finalization latch before delivery, allowing it to take a new mandate; it is valid for live, parked, and finalized targets. Without it, a finalized target rejects delivery before an inbox entry is appended or a revive is attempted.'],
-    },
-    run: (input) => runMessageEngine(input),
-    render: (r) => String(r['guidance']),
-});
-const nodeMessageRequest = defineLeaf({
-    name: 'request',
-    description: 'deliver an immediate typed-output request to an existing node',
-    whenToUse: 'a target chosen with `--to <node-id>` or `--self` must hand back one answer in a shape you fix — a choice among options, a structured extraction, a verdict your own logic will branch on — or must be held to answering at all before it goes quiet. Use `node message send` instead when prose in the target’s own judgment is enough, and `node new --output-schema` when no node holds the context yet and the work needs a fresh agent',
-    help: {
-        name: 'node message request',
-        summary: 'deliver an immediate typed-output request to an existing node',
-        params: messageRequestParams(),
-        output: messageOutput(),
-        outputKind: 'object',
-        effects: ['Installs the one-off output schema before appending the request.'],
-    },
-    run: (input) => {
-        requireNonBlankDiscriminant(input, 'outputSchema');
-        return runMessageEngine(input);
-    },
-    render: (r) => String(r['guidance']),
-});
-export const nodeMessage = defineBranch({
-    name: 'message',
-    description: 'deliver immediate inbox work to an existing node',
-    whenToUse: 'you need one immediate delivery: send ordinary information, or request one schema-constrained result',
-    help: {
-        name: 'node message',
-        summary: 'deliver one immediate inbox entry to an existing node',
-        model: 'Both children append one inbox entry to a node that already exists, targeted with `--to <node-id>` or `--self`, and may revive it if it is dormant. They differ in what the delivery obligates. An ordinary message obligates nothing: the target reads it and acts however it judges best. A request installs a one-off output schema and holds the target awake and owing until it answers; the answer is validated against the schema, written to the target’s result file, and pushed as an update report to the TARGET’S subscribers, so subscribe to it first if the answer has to reach you. Neither child creates that standing relationship — a durable delivery edge is `node subscription`, and work that needs a fresh agent is `node new`.',
-    },
-    children: [nodeMessageSend, nodeMessageRequest],
-});
+var S=Object.defineProperty;var i=(e,n)=>S(e,"name",{value:n,configurable:!0});import{envNodeId as p}from"../../shared/env.js";import{defineBranch as _,defineLeaf as y}from"../../core/command.js";import{InputError as o}from"../../core/io.js";import{OUTPUT_SCHEMA_CONSTRAINTS as C,OUTPUT_SCHEMA_TRANSPORT as R,parseOutputSchemaValue as N}from"../../core/runtime/structured-output.js";import{cliClient as P,getNodeOrNull as E,rethrowAsCliError as A}from"../api-client.js";function D(e,n){const t=e[n];if(t!==void 0&&(typeof t!="string"||t.trim()==="")){const r=n.replace(/[A-Z]/g,a=>`-${a.toLowerCase()}`);throw new o({error:"empty_discriminant",message:`--${r} must contain non-whitespace text`,received:typeof t=="string"?t:String(t),field:r,next:`Pass a non-empty --${r} value, or omit the flag.`})}}i(D,"requireNonBlankDiscriminant");async function O(e,n){const t=e.to?.trim(),r=e.self===!0,a=t!==void 0&&t!=="";if(a===r)throw new o({error:"bad_target",message:a&&r?"--to and --self are mutually exclusive":n?"no target given \u2014 the message body is not a node id":"exactly one of --to or --self is required",field:a?void 0:"to",next:a?"Pass --to <node-id> or --self.":n?"Pass the node id with --to <node-id> and provide the message body as a positional argument or on stdin, or use --self.":"Pass --to <node-id> or --self."});if(r){const s=p();if(s===void 0||s==="")throw new o({error:"no_node",message:"no node to target with --self (CRTR_NODE_ID unset)",next:"Run from inside a node, or pass --to <node-id>."});return{targetId:s,isSelf:!0}}if(await E(t)===null)throw new o({error:"not_found",message:`no node: ${t}`,field:"to",next:"List nodes with `crtr node inspect list`."});return{targetId:t,isSelf:!1}}i(O,"resolveMsgTarget");function w(){return[{name:"revived",type:"boolean",required:!1,constraint:"True when this request synchronously revived the target; ordinary durable delivery to an active or idle dormant target queues lifecycle revival instead."},{name:"guidance",type:"string",required:!0,constraint:"Immediate action confirmation."}]}i(w,"messageOutput");function v(e){const n=e.to?.trim();if(!(n!==void 0&&n!==""||e.self===!0))return{message:"no target given \u2014 the positional argument is the message body, not a node id",field:"to",next:"Pass the node id with --to <node-id> and pipe the message body on stdin, or use --self."}}i(v,"missingMessageTargetForBody");function U(){return[{kind:"stdin",name:"body",required:!1,constraint:"Visible message body. Required unless --situational-context is supplied.",positionalStdinConflict:v},{kind:"flag",name:"to",type:"string",required:!1,constraint:"Target an existing node by id. Exactly one of --to or --self is required."},{kind:"flag",name:"self",type:"bool",required:!1,constraint:"Target the calling node. Exactly one of --to or --self is required."},{kind:"flag",name:"tier",type:"enum",choices:["critical","urgent","normal","deferred"],required:!1,default:"normal",constraint:"Delivery urgency. Deferred never wakes an idle node, except a terminal one, which has no later cycle to read it on and is raised to urgent."},{kind:"flag",name:"situational-context",type:"string",required:!1,constraint:"Non-empty hidden ambient context delivered beside the message, or alone."},{kind:"flag",name:"reopen",type:"bool",required:!1,constraint:"Re-task the target: commits it resident and clears any finalization latch before delivery. Valid for live, parked, and finalized targets."}]}i(U,"messageSendParams");function I(){return[{kind:"stdin",name:"body",required:!1,constraint:"Visible message body. The schema alone is a complete request.",positionalStdinConflict:v},{kind:"flag",name:"to",type:"string",required:!1,constraint:"Target an existing node by id. Exactly one of --to or --self is required."},{kind:"flag",name:"self",type:"bool",required:!1,constraint:"Target the calling node. Exactly one of --to or --self is required."},{kind:"flag",name:"tier",type:"enum",choices:["critical","urgent","normal"],required:!1,default:"normal",constraint:"Delivery urgency. Every accepted tier queues lifecycle revival for an active or idle dormant target because the request must be answered; deferred is rejected for that reason."},{kind:"flag",name:"output-schema",type:"string",required:!0,constraint:`JSON Schema the result must satisfy. ${R} The target answers with \`crtr push result\` (or declines with \`crtr push result --decline "<reason>" --code <token>\`), then keeps working. ${C}`},{kind:"flag",name:"situational-context",type:"string",required:!1,constraint:"Non-empty hidden ambient context delivered beside the message, or alone."},{kind:"flag",name:"reopen",type:"bool",required:!1,hidden:!0,constraint:"Clear a finalized target latch before delivery or fresh revive."}]}i(I,"messageRequestParams");async function b(e){const n=e.situationalContext!==void 0,t=e.situationalContext?.trim();if(n&&t==="")throw new o({error:"empty_situational_context",message:"--situational-context must contain non-whitespace text",field:"situational-context",next:"Pass non-whitespace text, or omit --situational-context."});const r=e.body,a=r!==void 0?r.trim():void 0,u=a!==void 0&&a!=="",{targetId:s}=await O(e,u),d=e.tier,x=d!==void 0&&d!=="",m=N(e.outputSchema),l=m!==null?JSON.stringify(m):null,f=t!==void 0&&t!=="",q=e.reopen===!0;if(l!==null&&d==="deferred")throw new o({error:"output_schema_deferred_tier",message:"--output-schema cannot combine with --tier deferred because the target must answer",field:"tier",next:"Use normal, urgent, or critical tier, or drop --output-schema."});const h=p(),k=P();if(!u&&!f&&l===null)throw new o({error:"empty_body",message:"a message body is required unless --output-schema or --situational-context is supplied",field:"body",next:"Pass the message on stdin, or supply one of the documented alternatives."});const g=x?d:"normal",c=await k.sendMessage(s,{body:a??"",tier:g,...q?{reopen:!0}:{},...f?{situational_context:t}:{},...l!==null?{output_schema:l}:{},...h!==void 0?{from:h}:{}}).catch(A),T=c.revived?"Delivered \u2014 the dormant target was revived to receive it.":g!=="deferred"?"Delivered.":c.delivered_tier===void 0?"Delivered \u2014 held for the target's next natural cycle; not revived.":"Delivered \u2014 the target is terminal and takes no later cycle, so it was raised to urgent rather than held.";return{revived:c.revived,guidance:T}}i(b,"runMessageEngine");const M=y({name:"send",description:"deliver an inbox message to an existing node immediately",whenToUse:"a target chosen with `--to <node-id>` or `--self` should have information or new direction now \u2014 steering a worker mid-task, handing over a finding it needs, correcting a wrong turn, or waking a dormant node with fresh work. The target reads it and decides what to do with it. Use `node message request` instead when you need an answer back in a shape you specify, and `node subscription add` when the target should keep receiving this node\u2019s pushes rather than this one delivery",help:{name:"node message send",summary:"deliver an inbox message to an existing node immediately",params:U(),output:w(),outputKind:"object",effects:["Appends one inbox entry. Critical, urgent, and normal delivery queues lifecycle revival for an active or idle dormant target; deferred waits for its next natural cycle.","--reopen commits the target resident and clears any finalization latch before delivery, allowing it to take a new mandate; it is valid for live, parked, and finalized targets. Without it, a finalized target rejects delivery before an inbox entry is appended or a revive is attempted."]},run:i(e=>b(e),"run"),render:i(e=>String(e.guidance),"render")}),j=y({name:"request",description:"deliver an immediate typed-output request to an existing node",whenToUse:"a target chosen with `--to <node-id>` or `--self` must hand back one answer in a shape you fix \u2014 a choice among options, a structured extraction, a verdict your own logic will branch on \u2014 or must be held to answering at all before it goes quiet. Use `node message send` instead when prose in the target\u2019s own judgment is enough, and `node new --output-schema` when no node holds the context yet and the work needs a fresh agent",help:{name:"node message request",summary:"deliver an immediate typed-output request to an existing node",params:I(),output:w(),outputKind:"object",effects:["Installs the one-off output schema before appending the request."]},run:i(e=>(D(e,"outputSchema"),b(e)),"run"),render:i(e=>String(e.guidance),"render")}),H=_({name:"message",description:"deliver immediate inbox work to an existing node",whenToUse:"you need one immediate delivery: send ordinary information, or request one schema-constrained result",help:{name:"node message",summary:"deliver one immediate inbox entry to an existing node",model:"Both children append one inbox entry to a node that already exists, targeted with `--to <node-id>` or `--self`, and may revive it if it is dormant. They differ in what the delivery obligates. An ordinary message obligates nothing: the target reads it and acts however it judges best. A request installs a one-off output schema and holds the target awake and owing until it answers; the answer is validated against the schema, written to the target\u2019s result file, and pushed as an update report to the TARGET\u2019S subscribers, so subscribe to it first if the answer has to reach you. Neither child creates that standing relationship \u2014 a durable delivery edge is `node subscription`, and work that needs a fresh agent is `node new`."},children:[M,j]});export{H as nodeMessage};

package/dist/commands/node/outcome.js

@@ -1,134 +1,4 @@
-// `crtr node outcome` — read a durable terminal outcome through crtrd only.
-import { isSafeNodeId } from '../../api/index.js';
-import { defineBranch, defineLeaf } from '../../core/command.js';
-import { InputError } from '../../core/io.js';
-import { cliClient, rethrowAsCliError } from '../api-client.js';
-function nodeId(input) {
-    const id = typeof input['node'] === 'string' ? input['node'].trim() : '';
-    if (!isSafeNodeId(id)) {
-        throw new InputError({
-            error: 'invalid_node',
-            message: `invalid node id: ${id === '' ? '(empty)' : id}`,
-            field: 'node',
-            next: 'Pass the exact node id returned when the node was created.',
-        });
-    }
-    return id;
-}
-function renderedJson(value) {
-    return value === null || value === undefined ? 'none' : JSON.stringify(value);
-}
-const nodeOutcomeRead = defineLeaf({
-    name: 'read',
-    description: 'read or briefly await a node’s durable terminal outcome',
-    whenToUse: 'an external caller needs the durable result or failure reason for one node, optionally blocking for its terminal outcome without consuming or claiming it',
-    help: {
-        name: 'node outcome read',
-        summary: 'read a node’s durable outcome, optionally awaiting it for up to 25 seconds',
-        params: [
-            { kind: 'positional', name: 'node', required: true, constraint: 'Node id whose durable outcome to read.' },
-            { kind: 'flag', name: 'wait', type: 'int', required: false, default: 0, constraint: 'Whole seconds to await settlement: 0–25. Omit or use 0 to return the current pending/settled state immediately.' },
-        ],
-        output: [
-            { name: 'node_id', type: 'string', required: true, constraint: 'The requested node id.' },
-            { name: 'state', type: 'string', required: true, constraint: '`pending` while the node has no terminal outcome, otherwise `settled`.' },
-            { name: 'outcome', type: 'object', required: true, constraint: 'The durable result/failure record when settled — kind/reason, revision, settled time, report basename/path, structured result, failure detail, and `declined` ({ reason, code, retryable } for a failure with reason `declined`, else null) — otherwise null.' },
-            { name: 'node_status', type: 'string', required: true, constraint: 'The node status observed with the outcome.' },
-            { name: 'deadline_at', type: 'string', required: true, constraint: 'The absolute spawn deadline, or null when unbounded.' },
-        ],
-        outputKind: 'object',
-        effects: ['Read-only: calls the daemon’s replay-safe GET outcome route. With --wait, the daemon polls the durable row for no more than 25 seconds.'],
-    },
-    run: async (input) => {
-        const id = nodeId(input);
-        const wait = input['wait'];
-        if (typeof wait !== 'number' || !Number.isInteger(wait) || wait < 0 || wait > 25) {
-            throw new InputError({
-                error: 'invalid_wait',
-                message: '--wait must be an integer between 0 and 25 seconds',
-                field: 'wait',
-                received: wait,
-                next: 'Pass a whole number from 0 through 25, or omit --wait to poll immediately.',
-            });
-        }
-        return { ...await cliClient().getNodeOutcome(id, { waitSeconds: wait }).catch(rethrowAsCliError) };
-    },
-    render: (result) => {
-        const outcome = result['outcome'];
-        if (outcome === null) {
-            return [
-                `<outcome state="pending" node_id="${result['node_id']}">`,
-                `- node status: ${result['node_status']}`,
-                `- deadline: ${result['deadline_at'] ?? 'none'}`,
-                '</outcome>',
-            ].join('\n');
-        }
-        return [
-            `<outcome kind="${outcome['kind']}" reason="${outcome['reason']}" state="settled" node_id="${result['node_id']}" revision="${outcome['revision']}">`,
-            `- final report: ${outcome['final_report'] ?? 'none'}`,
-            `- report path: ${outcome['final_report_path'] ?? 'none'}`,
-            `- structured result: ${renderedJson(outcome['structured_result'])}`,
-            `- declined: ${renderedJson(outcome['declined'])}`,
-            `- failure detail: ${renderedJson(outcome['detail'])}`,
-            `- settled at: ${outcome['settled_at']}`,
-            `- node status: ${result['node_status']}`,
-            `- deadline: ${result['deadline_at'] ?? 'none'}`,
-            '</outcome>',
-        ].join('\n');
-    },
-});
-export const nodeOutcomeDelivery = defineLeaf({
-    name: 'delivery',
-    description: 'inspect a node outcome-delivery registration',
-    whenToUse: 'you need the durable state of the local action target registered to receive a node’s outcome',
-    help: {
-        name: 'node outcome delivery',
-        summary: 'inspect the registered outcome-delivery target for one node',
-        params: [
-            { kind: 'positional', name: 'node', required: true, constraint: 'Node id whose outcome-delivery registration to inspect.' },
-        ],
-        output: [
-            { name: 'node_id', type: 'string', required: true, constraint: 'The node whose outcome is delivered.' },
-            { name: 'state', type: 'string', required: true, constraint: '`armed`, `pending`, `running`, `accepted`, or `permanent_failed`.' },
-            { name: 'action', type: 'string', required: true, constraint: 'The resolved configured action name.' },
-            { name: 'attempt', type: 'number', required: true, constraint: 'How many delivery attempts have been claimed.' },
-            { name: 'next_attempt_at', type: 'string', required: true, constraint: 'ISO-8601 time of the next retry, or null before a retry is scheduled (including while armed).' },
-            { name: 'accepted_at', type: 'string', required: true, constraint: 'When the target accepted the document, or null.' },
-            { name: 'permanent_failed_at', type: 'string', required: true, constraint: 'When the target permanently rejected the document, or null.' },
-            { name: 'last_failure', type: 'object', required: true, constraint: 'The most recent retryable or permanent delivery failure, or null.' },
-            { name: 'created_at', type: 'string', required: true, constraint: 'When this delivery registration was created.' },
-            { name: 'updated_at', type: 'string', required: true, constraint: 'When this delivery registration was last updated.' },
-        ],
-        outputKind: 'object',
-        effects: ['Read-only: calls the daemon outcome-delivery inspection route.'],
-    },
-    run: async (input) => {
-        const id = nodeId(input);
-        return { ...await cliClient().getOutcomeDelivery(id).catch(rethrowAsCliError) };
-    },
-    render: (result) => {
-        return [
-            `<outcome-delivery state="${result['state']}" node_id="${result['node_id']}">`,
-            `- attempt: ${result['attempt']}`,
-            `- next retry: ${result['next_attempt_at'] ?? 'none'}`,
-            `- last failure: ${renderedJson(result['last_failure'])}`,
-            `- action: ${result['action']}`,
-            `- accepted at: ${result['accepted_at'] ?? 'none'}`,
-            `- permanently failed at: ${result['permanent_failed_at'] ?? 'none'}`,
-            `- registered at: ${result['created_at']}`,
-            `- updated at: ${result['updated_at']}`,
-            '</outcome-delivery>',
-        ].join('\n');
-    },
-});
-export const nodeOutcome = defineBranch({
-    name: 'outcome',
-    description: 'read a node’s terminal outcome or its delivery state',
-    whenToUse: 'you need the durable terminal result/failure of one node, or the state of its registered outcome-delivery target',
-    help: {
-        name: 'node outcome',
-        summary: 'read one node’s durable terminal outcome or its delivery registration',
-        model: 'Outcome reads never consume the terminal record. Read returns the durable result or failure and can wait briefly for settlement; delivery inspects the separate action-registration attempt state.',
-    },
-    children: [nodeOutcomeRead, nodeOutcomeDelivery],
-});
+var l=Object.defineProperty;var n=(e,t)=>l(e,"name",{value:t,configurable:!0});import{isSafeNodeId as c}from"../../api/index.js";import{defineBranch as m,defineLeaf as a}from"../../core/command.js";import{InputError as i}from"../../core/io.js";import{cliClient as d,rethrowAsCliError as s}from"../api-client.js";function u(e){const t=typeof e.node=="string"?e.node.trim():"";if(!c(t))throw new i({error:"invalid_node",message:`invalid node id: ${t===""?"(empty)":t}`,field:"node",next:"Pass the exact node id returned when the node was created."});return t}n(u,"nodeId");function o(e){return e==null?"none":JSON.stringify(e)}n(o,"renderedJson");const p=a({name:"read",description:"read or briefly await a node\u2019s durable terminal outcome",whenToUse:"an external caller needs the durable result or failure reason for one node, optionally blocking for its terminal outcome without consuming or claiming it",help:{name:"node outcome read",summary:"read a node\u2019s durable outcome, optionally awaiting it for up to 25 seconds",params:[{kind:"positional",name:"node",required:!0,constraint:"Node id whose durable outcome to read."},{kind:"flag",name:"wait",type:"int",required:!1,default:0,constraint:"Whole seconds to await settlement: 0\u201325. Omit or use 0 to return the current pending/settled state immediately."}],output:[{name:"node_id",type:"string",required:!0,constraint:"The requested node id."},{name:"state",type:"string",required:!0,constraint:"`pending` while the node has no terminal outcome, otherwise `settled`."},{name:"outcome",type:"object",required:!0,constraint:"The durable result/failure record when settled \u2014 kind/reason, revision, settled time, report basename/path, structured result, failure detail, and `declined` ({ reason, code, retryable } for a failure with reason `declined`, else null) \u2014 otherwise null."},{name:"node_status",type:"string",required:!0,constraint:"The node status observed with the outcome."},{name:"deadline_at",type:"string",required:!0,constraint:"The absolute spawn deadline, or null when unbounded."}],outputKind:"object",effects:["Read-only: calls the daemon\u2019s replay-safe GET outcome route. With --wait, the daemon polls the durable row for no more than 25 seconds."]},run:n(async e=>{const t=u(e),r=e.wait;if(typeof r!="number"||!Number.isInteger(r)||r<0||r>25)throw new i({error:"invalid_wait",message:"--wait must be an integer between 0 and 25 seconds",field:"wait",received:r,next:"Pass a whole number from 0 through 25, or omit --wait to poll immediately."});return{...await d().getNodeOutcome(t,{waitSeconds:r}).catch(s)}},"run"),render:n(e=>{const t=e.outcome;return t===null?[`<outcome state="pending" node_id="${e.node_id}">`,`- node status: ${e.node_status}`,`- deadline: ${e.deadline_at??"none"}`,"</outcome>"].join(`
+`):[`<outcome kind="${t.kind}" reason="${t.reason}" state="settled" node_id="${e.node_id}" revision="${t.revision}">`,`- final report: ${t.final_report??"none"}`,`- report path: ${t.final_report_path??"none"}`,`- structured result: ${o(t.structured_result)}`,`- declined: ${o(t.declined)}`,`- failure detail: ${o(t.detail)}`,`- settled at: ${t.settled_at}`,`- node status: ${e.node_status}`,`- deadline: ${e.deadline_at??"none"}`,"</outcome>"].join(`
+`)},"render")}),h=a({name:"delivery",description:"inspect a node outcome-delivery registration",whenToUse:"you need the durable state of the local action target registered to receive a node\u2019s outcome",help:{name:"node outcome delivery",summary:"inspect the registered outcome-delivery target for one node",params:[{kind:"positional",name:"node",required:!0,constraint:"Node id whose outcome-delivery registration to inspect."}],output:[{name:"node_id",type:"string",required:!0,constraint:"The node whose outcome is delivered."},{name:"state",type:"string",required:!0,constraint:"`armed`, `pending`, `running`, `accepted`, or `permanent_failed`."},{name:"action",type:"string",required:!0,constraint:"The resolved configured action name."},{name:"attempt",type:"number",required:!0,constraint:"How many delivery attempts have been claimed."},{name:"next_attempt_at",type:"string",required:!0,constraint:"ISO-8601 time of the next retry, or null before a retry is scheduled (including while armed)."},{name:"accepted_at",type:"string",required:!0,constraint:"When the target accepted the document, or null."},{name:"permanent_failed_at",type:"string",required:!0,constraint:"When the target permanently rejected the document, or null."},{name:"last_failure",type:"object",required:!0,constraint:"The most recent retryable or permanent delivery failure, or null."},{name:"created_at",type:"string",required:!0,constraint:"When this delivery registration was created."},{name:"updated_at",type:"string",required:!0,constraint:"When this delivery registration was last updated."}],outputKind:"object",effects:["Read-only: calls the daemon outcome-delivery inspection route."]},run:n(async e=>{const t=u(e);return{...await d().getOutcomeDelivery(t).catch(s)}},"run"),render:n(e=>[`<outcome-delivery state="${e.state}" node_id="${e.node_id}">`,`- attempt: ${e.attempt}`,`- next retry: ${e.next_attempt_at??"none"}`,`- last failure: ${o(e.last_failure)}`,`- action: ${e.action}`,`- accepted at: ${e.accepted_at??"none"}`,`- permanently failed at: ${e.permanent_failed_at??"none"}`,`- registered at: ${e.created_at}`,`- updated at: ${e.updated_at}`,"</outcome-delivery>"].join(`
+`),"render")}),b=m({name:"outcome",description:"read a node\u2019s terminal outcome or its delivery state",whenToUse:"you need the durable terminal result/failure of one node, or the state of its registered outcome-delivery target",help:{name:"node outcome",summary:"read one node\u2019s durable terminal outcome or its delivery registration",model:"Outcome reads never consume the terminal record. Read returns the durable result or failure and can wait briefly for settlement; delivery inspects the separate action-registration attempt state."},children:[p,h]});export{b as nodeOutcome,h as nodeOutcomeDelivery};

package/dist/commands/node/pyramid.js

@@ -1,79 +1,2 @@
-// The node-subtree slash command is provisioned with the node family.
-export const pyramidSlash = {
-    name: 'pyramid',
-    description: 'Explain a topic as a live-building Minto pyramid diagram, backed by parallel explore agents.',
-    argumentHint: '<topic to explain>',
-    body: [
-        '# Pyramid explanation',
-        '',
-        'Explain **$ARGUMENTS** as a *pyramid*: lead with the answer, support it with a few key pillars, ground each pillar in evidence. You build this as a LIVE termrender diagram that fills in as parallel research lands — the user watches the skeleton grow into a complete picture.',
-        '',
-        '## The pyramid (Minto principle)',
-        '- **Apex** — ONE crisp sentence: the single governing answer/claim, the thing worth remembering.',
-        '- **Pillars** — 2–4 MECE supporting arguments that together prove the apex.',
-        '- **Base** — concrete evidence under each pillar (mechanisms, `file:line` refs, numbers, sources).',
-        '',
-        'Top-down: the reader gets the conclusion first, then descends for as much support as they want.',
-        '',
-        '## Workflow',
-        '',
-        '1. **Frame it.** Restate the topic in one line and commit to a *working* apex hypothesis (you will sharpen it). Name the 2–4 pillars you expect to need.',
-        '',
-        '2. **Scaffold the live diagram FIRST.** Write the termrender skeleton below to `./pyramid-<slug>.md` (apex = your hypothesis, pillars = titles, every base entry marked `[?]` pending). Then open it live so the user watches it build:',
-        '   ```bash',
-        '   termrender pane open ./pyramid-<slug>.md --watch   # detached tmux side-pane; re-renders on every save',
-        '   ```',
-        '   Not in tmux? Tell the user to run `termrender doc watch ./pyramid-<slug>.md` in another terminal, then continue regardless.',
-        '',
-        '3. **Investigate in parallel — do not block.** Fan out ONE explore agent per pillar/unknown AND dig into what you can answer yourself, concurrently:',
-        '   ```bash',
-        '   crtr node new "Investigate: <focused question for this pillar>. Report findings with sources / file:line refs." --kind explore',
-        '   ```',
-        '   You auto-subscribe; each finish wakes you. Never poll or wait — kick them all off, then start filling in what you already know.',
-        '',
-        '4. **Live-update as findings land.** Every time you learn something — your own digging or an explore report — EDIT the diagram file: flip a `[?]` to `[x]` (or `[!]` for a caveat/risk), add evidence under the right pillar, sharpen or rewrite the apex, drop a pillar that did not hold. Each save re-renders the pane. The diagram visibly grows skeleton → complete.',
-        '',
-        '5. **Land it.** When the apex is one crisp sentence, the pillars are MECE, and the base is concrete, do a final pass for accuracy, then give the user a 3–4 sentence spoken summary that mirrors apex → pillars. Tell them the diagram file path.',
-        '',
-        '## termrender skeleton (write this verbatim, then keep editing it)',
-        '',
-        'Apex panel on top, a divider, then the pillars as a row of boxes below — a literal pyramid: 1 claim over N supports.',
-        '```markdown',
-        ':::panel{title="<TOPIC>" color="cyan"}',
-        '**<one-line apex answer — your governing claim>**',
-        ':::',
-        '',
-        ':::divider{label="why"}',
-        ':::',
-        '',
-        '::::::columns',
-        ':::::col{width="33%"}',
-        '::::panel{title="Pillar 1 — <claim>" color="green"}',
-        ':::tree',
-        'evidence A [x]',
-        'evidence B [?]',
-        ':::',
-        '::::',
-        ':::::',
-        ':::::col{width="33%"}',
-        '::::panel{title="Pillar 2 — <claim>" color="green"}',
-        ':::tree',
-        'evidence C [?]',
-        ':::',
-        '::::',
-        ':::::',
-        ':::::col{width="34%"}',
-        '::::panel{title="Pillar 3 — <claim>" color="green"}',
-        ':::tree',
-        'evidence D [?]',
-        ':::',
-        '::::',
-        ':::::',
-        '::::::',
-        '```',
-        '',
-        '**Nesting rule (termrender will reject the file otherwise): an OUTER directive needs strictly MORE colons than the directive nested inside it.** Hence `::::::columns` (6) wraps `:::::col` (5) wraps `::::panel` (4) wraps `:::tree` (3). Every block closes with a bare run of its OWN colon count on its own line. Run `termrender doc check ./pyramid-<slug>.md` after each edit — if it errors, fix the colon counts before re-saving.',
-        '',
-        'Markers inside a tree: `[x]` → ✔ confirmed, `[!]` → ⚠ caveat/risk; `[?]` is not a marker and stays literal — use it for still-pending. Write structure only — termrender draws every box, border, and guide line; never hand-draw ASCII. Keep the apex to one sentence; push all detail into the base.',
-    ].join('\n'),
-};
+const e={name:"pyramid",description:"Explain a topic as a live-building Minto pyramid diagram, backed by parallel explore agents.",argumentHint:"<topic to explain>",body:["# Pyramid explanation","","Explain **$ARGUMENTS** as a *pyramid*: lead with the answer, support it with a few key pillars, ground each pillar in evidence. You build this as a LIVE termrender diagram that fills in as parallel research lands \u2014 the user watches the skeleton grow into a complete picture.","","## The pyramid (Minto principle)","- **Apex** \u2014 ONE crisp sentence: the single governing answer/claim, the thing worth remembering.","- **Pillars** \u2014 2\u20134 MECE supporting arguments that together prove the apex.","- **Base** \u2014 concrete evidence under each pillar (mechanisms, `file:line` refs, numbers, sources).","","Top-down: the reader gets the conclusion first, then descends for as much support as they want.","","## Workflow","","1. **Frame it.** Restate the topic in one line and commit to a *working* apex hypothesis (you will sharpen it). Name the 2\u20134 pillars you expect to need.","","2. **Scaffold the live diagram FIRST.** Write the termrender skeleton below to `./pyramid-<slug>.md` (apex = your hypothesis, pillars = titles, every base entry marked `[?]` pending). Then open it live so the user watches it build:","   ```bash","   termrender pane open ./pyramid-<slug>.md --watch   # detached tmux side-pane; re-renders on every save","   ```","   Not in tmux? Tell the user to run `termrender doc watch ./pyramid-<slug>.md` in another terminal, then continue regardless.","","3. **Investigate in parallel \u2014 do not block.** Fan out ONE explore agent per pillar/unknown AND dig into what you can answer yourself, concurrently:","   ```bash",'   crtr node new "Investigate: <focused question for this pillar>. Report findings with sources / file:line refs." --kind explore',"   ```","   You auto-subscribe; each finish wakes you. Never poll or wait \u2014 kick them all off, then start filling in what you already know.","","4. **Live-update as findings land.** Every time you learn something \u2014 your own digging or an explore report \u2014 EDIT the diagram file: flip a `[?]` to `[x]` (or `[!]` for a caveat/risk), add evidence under the right pillar, sharpen or rewrite the apex, drop a pillar that did not hold. Each save re-renders the pane. The diagram visibly grows skeleton \u2192 complete.","","5. **Land it.** When the apex is one crisp sentence, the pillars are MECE, and the base is concrete, do a final pass for accuracy, then give the user a 3\u20134 sentence spoken summary that mirrors apex \u2192 pillars. Tell them the diagram file path.","","## termrender skeleton (write this verbatim, then keep editing it)","","Apex panel on top, a divider, then the pillars as a row of boxes below \u2014 a literal pyramid: 1 claim over N supports.","```markdown",':::panel{title="<TOPIC>" color="cyan"}',"**<one-line apex answer \u2014 your governing claim>**",":::","",':::divider{label="why"}',":::","","::::::columns",':::::col{width="33%"}','::::panel{title="Pillar 1 \u2014 <claim>" color="green"}',":::tree","evidence A [x]","evidence B [?]",":::","::::",":::::",':::::col{width="33%"}','::::panel{title="Pillar 2 \u2014 <claim>" color="green"}',":::tree","evidence C [?]",":::","::::",":::::",':::::col{width="34%"}','::::panel{title="Pillar 3 \u2014 <claim>" color="green"}',":::tree","evidence D [?]",":::","::::",":::::","::::::","```","","**Nesting rule (termrender will reject the file otherwise): an OUTER directive needs strictly MORE colons than the directive nested inside it.** Hence `::::::columns` (6) wraps `:::::col` (5) wraps `::::panel` (4) wraps `:::tree` (3). Every block closes with a bare run of its OWN colon count on its own line. Run `termrender doc check ./pyramid-<slug>.md` after each edit \u2014 if it errors, fix the colon counts before re-saving.","","Markers inside a tree: `[x]` \u2192 \u2714 confirmed, `[!]` \u2192 \u26A0 caveat/risk; `[?]` is not a marker and stays literal \u2014 use it for still-pending. Write structure only \u2014 termrender draws every box, border, and guide line; never hand-draw ASCII. Keep the apex to one sentence; push all detail into the base."].join(`
+`)};export{e as pyramidSlash};

package/dist/commands/node/subscription.js

@@ -1,78 +1 @@
-// `crtr node subscription` — push-delivery edge controls.
-import { envNodeId } from '../../shared/env.js';
-import { defineBranch, defineLeaf } from '../../core/command.js';
-import { InputError } from '../../core/io.js';
-import { cliClient, rethrowAsCliError } from '../api-client.js';
-function resolveSubscriber(input) {
-    const sub = input['subscriber'] ?? envNodeId();
-    if (sub === undefined || sub === '') {
-        throw new InputError({ error: 'no_subscriber', message: 'no subscriber (set CRTR_NODE_ID or pass --subscriber)', field: 'subscriber', next: 'Run from inside a node, or pass --subscriber <id>.' });
-    }
-    return sub;
-}
-const nodeSubscribe = defineLeaf({
-    name: 'add',
-    description: 'wire a subscribes_to edge between any pair (active or --passive)',
-    whenToUse: 'you want to make one node receive another node’s pushes, actively or passively. Managed-child creation already adds its active edge; use this for other subscriber-to-publisher pairs',
-    help: {
-        name: 'node subscription add',
-        summary: 'wire a subscribes_to edge so one node receives another\'s pushes — the subscriber can be you (default) or, with --subscriber, ANY node, to ANY publisher. Re-running flips an existing edge\'s active/passive mode.',
-        params: [
-            { kind: 'positional', name: 'publisher', required: true, constraint: 'The node to subscribe TO — whose pushes get delivered to the subscriber.' },
-            { kind: 'flag', name: 'subscriber', type: 'string', required: false, constraint: 'Who receives the pushes. Defaults to the calling node (CRTR_NODE_ID). Pass any node id to wire a third party.' },
-            { kind: 'flag', name: 'passive', type: 'bool', required: false, constraint: 'Passive subscription: pushes ACCUMULATE without waking the subscriber, then auto-inject as timestamped XML pre-text on its next message. Omit for an active (wake-on-push) subscription.' },
-        ],
-        output: [],
-        outputKind: 'object',
-        effects: ['Upserts a subscribes_to edge in canvas.db (active flag set from --passive).', 'Passive edges never wake the subscriber and do not hold it alive (excluded from the stop-guard).'],
-    },
-    run: async (input) => {
-        const publisher = input['publisher'];
-        const subscriber = resolveSubscriber(input);
-        const passive = input['passive'] === true;
-        if (subscriber === publisher) {
-            throw new InputError({ error: 'self_subscribe', message: 'a node cannot subscribe to itself', next: 'Pick a different publisher.' });
-        }
-        await cliClient()
-            .subscribe(subscriber, { target: publisher, active: !passive })
-            .catch((err) => rethrowAsCliError(err));
-        return {};
-    },
-    render: () => 'Subscription added.'
-});
-const nodeUnsubscribe = defineLeaf({
-    name: 'remove',
-    description: 'drop a subscribes_to edge',
-    whenToUse: 'you want to stop one node receiving a publisher’s pushes; removal is idempotent',
-    help: {
-        name: 'node subscription remove',
-        summary: 'drop a subscribes_to edge — the subscriber (you by default, or any node via --subscriber) stops receiving the publisher\'s pushes.',
-        params: [
-            { kind: 'positional', name: 'publisher', required: true, constraint: 'The node to stop subscribing to.' },
-            { kind: 'flag', name: 'subscriber', type: 'string', required: false, constraint: 'Who to detach. Defaults to the calling node (CRTR_NODE_ID).' },
-        ],
-        output: [],
-        outputKind: 'object',
-        effects: ['Deletes the subscribes_to edge from canvas.db.'],
-    },
-    run: async (input) => {
-        const publisher = input['publisher'];
-        const subscriber = resolveSubscriber(input);
-        await cliClient()
-            .unsubscribe(subscriber, publisher)
-            .catch((err) => rethrowAsCliError(err));
-        return {};
-    },
-    render: () => 'Subscription removed.'
-});
-export const nodeSubscription = defineBranch({
-    name: 'subscription',
-    description: 'manage push-delivery edges between nodes',
-    whenToUse: 'you need an ongoing active or passive subscriber-to-publisher delivery edge that spawn did not create, or need to remove one',
-    help: {
-        name: 'node subscription',
-        summary: 'add or remove subscriber-to-publisher push-delivery edges',
-        model: 'Subscriptions point from a subscriber to a publisher and control future push delivery. Active edges wake on each push; passive edges accumulate pushes for the subscriber’s next turn. Removing either edge stops subsequent delivery without changing messages already received.',
-    },
-    children: [nodeSubscribe, nodeUnsubscribe],
-});
+var b=Object.defineProperty;var r=(e,s)=>b(e,"name",{value:s,configurable:!0});import{envNodeId as p}from"../../shared/env.js";import{defineBranch as h,defineLeaf as o}from"../../core/command.js";import{InputError as n}from"../../core/io.js";import{cliClient as a,rethrowAsCliError as u}from"../api-client.js";function c(e){const s=e.subscriber??p();if(s===void 0||s==="")throw new n({error:"no_subscriber",message:"no subscriber (set CRTR_NODE_ID or pass --subscriber)",field:"subscriber",next:"Run from inside a node, or pass --subscriber <id>."});return s}r(c,"resolveSubscriber");const l=o({name:"add",description:"wire a subscribes_to edge between any pair (active or --passive)",whenToUse:"you want to make one node receive another node\u2019s pushes, actively or passively. Managed-child creation already adds its active edge; use this for other subscriber-to-publisher pairs",help:{name:"node subscription add",summary:"wire a subscribes_to edge so one node receives another's pushes \u2014 the subscriber can be you (default) or, with --subscriber, ANY node, to ANY publisher. Re-running flips an existing edge's active/passive mode.",params:[{kind:"positional",name:"publisher",required:!0,constraint:"The node to subscribe TO \u2014 whose pushes get delivered to the subscriber."},{kind:"flag",name:"subscriber",type:"string",required:!1,constraint:"Who receives the pushes. Defaults to the calling node (CRTR_NODE_ID). Pass any node id to wire a third party."},{kind:"flag",name:"passive",type:"bool",required:!1,constraint:"Passive subscription: pushes ACCUMULATE without waking the subscriber, then auto-inject as timestamped XML pre-text on its next message. Omit for an active (wake-on-push) subscription."}],output:[],outputKind:"object",effects:["Upserts a subscribes_to edge in canvas.db (active flag set from --passive).","Passive edges never wake the subscriber and do not hold it alive (excluded from the stop-guard)."]},run:r(async e=>{const s=e.publisher,i=c(e),t=e.passive===!0;if(i===s)throw new n({error:"self_subscribe",message:"a node cannot subscribe to itself",next:"Pick a different publisher."});return await a().subscribe(i,{target:s,active:!t}).catch(d=>u(d)),{}},"run"),render:r(()=>"Subscription added.","render")}),m=o({name:"remove",description:"drop a subscribes_to edge",whenToUse:"you want to stop one node receiving a publisher\u2019s pushes; removal is idempotent",help:{name:"node subscription remove",summary:"drop a subscribes_to edge \u2014 the subscriber (you by default, or any node via --subscriber) stops receiving the publisher's pushes.",params:[{kind:"positional",name:"publisher",required:!0,constraint:"The node to stop subscribing to."},{kind:"flag",name:"subscriber",type:"string",required:!1,constraint:"Who to detach. Defaults to the calling node (CRTR_NODE_ID)."}],output:[],outputKind:"object",effects:["Deletes the subscribes_to edge from canvas.db."]},run:r(async e=>{const s=e.publisher,i=c(e);return await a().unsubscribe(i,s).catch(t=>u(t)),{}},"run"),render:r(()=>"Subscription removed.","render")}),_=h({name:"subscription",description:"manage push-delivery edges between nodes",whenToUse:"you need an ongoing active or passive subscriber-to-publisher delivery edge that spawn did not create, or need to remove one",help:{name:"node subscription",summary:"add or remove subscriber-to-publisher push-delivery edges",model:"Subscriptions point from a subscriber to a publisher and control future push delivery. Active edges wake on each push; passive edges accumulate pushes for the subscriber\u2019s next turn. Removing either edge stops subsequent delivery without changing messages already received."},children:[l,m]});export{_ as nodeSubscription};