@north-light/crouter 0.3.233 → 0.3.234

package/dist/clients/conversation/projection.js

@@ -164,12 +164,10 @@ export function applyToolGroupSummary(state, key, summary) {
 function roleOf(m) {
     return m.role ?? '';
 }
-// ---------------------------------------------------------------------------
 // `!` bash execution (broker bash_start/bash_output/bash_end frames). These are
 // broker control frames, NOT AgentSessionEvents, so the hook routes them here
 // explicitly. They build a synthetic `bashExecution` message in the transcript
 // that mirrors the one pi persists to context — rendered by MessageView.
-// ---------------------------------------------------------------------------
 /** Index of the most recent bashExecution message (the active `!` run), or null. */
 function lastBashIndex(state) {
     for (let i = state.messages.length - 1; i >= 0; i--) {

package/dist/clients/inbox/controller.js

@@ -66,7 +66,7 @@ export class InboxController {
             return;
         }
         if (this.adapter !== undefined && priorDir !== undefined) {
-            const canceled = readTicketResult(priorDir)?.kind === 'canceled';
+            const canceled = readTicketResultOrNull(priorDir)?.kind === 'canceled';
             if (canceled)
                 clearProgress(priorDir);
             // Suppress the "resolved elsewhere" banner when WE are the ones resolving
@@ -213,7 +213,7 @@ export class InboxController {
         }
         catch (error) {
             this.status = resolveFailureKind(error) === 'already_resolved'
-                ? canonicalResultStatus(readTicketResult(item.dir))
+                ? safeCanonicalResultStatus(item.dir)
                 : daemonErrorMessage(error);
         }
         finally {
@@ -352,7 +352,7 @@ export class InboxController {
                 return;
             }
             if (failure === 'already_resolved')
-                this.status = canonicalResultStatus(readTicketResult(claim.dir));
+                this.status = safeCanonicalResultStatus(claim.dir);
             this.leaveDetail(false);
             this.rescan();
             this.markDirty();
@@ -537,3 +537,22 @@ function canonicalResultStatus(result) {
         return 'ticket was already resolved: page submitted';
     return 'ticket was already canceled';
 }
+/** `readTicketResult` throws on a corrupt result file. In this long-lived TUI
+ *  process there is no top-level catch, so a corrupt file must surface as a
+ *  status line rather than crash the inbox. */
+function readTicketResultOrNull(dir) {
+    try {
+        return readTicketResult(dir);
+    }
+    catch {
+        return null;
+    }
+}
+function safeCanonicalResultStatus(dir) {
+    try {
+        return canonicalResultStatus(readTicketResult(dir));
+    }
+    catch (error) {
+        return `ticket result is unreadable: ${error instanceof Error ? error.message : String(error)}`;
+    }
+}

package/dist/clients/inbox/review/companion-pane.js

@@ -4,17 +4,13 @@
 // review knowledge beyond the ids it is handed.
 import { inTmux, liveViewerPanes, paneRunning, paneSize, splitWindow, paneExists, getPaneOption, closePane, } from '../../../core/runtime/placement-tmux.js';
 import { viewerEnv } from '../../../commands/surface/node/placement.js';
-// ---------------------------------------------------------------------------
 // Constants
-// ---------------------------------------------------------------------------
 export const SPLIT_MIN_COLS = 99;
 export const MIN_COMPANION_COLS = 40;
 export const MIN_COMPANION_ROWS = 12;
 export const COMPANION_WIDTH_RATIO = 0.42;
 export const COMPANION_HEIGHT_RATIO = 0.40;
-// ---------------------------------------------------------------------------
 // Pane lifecycle
-// ---------------------------------------------------------------------------
 /** Open or adopt a companion pane for a review. Adoption succeeds only when
  *  an existing validated-live companion viewer pane exists; otherwise, a
  *  fresh pane is split beside the caller. */

package/dist/clients/inbox/review-adapter.js

@@ -1,5 +1,4 @@
 import { basename } from 'node:path';
-import { ApiError } from '../../api/errors.js';
 import { openReviewWindow } from './review/launch.js';
 import { createReviewClient, ReviewTerminalError, terminalRefusalNotice } from './review/review-client.js';
 /** Resolve a durable review ticket and open it in its own tmux window. */
@@ -42,11 +41,5 @@ export class ReviewAdapter {
 function noticeForBridgeFailure(error) {
     if (error instanceof ReviewTerminalError)
         return terminalRefusalNotice(error);
-    if (isReviewPredatesSystem(error)) {
-        return 'This review predates canonical review records — cancel it and re-file the review.';
-    }
     return error instanceof Error ? error.message : String(error);
 }
-function isReviewPredatesSystem(error) {
-    return error instanceof ApiError && error.status === 409 && error.code === 'review_predates_system';
-}

package/dist/clients/inbox/tui/slots.d.ts

@@ -1,4 +1,4 @@
-import type { CommentAnchor, PageSlot, SlotResponse, TableConfig } from '../../../core/human/page-schema.js';
+import type { PageCommentAnchor, PageSlot, SlotResponse, TableConfig } from '../../../core/human/page-schema.js';
 import type { TuiState } from './types.js';
 export type SelectGroup = 'option' | 'card' | 'row' | 'column';
 export type ActionRow = {
@@ -28,6 +28,6 @@ export declare function tableMarkdown(config: TableConfig): string;
 export declare function responseAnswers(state: Pick<TuiState, 'manifest'>, slot: PageSlot, response: SlotResponse): boolean;
 export declare function slotAnswered(state: TuiState, slot: PageSlot): boolean;
 export declare function pageComplete(state: Pick<TuiState, 'manifest' | 'responses'>): boolean;
-export declare function commentIdFor(anchor: CommentAnchor): string;
+export declare function commentIdFor(anchor: PageCommentAnchor): string;
 /** The response-comment anchors this component may author: options take per-option, tables take rows only. */
-export declare function commentAnchors(slot: PageSlot): CommentAnchor[];
+export declare function commentAnchors(slot: PageSlot): PageCommentAnchor[];

package/dist/clients/inbox/tui/types.d.ts

@@ -1,12 +1,12 @@
 import type { Key } from './keys.js';
 import type { ProductPageComponents } from '../../../types.js';
-import type { CommentAnchor, PageManifest, PageResponses, PageSlot, SlotResponse } from '../../../core/human/page-schema.js';
+import type { PageCommentAnchor, PageManifest, PageResponses, PageSlot, SlotResponse } from '../../../core/human/page-schema.js';
 export type Phase = 'overview' | 'item-review' | 'final';
 export type InputMode = null | {
     kind: 'comment';
     buffer: string;
     cursor: number;
-    anchor: CommentAnchor;
+    anchor: PageCommentAnchor;
 } | {
     kind: 'freetext';
     buffer: string;

package/dist/commands/api-client.js

@@ -24,9 +24,7 @@ import { readState } from '../core/config.js';
 import { resolveRemoteCanvasTarget } from '../core/remote-canvas-target.js';
 import { RemoteCanvasSource } from '../core/canvas/remote-canvas-source.js';
 import { crtrHome } from '../core/canvas/paths.js';
-// ---------------------------------------------------------------------------
 // Error translation
-// ---------------------------------------------------------------------------
 /** Rethrow an `ApiError` as the clean structured CLI error agents parse
  *  (`core/io` `handle`) — instead of the generic "internal bug" stderr path a
  *  raw non-`CrtrError` throw would take. The mapping itself lives in ONE place
@@ -57,9 +55,7 @@ export async function getNodeOrNull(nodeId) {
         rethrowAsCliError(err);
     }
 }
-// ---------------------------------------------------------------------------
 // cliClient — the one place the CLI constructs a daemon client
-// ---------------------------------------------------------------------------
 /** Bounded tail of crtrd.err surfaced on a cold-start `/healthz` timeout.
  *  Large enough to catch a real startup failure/stack trace,
  *  small enough that a runaway daemon log can never leak unbounded into a CLI
@@ -133,9 +129,7 @@ export function cliClient(opts) {
         coldStartPollWindowMs: DAEMON_STARTUP_WINDOW_MS,
     });
 }
-// ---------------------------------------------------------------------------
 // ApiCanvasSource — a read CanvasSource backed entirely by the crtrd API
-// ---------------------------------------------------------------------------
 // NodeSummaryDTO now carries every NodeRow field and NodeDetailDTO extends it,
 // so the viewer adapter returns the daemon's typed projections directly. It
 // performs no lossy legacy reconstruction or invented local-presence values.
@@ -268,9 +262,7 @@ export class ApiCanvasSource {
         return false;
     }
 }
-// ---------------------------------------------------------------------------
 // cliCanvasSource — the source selector (mirrors resolveCanvasSource)
-// ---------------------------------------------------------------------------
 /** The active read source for a CLI command. Mirrors `resolveCanvasSource`'s
  *  selection WITHOUT importing `core/canvas/source.ts` (which pulls
  *  `LocalCanvasSource` → `openDb`, failing the Stage-C import checker): an

package/dist/commands/attention.js

@@ -13,9 +13,7 @@ import { cliClient, cliCanvasSource } from './api-client.js';
 async function viewNodeSet(source, viewId) {
     return new Set([viewId, ...(await source.view(viewId))]);
 }
-// ---------------------------------------------------------------------------
 // attention count
-// ---------------------------------------------------------------------------
 const attentionCount = defineLeaf({
     name: 'count',
     description: 'total pending human-ticket count (machine-parseable stdout.count)',
@@ -87,9 +85,7 @@ const attentionCount = defineLeaf({
         return { count: items.reduce((s, e) => s + e.count, 0) };
     },
 });
-// ---------------------------------------------------------------------------
 // attention list
-// ---------------------------------------------------------------------------
 const attentionList = defineLeaf({
     name: 'list',
     description: 'itemised list of cwds with pending human tickets',
@@ -137,9 +133,7 @@ const attentionList = defineLeaf({
         return { items, total };
     },
 });
-// ---------------------------------------------------------------------------
 // attention map
-// ---------------------------------------------------------------------------
 const attentionMap = defineLeaf({
     name: 'map',
     description: 'per-node ticket counts for a visible set, batched in one pass',
@@ -207,9 +201,7 @@ const attentionMap = defineLeaf({
         return { counts: counts.counts };
     },
 });
-// ---------------------------------------------------------------------------
 // Export — mounted under `crtr canvas`
-// ---------------------------------------------------------------------------
 export const attentionBranch = defineBranch({
     name: 'attention',
     description: 'count/list pending human tickets across the graph',

package/dist/commands/canvas-browse.js

@@ -5,6 +5,7 @@
 // `crtr surface node focus` (the ONLY sanctioned open — reviveNode, never `pi --session`).
 // Owns the screen, so it returns void and writes nothing to stdout itself.
 // Outside a TTY it prints the static forest and exits 0 (see runBrowse).
+import { envProfileId } from '../shared/env.js';
 import { defineLeaf } from '../core/command.js';
 import { runBrowse } from '../core/canvas/browse/app.js';
 import { ApiCanvasSource, cliClient } from './api-client.js';
@@ -50,7 +51,7 @@ export const browseLeaf = defineLeaf({
     run: async (input) => {
         const cwd = input['cwd'] ?? process.cwd();
         const profileId = input['profileId'] ??
-            process.env['CRTR_PROFILE_ID'] ??
+            envProfileId() ??
             getDefaultProfileId(cwd) ??
             undefined;
         const source = new ApiCanvasSource();

package/dist/commands/canvas-config.js

@@ -25,9 +25,7 @@ function maskedTarget(name, target, secrets) {
         ...(token !== undefined && token !== '' ? { fingerprint: fingerprint(token) } : {}),
     };
 }
-// ---------------------------------------------------------------------------
 // canvas config add
-// ---------------------------------------------------------------------------
 const canvasConfigAdd = defineLeaf({
     name: 'add',
     description: 'register a remote canvas target (preview endpoint + relay token)',
@@ -76,9 +74,7 @@ const canvasConfigAdd = defineLeaf({
     },
     render: () => 'Registered remote canvas target (token stored).',
 });
-// ---------------------------------------------------------------------------
 // canvas config list
-// ---------------------------------------------------------------------------
 const canvasConfigList = defineLeaf({
     name: 'list',
     description: 'list registered remote canvas targets',
@@ -112,9 +108,7 @@ const canvasConfigList = defineLeaf({
             .join('\n');
     },
 });
-// ---------------------------------------------------------------------------
 // canvas config show
-// ---------------------------------------------------------------------------
 const canvasConfigShow = defineLeaf({
     name: 'show',
     description: 'show one registered remote canvas target',
@@ -150,9 +144,7 @@ const canvasConfigShow = defineLeaf({
     },
     render: (r) => `${r['name']} — ${r['previewEndpoint']} (${r['tokenStored'] ? `token ${r['fingerprint']}` : 'no token stored'})`,
 });
-// ---------------------------------------------------------------------------
 // canvas config remove
-// ---------------------------------------------------------------------------
 const canvasConfigRemove = defineLeaf({
     name: 'remove',
     description: 'remove a registered remote canvas target and its stored token',
@@ -186,9 +178,7 @@ const canvasConfigRemove = defineLeaf({
     },
     render: () => 'Removed remote canvas target.'
 });
-// ---------------------------------------------------------------------------
 // Export — mounted under `crtr canvas`
-// ---------------------------------------------------------------------------
 export const canvasConfigBranch = defineBranch({
     name: 'config',
     description: 'register/list/inspect/remove remote canvas targets',

package/dist/commands/canvas-history.js

@@ -5,6 +5,7 @@
 // memory`, which is curated semantic knowledge held independent of any episode.
 // This branch owns CONTENT; it never duplicates the graph (use `node lifecycle
 // revive` to reopen a found node, `node inspect show` for its topology).
+import { envNodeCwd } from '../shared/env.js';
 import { defineBranch } from '../core/command.js';
 import { searchLeaf } from './canvas-history/search.js';
 import { grepLeaf } from './canvas-history/grep.js';
@@ -13,7 +14,7 @@ import { readLeaf } from './canvas-history/read.js';
  *  anchor the help text without scanning nodes or files. Uses only the injected
  *  node cwd env (or the process cwd outside a node), so help stays cheap. */
 function corpusBlock() {
-    const cwd = process.env['CRTR_NODE_CWD'] ?? process.cwd();
+    const cwd = envNodeCwd() ?? process.cwd();
     return `<corpus cwd="${cwd}"/>`;
 }
 export const historyBranch = defineBranch({

package/dist/commands/cron.js

@@ -13,6 +13,7 @@
 // resolves the time grammar client-side (parseWhen/parseCadence) and sends the
 // settled fire_at/recur/tz through
 // the crtrd API; this file reaches ZERO canvas state-store code (V-1).
+import { envNodeId, envProfileId } from '../shared/env.js';
 import { existsSync, statSync } from 'node:fs';
 import { resolve as resolvePath } from 'node:path';
 import { defineBranch, defineLeaf } from '../core/command.js';
@@ -67,7 +68,7 @@ function parseRunTimeout(raw) {
  *  canvas-home-wide. Outside a profile there is no scope to narrow to, so the
  *  caller sees the whole canvas home. */
 function scopeQuery() {
-    const p = process.env['CRTR_PROFILE_ID'];
+    const p = envProfileId();
     return p !== undefined && p.trim() !== '' ? { profile: canonicalProfileId(p) } : undefined;
 }
 /** Resolve the chosen-else-inherited cwd, and refuse one that is not a
@@ -120,9 +121,7 @@ function renderRun(r) {
     const dur = r.duration_ms !== null ? `${r.duration_ms}ms` : '—';
     return `- ${r.started} — ${exit}, ${dur} — ${r.delivered ?? '(no disposition recorded)'}`;
 }
-// ---------------------------------------------------------------------------
 // cron add
-// ---------------------------------------------------------------------------
 const addLeaf = defineLeaf({
     name: 'add',
     description: 'arm a scheduled command (bash on stdin; one of --at / --every)',
@@ -216,7 +215,7 @@ const addLeaf = defineLeaf({
         }
         let anchorNode = anchorFlag ?? null;
         if (anchorSelf) {
-            const self = process.env['CRTR_NODE_ID'];
+            const self = envNodeId();
             if (self === undefined || self === '') {
                 throw new InputError({ error: 'no_self_node', message: '--anchor-self requires a calling node ($CRTR_NODE_ID is unset)', next: 'Run from inside a node, or pass --anchor <node-id> explicitly.' });
             }
@@ -232,7 +231,7 @@ const addLeaf = defineLeaf({
         const cwd = resolveCwd(typeof input['cwd'] === 'string' && input['cwd'] !== '' ? input['cwd'] : undefined);
         const envJson = resolveEnvJson(input['env']);
         const profileFlag = typeof input['profile'] === 'string' && input['profile'] !== '' ? input['profile'] : undefined;
-        const inherited = process.env['CRTR_PROFILE_ID'];
+        const inherited = envProfileId();
         const profile = profileFlag !== undefined
             ? canonicalProfileId(profileFlag)
             : inherited !== undefined && inherited.trim() !== ''
@@ -243,7 +242,7 @@ const addLeaf = defineLeaf({
         if (scope === 'profile' && profile === undefined) {
             throw new InputError({ error: 'scope_needs_profile', message: '--scope profile names the profile this cron lists and cancels within, but no profile is resolved', field: 'profile', next: 'Pass --profile <id>, or use --scope global for a canvas-home-wide cron.' });
         }
-        const createdBy = process.env['CRTR_NODE_ID'];
+        const createdBy = envNodeId();
         const dto = await cliClient()
             .armCron({
             name,
@@ -274,9 +273,7 @@ const addLeaf = defineLeaf({
         return `Cron armed — ${String(r['cron_id'])}.\n\n- next fire: ${String(r['fire_at'])}\n- cadence: ${cadence}\n\nIt runs daemon-side; nothing more to do here. Inspect it with \`crtr cron show ${String(r['cron_id'])}\`; cancel any time with \`crtr cron cancel ${String(r['cron_id'])}\`.`;
     },
 });
-// ---------------------------------------------------------------------------
 // cron list
-// ---------------------------------------------------------------------------
 const listLeaf = defineLeaf({
     name: 'list',
     description: 'what is scheduled, with next fire and recent health',
@@ -336,9 +333,7 @@ const listLeaf = defineLeaf({
         return `${crons.length} cron(s):\n\n${lines.join('\n')}`;
     },
 });
-// ---------------------------------------------------------------------------
 // cron show
-// ---------------------------------------------------------------------------
 const showLeaf = defineLeaf({
     name: 'show',
     description: 'one cron: full config plus its run history',
@@ -396,9 +391,7 @@ const showLeaf = defineLeaf({
         return lines.join('\n');
     },
 });
-// ---------------------------------------------------------------------------
 // cron run
-// ---------------------------------------------------------------------------
 const runLeaf = defineLeaf({
     name: 'run',
     description: 'execute now, out of band — does not advance the schedule',
@@ -446,9 +439,7 @@ const runLeaf = defineLeaf({
         return lines.join('\n');
     },
 });
-// ---------------------------------------------------------------------------
 // cron pause / resume
-// ---------------------------------------------------------------------------
 const pauseLeaf = defineLeaf({
     name: 'pause',
     description: 'stop firing without losing config or history',
@@ -493,9 +484,7 @@ const resumeLeaf = defineLeaf({
     },
     render: (r) => `Cron resumed — next fire ${String(r['fire_at'])} (if that is already past, it fires on the next tick).`,
 });
-// ---------------------------------------------------------------------------
 // cron cancel
-// ---------------------------------------------------------------------------
 const cancelLeaf = defineLeaf({
     name: 'cancel',
     description: 'remove one cron (idempotent)',
@@ -523,9 +512,7 @@ const cancelLeaf = defineLeaf({
     },
     render: () => 'Cron canceled.'
 });
-// ---------------------------------------------------------------------------
 // Registration
-// ---------------------------------------------------------------------------
 export function registerCron() {
     return defineBranch({
         name: 'cron',

package/dist/commands/dashboard.js

@@ -9,9 +9,7 @@ import { defineLeaf } from '../core/command.js';
 import { InputError } from '../core/io.js';
 import { cliClient, cliCanvasSource } from './api-client.js';
 import { renderTreeFromSource, renderForestFromSource, dashboardRowsFromSource, dashboardRowsAllFromSource, enrichRowsFromSource, } from '../core/canvas/render-source.js';
-// ---------------------------------------------------------------------------
 // dashboard show — the main leaf
-// ---------------------------------------------------------------------------
 export const dashboardLeaf = defineLeaf({
     name: 'dashboard',
     description: 'render the canvas as a subscription tree',

package/dist/commands/human/feedback.js

@@ -3,6 +3,7 @@
 // the companion's terminal report that an open item has been dealt with.
 // Creating comments is the person's channel (the page surface); no agent
 // authors, edits, or deletes them.
+import { envNodeId } from '../../shared/env.js';
 import { existsSync } from 'node:fs';
 import { ApiError } from '../../api/index.js';
 import { defineBranch, defineLeaf } from '../../core/command.js';
@@ -71,7 +72,7 @@ const humanFeedbackResolve = defineLeaf({
     },
     run: async (input) => {
         const commentId = input['comment_id'];
-        const callerNodeId = process.env['CRTR_NODE_ID'];
+        const callerNodeId = envNodeId();
         if (callerNodeId === undefined || callerNodeId === '') {
             throw new InputError({ error: 'no_node', message: 'resolve runs inside the ticket\u2019s feedback companion (CRTR_NODE_ID unset)', next: 'Run this from the companion conversation bound to the ticket.' });
         }

package/dist/commands/human/prompts.js

@@ -1,3 +1,4 @@
+import { envNodeId } from '../../shared/env.js';
 import { defineLeaf } from '../../core/command.js';
 import { InputError } from '../../core/io.js';
 import { cliClient } from '../api-client.js';
@@ -21,7 +22,7 @@ import { pageHelpText, resolveMaxPanes } from './shared.js';
 const PAGE_HINT = pageHelpText().pageHint;
 /** The asking node's id, or null when run from a bare shell (no parent to route to). */
 function askingNode() {
-    return process.env['CRTR_NODE_ID'] ?? null;
+    return envNodeId() ?? null;
 }
 /** Provenance for crouter tickets. Ticket *identity* comes from the bridge node
  * directory, never ticket data; `nodeId` carries the originating node so a
@@ -159,9 +160,7 @@ function pageInput(input) {
 function queuedFollowUp() {
     return 'Queued for the user. Their answer is pushed to your inbox and wakes you when they respond — never poll, verify it opened, or block.';
 }
-// ---------------------------------------------------------------------------
 // send
-// ---------------------------------------------------------------------------
 export function humanSend(pageSurface = false) {
     const pageHelp = pageHelpText(pageSurface);
     return defineLeaf({
@@ -281,11 +280,9 @@ export function humanSend(pageSurface = false) {
         },
     });
 }
-// ---------------------------------------------------------------------------
 // show (no job, non-blocking passthrough) — passive live document display, NOT
 // a ticket surface. `display()` puts a file live in a watch pane and never
 // enqueues anything.
-// ---------------------------------------------------------------------------
 export const humanShow = defineLeaf({
     name: 'show',
     description: "put a file live on the user's screen",

package/dist/commands/human/queue.js

@@ -1,3 +1,4 @@
+import { envNodeId } from '../../shared/env.js';
 import { existsSync } from 'node:fs';
 import { ApiError } from '../../api/index.js';
 import { defineLeaf } from '../../core/command.js';
@@ -88,9 +89,7 @@ function isTerminalBridge(status) {
 function isAlreadyResolvedConflict(error) {
     return error instanceof ApiError && error.status === 409 && error.code === 'ticket_already_resolved';
 }
-// ---------------------------------------------------------------------------
 // list (read-only, paginated)
-// ---------------------------------------------------------------------------
 export const humanList = defineLeaf({
     name: 'list',
     description: 'enumerate pending interactions',
@@ -137,9 +136,7 @@ export const humanList = defineLeaf({
         return { items: page.items, next_cursor: page.next_cursor, total: page.total };
     },
 });
-// ---------------------------------------------------------------------------
 // resolve — non-interactive human answer
-// ---------------------------------------------------------------------------
 /** Decode the stdin envelope only; the daemon validates every response against the page manifest. */
 function parseResolveBody(raw) {
     let parsed;
@@ -201,9 +198,7 @@ export const humanResolve = defineLeaf({
         return { resolved: true, ticket_id: ticketId };
     },
 });
-// ---------------------------------------------------------------------------
 // cancel — retract a pending page/review
-// ---------------------------------------------------------------------------
 export const humanCancel = defineLeaf({
     name: 'cancel',
     description: 'retract a pending page/review',
@@ -229,7 +224,7 @@ export const humanCancel = defineLeaf({
     run: async (input) => {
         const ticketId = input['ticket_id'];
         const reason = input['reason'];
-        const actor = process.env['CRTR_NODE_ID'] ?? 'human';
+        const actor = envNodeId() ?? 'human';
         try {
             await cliClient().cancelHumanTicket(ticketId, { ...(reason !== undefined && reason !== '' ? { reason } : {}), actor });
         }

package/dist/commands/human/request.js

@@ -8,9 +8,7 @@ import { existsSync, readFileSync } from 'node:fs';
 import { defineBranch, defineLeaf } from '../../core/command.js';
 import { InputError } from '../../core/io.js';
 import { cliClient, rethrowAsCliError } from '../api-client.js';
-// ---------------------------------------------------------------------------
 // shared input helpers
-// ---------------------------------------------------------------------------
 function readJsonFile(path, field, shape) {
     if (!existsSync(path)) {
         throw new InputError({ error: 'not_found', message: `no such file: ${path}`, field, next: `Pass --${field} PATH pointing at a JSON file holding ${shape}.` });
@@ -88,9 +86,7 @@ const RECORD_OUTPUT = [
     { name: 'request_id', type: 'string', required: true, constraint: 'The request — the same 64-hex id the human inbox lists it under.' },
     ...REQUEST_RESULT_OUTPUT,
 ];
-// ---------------------------------------------------------------------------
 // create
-// ---------------------------------------------------------------------------
 const createLeaf = defineLeaf({
     name: 'create',
     description: 'create a durable request from a JSON request file',
@@ -135,9 +131,7 @@ const createLeaf = defineLeaf({
         }
     },
 });
-// ---------------------------------------------------------------------------
 // get
-// ---------------------------------------------------------------------------
 const getLeaf = defineLeaf({
     name: 'get',
     description: 'read one request, its terminal result, and its delivery state',
@@ -159,9 +153,7 @@ const getLeaf = defineLeaf({
         }
     },
 });
-// ---------------------------------------------------------------------------
 // replace
-// ---------------------------------------------------------------------------
 const replaceLeaf = defineLeaf({
     name: 'replace',
     description: 'revise a pending request\'s page in place',
@@ -192,9 +184,7 @@ const replaceLeaf = defineLeaf({
         }
     },
 });
-// ---------------------------------------------------------------------------
 // respond
-// ---------------------------------------------------------------------------
 const respondLeaf = defineLeaf({
     name: 'respond',
     description: 'settle a pending request with typed answers',
@@ -231,9 +221,7 @@ const respondLeaf = defineLeaf({
         }
     },
 });
-// ---------------------------------------------------------------------------
 // cancel
-// ---------------------------------------------------------------------------
 const cancelLeaf = defineLeaf({
     name: 'cancel',
     description: 'withdraw a pending request',
@@ -264,9 +252,7 @@ const cancelLeaf = defineLeaf({
         }
     },
 });
-// ---------------------------------------------------------------------------
 // Registration
-// ---------------------------------------------------------------------------
 export const humanRequestBranch = defineBranch({
     name: 'request',
     description: 'durable requests that outlive the process that made them',

package/dist/commands/human/review.js

@@ -1,3 +1,4 @@
+import { envNodeId } from '../../shared/env.js';
 import { randomUUID } from 'node:crypto';
 import { join, resolve } from 'node:path';
 import { defineBranch, defineLeaf } from '../../core/command.js';
@@ -5,7 +6,7 @@ import { InputError } from '../../core/io.js';
 import { ticketDir } from '../../core/human/root.js';
 import { cliClient } from '../api-client.js';
 function nodeActor() {
-    const nodeId = process.env['CRTR_NODE_ID'];
+    const nodeId = envNodeId();
     return nodeId === undefined || nodeId === '' ? null : nodeId;
 }
 function requireOriginNode() {

package/dist/commands/memory/__tests__/command-selector-and-mutation-guards.test.js

@@ -82,7 +82,7 @@ beforeEach(() => {
     mkdirSync(child, { recursive: true });
     mkdirSync(nestedWrite, { recursive: true });
     mkdirSync(nestedEmpty, { recursive: true });
-    // --- repository root, declaring the namespace for every nested store ---
+    // repository root, declaring the namespace for every nested store
     writeDoc(join(storeDir(root), 'INDEX.md'), 'kind: knowledge\nnamespace: acme\nwhen-and-why-to-read: "When the root acme store is addressed, this knowledge should be read because it names what the store holds."', 'ROOT STORE INDEX');
     writeDoc(join(storeDir(root), 'foo.md'), 'kind: knowledge', 'ROOT FOO BODY');
     writeDoc(join(storeDir(root), 'linker.md'), 'kind: knowledge', 'ROOT LINKER BODY linking [[acme/foo]] once.');
@@ -91,17 +91,17 @@ beforeEach(() => {
     // A `name:` pin on a file whose own path already derives a different identity.
     writeDoc(join(storeDir(root), 'x.md'), 'kind: knowledge\nname: y', 'ROOT PINNED BODY');
     appendHistoryRecord(join(storeDir(root), '.history', 'x.jsonl'), buildHistoryRecord({ op: 'create', before: '', after: 'ROOT PINNED BODY' }));
-    // --- child: a nested store deriving `acme/child`; cwd lives here ---
+    // child: a nested store deriving `acme/child`; cwd lives here
     writeDoc(join(storeDir(child), 'INDEX.md'), 'kind: knowledge\nwhen-and-why-to-read: "When the child guide is addressed, this knowledge should be read because it names what the nested store holds."', 'CHILD STORE INDEX');
     writeDoc(join(storeDir(child), 'foo.md'), 'kind: knowledge', 'CHILD FOO BODY');
     // This nested store has content but no guide, so a write at its exact prefix
     // must create metadata-free INDEX.md rather than a second declaration.
     writeDoc(join(storeDir(nestedWrite), 'topic.md'), 'kind: knowledge', 'NESTED WRITE TOPIC');
-    // --- lint fixtures ---
+    // lint fixtures
     writeDoc(join(storeDir(badns), 'INDEX.md'), 'kind: knowledge\nnamespace: 42', 'BADNS STORE INDEX');
     writeDoc(join(storeDir(dangling), 'INDEX.md'), 'kind: knowledge\nnamespace: dang\nwhen-and-why-to-read: "When the dang store is addressed, this knowledge should be read because it names what the store holds."', 'DANG STORE INDEX');
     writeDoc(join(storeDir(dangling), 'broken.md'), 'kind: knowledge', 'Links [[dang/nowhere]], which no document answers to.');
-    // --- two profiles, both holding the SAME canonical name ---
+    // two profiles, both holding the SAME canonical name
     const a = createProfile('memcmd-a');
     const b = createProfile('memcmd-b');
     profileB = profileMemoryDir(b.profileId);