@north-light/crouter 0.3.240 → 0.3.242

package/dist/core/runtime/warm-pool.js

@@ -50,10 +50,10 @@
 // different directory than the last one simply misses and cold-spawns — the
 // pool serves the common case of returning to the same working directory.
 //
-// Nothing ever RESUMES a spare: the daemon's recovery sweep reads `listNodes`,
-// which hides the pool, so a spare whose broker dies (every daemon handover
-// tears down every broker of the epoch) is garbage, not a parked node. It is
-// also invisible to the count-based prune for the same reason. So the pool owns
+// Nothing ever resumes a spare: the daemon's row query hides the pool, so a
+// spare whose broker dies (every daemon handover tears down every broker of the
+// epoch) is garbage, not a parked node. It is also invisible to the count-based
+// prune for the same reason. So the pool owns
 // its own garbage collection — `reapStaleSpares`, below, run at daemon start
 // and on every supervision tick.
 import { createHash } from 'node:crypto';

package/dist/core/tui/fuzzy.d.ts

@@ -0,0 +1,9 @@
+/** Case-insensitive subsequence match: every char of `query` appears in `text`
+ *  in order (gaps allowed). Empty query matches everything. Substrings are a
+ *  subsequence, so this subsumes substring matching too. */
+export declare function fuzzyMatch(query: string, text: string): boolean;
+/** Indices in `text` consumed by a greedy left-to-right subsequence match of
+ *  `query` — the same walk as `fuzzyMatch`, but returning WHICH chars matched so
+ *  the renderer can highlight them. Empty set when `query` is empty OR does not
+ *  fully match (no partial highlights). */
+export declare function matchIndices(query: string, text: string): Set<number>;

package/dist/core/tui/fuzzy.js

@@ -0,0 +1,38 @@
+// Subsequence matching for TUI filters. One definition, shared by the canvas
+// browser and the context admin list, so the two surfaces cannot drift apart.
+/** Case-insensitive subsequence match: every char of `query` appears in `text`
+ *  in order (gaps allowed). Empty query matches everything. Substrings are a
+ *  subsequence, so this subsumes substring matching too. */
+export function fuzzyMatch(query, text) {
+    if (query === '')
+        return true;
+    const q = query.toLowerCase();
+    const t = text.toLowerCase();
+    let qi = 0;
+    for (let ti = 0; ti < t.length && qi < q.length; ti++) {
+        if (t[ti] === q[qi])
+            qi++;
+    }
+    return qi === q.length;
+}
+/** Indices in `text` consumed by a greedy left-to-right subsequence match of
+ *  `query` — the same walk as `fuzzyMatch`, but returning WHICH chars matched so
+ *  the renderer can highlight them. Empty set when `query` is empty OR does not
+ *  fully match (no partial highlights). */
+export function matchIndices(query, text) {
+    const out = new Set();
+    if (query === '')
+        return out;
+    const q = query.toLowerCase();
+    const t = text.toLowerCase();
+    let qi = 0;
+    for (let ti = 0; ti < t.length && qi < q.length; ti++) {
+        if (t[ti] === q[qi]) {
+            out.add(ti);
+            qi++;
+        }
+    }
+    if (qi < q.length)
+        out.clear(); // no full match → no highlight
+    return out;
+}

package/dist/daemon/api/__tests__/node-create-description.test.js

@@ -78,6 +78,7 @@ test('node create stores caller description and automatic naming leaves it and n
     const generated = await generatedNameRoute.handler(context('POST', `/v1/nodes/${nodeId}/broker/generated-name`, nodeId, {
         kind: 'initial',
         description: 'Generated replacement',
+        title: 'Generated replacement',
         icon: '',
     }));
     assert.deepEqual(generated.body, { applied: false });

package/dist/daemon/api/handlers/broker-ops.js

@@ -88,6 +88,7 @@ function extensionNode(node) {
         node_id: node.node_id,
         name: node.name,
         ...(node.description === undefined ? {} : { description: node.description }),
+        ...(node.title === undefined ? {} : { title: node.title }),
         ...(node.icon === undefined ? {} : { icon: node.icon }),
         kind: node.kind,
         mode: node.mode,
@@ -153,17 +154,18 @@ function parseGeneratedNameBody(body) {
     const value = objectBody(body, 'broker generated-name');
     if (value['kind'] !== 'initial' && value['kind'] !== 'recap')
         throw usage('kind must be initial or recap');
-    if (typeof value['description'] !== 'string' || typeof value['icon'] !== 'string') {
-        throw usage('description and icon must be strings');
+    if (typeof value['description'] !== 'string' || typeof value['title'] !== 'string' || typeof value['icon'] !== 'string') {
+        throw usage('description, title, and icon must be strings');
+    }
+    if (value['kind'] === 'initial') {
+        return { kind: 'initial', description: value['description'], title: value['title'], icon: value['icon'] };
     }
-    if (value['kind'] === 'initial')
-        return { kind: 'initial', description: value['description'], icon: value['icon'] };
     const expected = value['expected'];
     if (typeof expected !== 'object' || expected === null || Array.isArray(expected)
-        || ['name', 'description', 'icon', 'kind'].some((key) => typeof expected[key] !== 'string')) {
-        throw usage('recap expected must contain name, description, icon, and kind strings');
+        || ['name', 'description', 'title', 'icon', 'kind'].some((key) => typeof expected[key] !== 'string')) {
+        throw usage('recap expected must contain name, description, title, icon, and kind strings');
     }
-    return { kind: 'recap', description: value['description'], icon: value['icon'], expected: expected };
+    return { kind: 'recap', description: value['description'], title: value['title'], icon: value['icon'], expected: expected };
 }
 function parsePersonaAckBody(body) {
     const value = objectBody(body, 'broker persona-ack');
@@ -371,27 +373,32 @@ function handleGeneratedName(ctx) {
                 return { applied: false };
             const updated = updateNode(nodeId, {
                 description: request.description,
+                ...(request.title.trim() === '' ? {} : { title: request.title }),
                 ...(request.icon.trim() === '' ? {} : { icon: request.icon }),
             });
             return {
                 applied: true,
                 editorLabel: editorLabel(updated),
                 description: updated.description ?? '',
+                title: updated.title ?? '',
                 icon: updated.icon ?? '',
             };
         }
         const expected = request.expected;
         if (node.name !== expected.name || (node.description ?? '') !== expected.description
+            || (node.title ?? '') !== expected.title
             || (node.icon ?? '') !== expected.icon || node.kind !== expected.kind)
             return { applied: false };
         const updated = updateNode(nodeId, {
             description: request.description,
+            title: request.title.trim() === '' ? undefined : request.title,
             icon: request.icon.trim() === '' ? undefined : request.icon,
         });
         return {
             applied: true,
             editorLabel: editorLabel(updated),
             description: updated.description ?? '',
+            title: updated.title ?? '',
             icon: updated.icon ?? '',
         };
     });

package/dist/daemon/api/handlers/feedback-comments.js

@@ -67,7 +67,7 @@ async function deliverCommentTurn(args) {
             mode: 'interactive',
             data: { page_id: basename(args.dir), comment_id: args.mutation.comment.id, verb: 'create' },
         });
-        return { target_node_id: target, status: 'delivered', via: delivery.via, woke: delivery.revived };
+        return { target_node_id: target, status: 'delivered', via: delivery.via, woke: delivery.revived, ...(delivery.reason === undefined ? {} : { reason: delivery.reason }) };
     }
     catch (error) {
         // State was committed before delivery; a delivery failure remains a

package/dist/daemon/api/map.js

@@ -124,6 +124,8 @@ export function toNodeDetailDTO(meta, edges) {
     };
     if (meta.description !== undefined)
         dto.description = meta.description;
+    if (meta.title !== undefined)
+        dto.title = meta.title;
     if (meta.icon !== undefined)
         dto.icon = meta.icon;
     if (meta.cycles !== undefined)

package/dist/daemon/crtrd.js

@@ -9,9 +9,8 @@
 // clock. A broker's real `exit` event enqueues an exit-policy job on the
 // daemon's serial work lane (never inline on the Node event callback), where
 // classifyDeadNode — one pure 8-row policy table over durable row state —
-// decides forget / dormant / respawn / boot-failure. The startup recovery
-// sweep classifies boot-time dead rows through the SAME table, so exit
-// recovery and startup recovery can never diverge. Every broker's argv is
+// decides forget / dormant / respawn / boot-failure. The row-driven tick
+// classifies disconnected rows through the same table. Every broker's argv is
 // stamped `--epoch <id>`: at boot the census reaps every prior-epoch broker
 // (no adoption), and at shutdown the daemon tears its whole fleet down, so no
 // broker ever outlives the daemon epoch that launched it. A tmux pane, when
@@ -94,8 +93,8 @@ export function brokerCommandDeclaresCanvasHome(command, home) {
 // readiness mirror, reap every broker of a PRIOR epoch on its own canvas.
 // Ownership is never adopted across epochs — a prior daemon's ChildProcess
 // handles died with it, so its brokers are unsupervisable; tear them down and
-// let the startup recovery sweep reclassify their rows through the policy
-// table. A broker whose argv carries NO `--epoch` tag is a legacy-generation
+// let the next supervision tick classify their rows through the policy table.
+// A broker whose argv carries NO `--epoch` tag is a legacy-generation
 // broker and gets the same verdict (reap): it predates epoch ownership.
 /** The `--epoch <id>` tag host.ts stamps into every broker's argv, or null
  *  for a legacy/untagged broker (which the census treats as prior-epoch). */
@@ -110,9 +109,9 @@ const CENSUS_POLL_MS = 150;
 async function reapPriorEpochBrokers(epoch) {
     const snapshot = captureLivenessSnapshot();
     if (snapshot === null) {
-        // No process table — the census cannot run. The startup recovery sweep
-        // still reclassifies rows; a surviving prior-epoch broker is at worst a
-        // duplicate engine risk the next daemon boot's census retries.
+        // No process table — the census cannot run. The supervision tick still
+        // classifies rows; a surviving prior-epoch broker is at worst a duplicate
+        // engine risk the next daemon boot's census retries.
         emitEvent({
             level: 'error',
             event: 'daemon.census.snapshot_failed',
@@ -184,10 +183,9 @@ async function reapPriorEpochBrokers(epoch) {
 // Daemon-shutdown fleet teardown (invariant 2: no broker outlives the daemon
 // epoch that launched it). SIGTERM every live entry, race each handle's real
 // exit against ONE shared bounded grace, then SIGKILL each survivor's captured
-// process tree. Rows are deliberately NOT rewritten here — the NEXT daemon's
-// startup recovery sweep classifies them through the policy table, exactly as
-// it would after a daemon crash, so clean shutdown and crash converge on one
-// recovery path.
+// process tree. Rows are deliberately NOT rewritten here — the next daemon's
+// supervision tick classifies them through the policy table, so clean shutdown
+// and crash converge on one recovery path.
 const FLEET_TEARDOWN_GRACE_MS = 5_000;
 async function teardownFleet(fleet) {
     const entries = Array.from(fleet.entries());
@@ -292,7 +290,7 @@ export async function superviseTick(now = Date.now(), lifecycle = directTickLife
         // Human bridge rows have no broker engine and participate in none of the
         // recurring row-driven reconciler passes.
         rows = listNodes({ status: ['active', 'idle'] }).filter((row) => row.kind !== 'human');
-        terminating = listNodes({ status: ['done', 'canceled', 'dead'], withRecordedPid: true })
+        terminating = listNodes({ status: ['done', 'canceled', 'dead'], withRecordedPidOrFrozen: true })
             .filter((row) => row.kind !== 'human');
     }
     catch (err) {
@@ -427,7 +425,7 @@ export async function runDaemon(opts = {}) {
     // The grace covers: response flush → the CLI process printing and exiting →
     // pi persisting the tool result. It is NOT a correctness fallback; a broker
     // SIGTERMed mid-turn still gets `abortAndExit`'s own bounded persistence
-    // window, and the successor's startup recovery sweep resumes it either way.
+    // window, and the successor's supervision tick resolves it either way.
     const HANDOVER_ACK_GRACE_MS = 1_000;
     let handoverArmed = false;
     /** Arm the handover. Idempotent: a retry while one is already scheduled
@@ -484,7 +482,7 @@ export async function runDaemon(opts = {}) {
         catch (error) {
             // The canvas is now daemonless. Loud, and recoverable: the next front-door
             // command's ensureDaemon() starts one, and every torn-down node is
-            // reclassified by that daemon's startup recovery sweep.
+            // reclassified by that daemon's supervision tick.
             operationIdContext.fresh(() => {
                 emitEvent({ level: 'error', event: 'daemon.handover.successor_failed', error });
             });
@@ -530,9 +528,8 @@ export async function runDaemon(opts = {}) {
         void requestCleanup().catch(() => { });
     }
     /** The serial work lane (design D-3): supervision ticks, exit-policy jobs,
-     *  matured backoff respawns, and the startup recovery sweep all append here
-     *  and run strictly one at a time, so policy never interleaves with a tick's
-     *  row reads. `laneTail` never rejects — every append attaches the rejection
+     *  and matured backoff respawns run strictly one at a time, so policy never
+     *  interleaves with a tick's row reads. `laneTail` never rejects — every append attaches the rejection
      *  handler. Once admission closes, new jobs are DROPPED (not queued): a
      *  shutdown SIGTERM fans exit events across the whole fleet, and running
      *  their policy jobs would respawn brokers mid-teardown. */
@@ -574,8 +571,8 @@ export async function runDaemon(opts = {}) {
         bindDaemonEventSource();
         interval = opts.intervalMs ?? DEFAULT_INTERVAL_MS;
         // Mint this daemon's epoch and bind the ONE fleet registry for the process
-        // BEFORE anything can launch a broker (the API server, the recovery sweep,
-        // any tick): every launch funnels through headlessBrokerHost.launch, which
+        // BEFORE anything can launch a broker (the API server or any tick): every
+        // launch funnels through headlessBrokerHost.launch, which
         // registers with the bound fleet — an unbound launch throws (design D-2).
         const epoch = randomBytes(8).toString('hex');
         fleet = new DaemonFleet({ epoch, enqueue });

package/dist/daemon/messaging/node-message.d.ts

@@ -3,6 +3,7 @@ export interface NodeMessageDelivery {
     entry_id: string | null;
     via: 'engine' | 'inbox';
     revived: boolean;
+    reason?: 'capacity_frozen';
 }
 export interface RuntimeMessageCard {
     /** A bare core kind only. This renders with `formatCard`, which leaves the

package/dist/daemon/messaging/node-message.js

@@ -58,6 +58,7 @@ export async function deliverNodeMessage(args) {
         data: { ...args.data, body: args.body },
     }));
     let revived = false;
+    let reason;
     if (args.mode !== 'quiet') {
         target = getNode(args.node_id);
         if (target === null)
@@ -66,12 +67,15 @@ export async function deliverNodeMessage(args) {
             try {
                 // Mail is durable, so a wake denied for capacity waits for a slot
                 // rather than being lost: the row freezes and the tick relaunches it.
-                revived = reviveNode(args.node_id, { resume: true, capacity: 'freeze' }).launch !== undefined;
+                const result = reviveNode(args.node_id, { resume: true, capacity: 'freeze' });
+                revived = result.launch !== undefined;
+                if (result.outcome === 'frozen')
+                    reason = 'capacity_frozen';
             }
             catch {
                 // The durable entry remains authoritative; one wake attempt is enough.
             }
         }
     }
-    return { entry_id: entry.entry_id, via: 'inbox', revived };
+    return { entry_id: entry.entry_id, via: 'inbox', revived, ...(reason === undefined ? {} : { reason }) };
 }

package/dist/daemon/reconcilers/live-obligation.d.ts

@@ -12,8 +12,7 @@ export declare function hasLiveObligation(nodeId: string): boolean;
  *  cycle rather than causing one. */
 export declare function hasPendingWake(nodeId: string): boolean;
 /** What parking an unattended node actually amounts to — the one rule both the
- *  live-broker park clock (broker-supervision) and the already-parked
- *  reconciliation (dormant-inbox) apply.
+ *  live-broker park clock and the lifecycle tick apply.
  *
  *  `release` — something can still wake it, so parking is a pause.
  *  `park`    — a resident with nothing left to wake it has completed its

package/dist/daemon/reconcilers/node-lifecycle/freeze-lane.d.ts

@@ -43,11 +43,6 @@ export declare class FreezeLaneReconciler {
     endEpisode(nodeId: string): void;
     run(now: number, ctx: FreezeLaneContext): Promise<FrozenCounts>;
     private enact;
-    /** A frozen row is owed exactly one thing: the launch the cap refused. Strict
-     *  resume is the request, and `reviveNode` itself vetoes it for a pending
-     *  refresh or an unconfirmed cycle — the same modes the dead-row table would
-     *  have chosen. It is recovery, not a wake: nothing arrived for this node
-     *  while it waited, so an armed deadline survives the thaw. */
     private enactThaw;
     private enactIdleRelease;
 }

package/dist/daemon/reconcilers/node-lifecycle/freeze-lane.js

@@ -8,11 +8,7 @@
 // needs to pre-reserve anything. A candidate that finds the ledger full freezes
 // (`reviveNode` with `capacity: 'freeze'` is the single freeze writer) and waits
 // for the next tick.
-//
-// The idle-release episode rules below are the former DormantInboxReconciler's,
-// moved here whole: a relaunch that only ever tried to deliver mail is a launch
-// like any other, and it now competes for slots through the same lane.
-import { getRow, subscribersOf, } from '../../../core/canvas/index.js';
+import { clearFrozen, getNode, getRow, subscribersOf, } from '../../../core/canvas/index.js';
 import { fullName } from '../../../core/canvas/labels.js';
 import { isSafeNodeId } from '../../../core/canvas/paths.js';
 import { emitEvent } from '../../../core/events/emit.js';
@@ -87,7 +83,7 @@ export class FreezeLaneReconciler {
         const id = entry.row.node_id;
         try {
             if (entry.enact === 'thaw')
-                return this.enactThaw(id);
+                return this.enactThaw(entry.row);
             if (entry.enact === 'idle-release')
                 return this.enactIdleRelease(now, entry.row);
             // The SAME policy table an exit event runs, so tick recovery and exit
@@ -110,13 +106,13 @@ export class FreezeLaneReconciler {
             return 'skipped';
         }
     }
-    /** A frozen row is owed exactly one thing: the launch the cap refused. Strict
-     *  resume is the request, and `reviveNode` itself vetoes it for a pending
-     *  refresh or an unconfirmed cycle — the same modes the dead-row table would
-     *  have chosen. It is recovery, not a wake: nothing arrived for this node
-     *  while it waited, so an armed deadline survives the thaw. */
-    enactThaw(nodeId) {
-        return reviveNode(nodeId, { resume: true, capacity: 'freeze', recovery: true }).outcome === 'frozen'
+    enactThaw(row) {
+        if (row.lifecycle === 'resident' && getNode(row.node_id)?.pi_session_id != null && !hasPendingWake(row.node_id)) {
+            transition(row.node_id, 'release');
+            clearFrozen(row.node_id);
+            return 'skipped';
+        }
+        return reviveNode(row.node_id, { resume: true, capacity: 'freeze', recovery: true }).outcome === 'frozen'
             ? 'frozen'
             : 'launched';
     }

package/dist/daemon/reconcilers/node-lifecycle/respawn-policy.js

@@ -1,9 +1,3 @@
-// respawn-policy.ts — the tick's Backoff gate, and P5's file to own outright.
-//
-// P3 only READS `respawn_not_before`: nothing writes it yet, so the gate is
-// inert in effect. P5 replaces the in-memory throttle in `daemon/fleet.ts` with
-// the durable counter writes (`respawn_failures` + `respawn_not_before`) that
-// make it bite, and adds them here rather than in `tick.ts`.
 /** Whether a durable backoff still holds this row back from a relaunch. A row
  *  in backoff holds no slot and is excluded from the saturation figure — it is
  *  waiting on a clock, not on capacity. */

package/dist/daemon/reconcilers/node-lifecycle/terminating.d.ts

@@ -1,4 +1,2 @@
 import type { NodeRow } from '../../../core/canvas/index.js';
-/** Handle a terminal row that still holds a process. Deliberately inert until
- *  P4: a row reaching here is already excluded from every other tick duty. */
 export declare function handleTerminatingRow(row: NodeRow): void;

package/dist/daemon/reconcilers/node-lifecycle/terminating.js

@@ -1,13 +1,3 @@
-// terminating.ts — the Terminating state's owner, and P4's file to own outright.
-//
-// A terminal row that still holds a process is a node whose teardown has been
-// requested but not finished. P4 gives it one bounded shutdown request and an
-// escalation after its grace, moving the inline `headlessBrokerHost.teardown`
-// calls at the close/reset sites into this daemon-side lane. P3 changes no
-// teardown behavior: it only OBSERVES such rows (the tick queries terminal rows
-// carrying a recorded pid) and hands them here, so P4 edits this file alone.
-/** Handle a terminal row that still holds a process. Deliberately inert until
- *  P4: a row reaching here is already excluded from every other tick duty. */
 export function handleTerminatingRow(row) {
     void row;
 }

package/dist/daemon/reconcilers/node-lifecycle/tick.d.ts

@@ -2,8 +2,8 @@ import { type NodeRow } from '../../../core/canvas/index.js';
 import type { FleetRegistry } from '../../../core/runtime/fleet.js';
 import { type FrozenCounts } from './freeze-lane.js';
 export interface NodeLifecycleContext {
-    /** Every active and idle row (human rows excluded), plus terminal rows that
-     *  still hold a recorded pid. */
+    /** Every active and idle row (human rows excluded), plus terminal rows with
+     *  a recorded pid or frozen mark. */
     rows: readonly NodeRow[];
     fleet: FleetRegistry;
 }

package/dist/daemon/reconcilers/node-lifecycle/tick.js

@@ -64,9 +64,11 @@ export class NodeLifecycleReconciler {
             this.thawMark(row);
             return;
         }
-        // 2. A terminal row still holding a process is Terminating, and P4's.
         if (isTerminal(row)) {
-            handleTerminatingRow(row);
+            if (row.pi_pid != null)
+                handleTerminatingRow(row);
+            else if (row.frozen_at != null)
+                candidates.push({ row, enact: 'thaw' });
             return;
         }
         // A paused profile launches nothing, and its stuck-delivery episode is over

package/dist/daemon/reconcilers/storage-maintenance.js

@@ -19,8 +19,8 @@ export class StorageMaintenanceReconciler {
     run(now, ctx) {
         void ctx; // no consumer today — kept only for six-way call-site uniformity
         // Placement reap MUST precede focus GC, so GC catches a focus row the reap
-        // strands. Both run after dormant-inbox reconciliation, so a same-tick
-        // revive has already had the chance to re-anchor its focus.
+        // strands. Both run after the lifecycle tick, so a same-tick revive has
+        // already had the chance to re-anchor its focus.
         this.reapDeadResidue(now);
         this.gcStaleFocuses();
         this.reapGhostRows(now);

package/dist/daemon/review/comment-notify.d.ts

@@ -7,6 +7,7 @@ export interface CommentDelivery {
     status: 'delivered' | 'skipped' | 'failed';
     via?: 'engine' | 'inbox';
     woke: boolean;
+    reason?: 'capacity_frozen';
     error?: string;
 }
 /** Render the one bounded, durable comment notice delivered to a review companion. */

package/dist/daemon/review/comment-notify.js

@@ -96,6 +96,7 @@ export async function notifyComment(args) {
         status: 'delivered',
         via: delivery.via,
         woke: delivery.revived,
+        ...(delivery.reason === undefined ? {} : { reason: delivery.reason }),
     };
     appendDeliveryEvent({
         review_id: args.review.review_id,

package/dist/pi-extensions/broker-local.d.ts

@@ -13,6 +13,7 @@ export declare function generateAndCommitInitialName(nodeId: string, prompt: str
 export declare function generateAndCommitRecapName(nodeId: string, conversation: string, expected: {
     name: string;
     description: string;
+    title: string;
     icon: string;
     kind: string;
 }, isStillAutomatic: () => boolean, onNamed?: (editorLabel: string) => void): void;

package/dist/pi-extensions/broker-local.js

@@ -10,7 +10,7 @@ import { join } from 'node:path';
 import { CRTR_DIR_NAME } from '../types.js';
 import { brokerExtensionState, commitBrokerGeneratedName, } from '../core/runtime/broker/daemon-ops.js';
 import { publishNodeNamed } from '../core/runtime/broker/node-named.js';
-import { headlessName, headlessNameFromConversation, sanitizeSessionName, slugFromPrompt, } from '../core/runtime/naming.js';
+import { headlessName, headlessNameFromConversation, sanitizeSessionName, sanitizeSessionTitle, slugFromPrompt, titleFromPrompt, } from '../core/runtime/naming.js';
 function contextDir(nodeId) {
     if (nodeId === '' || nodeId === '.' || nodeId === '..' || /[\\/\0]/u.test(nodeId)) {
         throw new TypeError('node_id must be a non-empty path segment');
@@ -37,8 +37,14 @@ export function readRoadmap(nodeId) {
     const path = join(contextDir(nodeId), 'roadmap.md');
     return existsSync(path) ? readFileSync(path, 'utf8') : null;
 }
-function generatedDescription(source, generated) {
-    return sanitizeSessionName(generated.name) || slugFromPrompt(source);
+/** The label fields to commit: what the namer produced, or what the source text
+ * itself yields when it produced nothing usable. */
+function generatedLabel(source, generated) {
+    return {
+        description: sanitizeSessionName(generated.name) || slugFromPrompt(source),
+        title: sanitizeSessionTitle(generated.title) || titleFromPrompt(source),
+        icon: generated.icon,
+    };
 }
 /** Generate and commit the first name for a node. The initial operation is
  * guarded by crtrd, so a concurrent rename or another broker cannot be
@@ -53,8 +59,7 @@ export function generateAndCommitInitialName(nodeId, prompt, onNamed) {
             return undefined;
         return headlessName(body).then((generated) => commitBrokerGeneratedName(nodeId, {
             kind: 'initial',
-            description: generatedDescription(body, generated),
-            icon: generated.icon,
+            ...generatedLabel(body, generated),
         }));
     })
         .then((result) => {
@@ -68,6 +73,7 @@ export function generateAndCommitInitialName(nodeId, prompt, onNamed) {
         // has nothing left to re-read on.
         publishNodeNamed({
             description: result.description ?? '',
+            title: result.title ?? '',
             icon: result.icon ?? '',
             editorLabel: result.editorLabel,
         });
@@ -88,8 +94,7 @@ export function generateAndCommitRecapName(nodeId, conversation, expected, isSti
             return undefined;
         return commitBrokerGeneratedName(nodeId, {
             kind: 'recap',
-            description: generatedDescription(body, generated),
-            icon: generated.icon,
+            ...generatedLabel(body, generated),
             expected,
         });
     })

package/dist/pi-extensions/canvas-recap.js

@@ -267,6 +267,7 @@ export function registerCanvasRecap(pi, recapGenerator = generateRecap, nameRege
             generateAndCommitRecapName(nodeId, conversation, {
                 name: node.name,
                 description: node.description ?? '',
+                title: node.title ?? '',
                 icon: node.icon ?? '',
                 kind: node.kind,
             }, () => pi.getSessionName?.() === original, (label) => {

package/dist/pi-extensions/canvas-stophook.js

@@ -360,6 +360,8 @@ export function registerCanvasStophook(pi) {
                 // back into its calling broker. Do not await the operation that tears
                 // this broker down from Pi's session-start dispatch.
                 void relaunchBrokerRoot(nodeId).catch((error) => {
+                    const message = error instanceof Error ? error.message : String(error);
+                    ctx?.ui?.notify?.(`/new refused: ${message}`, 'error');
                     emitEvent({
                         event: 'broker.daemon.operation.failed',
                         level: 'error',

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@north-light/crouter",
-  "version": "0.3.240",
+  "version": "0.3.242",
   "description": "crtr — agent runtime with memory, plugins, and marketplaces",
   "type": "module",
   "main": "dist/index.js",

package/runtime.lock.json

@@ -1,12 +1,12 @@
 {
   "name": "@north-light/crouter",
-  "version": "0.3.240",
+  "version": "0.3.242",
   "lockfileVersion": 3,
   "requires": true,
   "packages": {
     "": {
       "name": "@north-light/crouter",
-      "version": "0.3.240",
+      "version": "0.3.242",
       "hasInstallScript": true,
       "license": "MIT",
       "dependencies": {

package/dist/commands/sys/context/admin/axes-panel.d.ts

@@ -1,21 +0,0 @@
-import { type Snapshot } from './model.js';
-export type AxisId = 'event' | 'payload' | 'kind' | 'mode' | 'lifecycle' | 'manager' | 'depth' | 'profile' | 'cwd';
-interface Axis {
-    id: AxisId;
-    label: string;
-    value: string;
-    /** Free-text axes open a field; the rest cycle in place. */
-    typed: boolean;
-}
-/** The rail's rows for a snapshot. The payload row appears only for the events
- *  that read one, because on boot there is nothing it could change. */
-export declare function axesOf(snapshot: Snapshot, profileName: string): Axis[];
-/** Cycle one enum axis, returning the changed snapshot. A typed axis is never
- *  cycled — the shell opens a field for it instead. */
-export declare function cycleAxis(snapshot: Snapshot, id: AxisId, delta: number): Snapshot;
-/** Apply a typed axis's submitted value. */
-export declare function setTypedAxis(snapshot: Snapshot, id: AxisId, value: string): Snapshot;
-/** The value a typed axis's field is seeded with. */
-export declare function typedAxisValue(snapshot: Snapshot, id: AxisId): string;
-export declare function renderAxes(axes: Axis[], index: number, width: number, height: number, focused: boolean): string[];
-export {};