@north-light/crouter 0.3.241 → 0.3.242

package/dist/core/review/realize.js

@@ -177,7 +177,7 @@ export async function realizeReview(reviewId) {
         throw companionUnbound(review.review_id, COMPANION_BIND_DEADLINE_MS);
     }
     // R5: SQLite visibility commits before the ticket projection. A missing
-    // projection is deliberately under-exposed and recovered by the startup sweep.
+    // projection is deliberately under-exposed and retried by the review lane.
     if (openReviewRow(review.review_id, new Date().toISOString())) {
         signalReviewActivity();
         if (review.origin_kind === 'ticket')

package/dist/core/runtime/broker/node-named.d.ts

@@ -1,6 +1,7 @@
 /** What crtrd stored, as it stored it — the payload of a `node_named` frame. */
 export interface NodeNamedNotice {
     description: string;
+    title: string;
     icon: string;
     editorLabel: string;
 }

package/dist/core/runtime/host.js

@@ -206,121 +206,132 @@ export const headlessBrokerHost = {
         if (!fleet.reserveSlot(nodeId)) {
             throw brokerCapReached(brokerThresholdsForDaemon().automaticReviveCap, fleet.size());
         }
-        // Redirect the detached broker's stdout+stderr to a per-node log under the
-        // node's existing job/ dir. It retains arbitrary engine/process residue and
-        // failed-canonical fatal fallback output. Append-mode preserves crash-revive history.
-        const logDir = jobDir(nodeId);
-        mkdirSync(logDir, { recursive: true });
-        const logFd = openSync(join(logDir, 'broker.log'), 'a');
-        // Launch from the crouter-branded host binary (a copy of node) so the
-        // broker shows "crouter" in macOS Full Disk Access, not "node". On
-        // non-darwin / dev / tests this is just process.execPath (see branded-host).
-        // buildBrokerEnv's default-deny allowlist has no `CRTR_` prefix, so a bare
-        // `CRTR_BROKER_ENGINE` set only in the LAUNCHING process's ambient env (the
-        // T11 test seam — see broker-sdk.ts) would never reach the child, which
-        // would silently fall back to booting the real SDK. Inject the SAME value
-        // preflightBrokerLaunch already resolved+validated above: it is
-        // parent-resolved, crtr-trusted data (the same trust category as
-        // `inv.env`), not a blanket `CRTR_*` passthrough, so this does not weaken
-        // the allowlist's hardening. In production `engineSpec` is always the real
-        // SDK default, so this is a no-op there.
-        const engineSpec = resolveEngineSpec(inv);
-        const childEnv = { ...buildBrokerEnv(inv), CRTR_BROKER_ENGINE: engineSpec };
-        // NODE_OPTIONS is deliberately absent from the operational allowlist (it is
-        // a code-execution vector — `--require`/`--import` — and DAEMON_ENV_STRIP_KEYS
-        // strips it from the daemon's own env for the identical reason: a poisoned
-        // NODE_OPTIONS in an inheriting shell must never reach a process that then
-        // handles model credentials). It is genuinely needed ONLY for the T11 test
-        // seam above: the fake engine is a `.ts` fixture, and the broker CLI entry
-        // itself is only a `.js` file under the compiled `dist/`, so the harness
-        // relies on `NODE_OPTIONS=--import tsx/esm` (set on its own ambient env, same
-        // seam as CRTR_BROKER_ENGINE) to make the spawned child resolve both under
-        // tsx. Gating this carry on `engineSpec !== DEFAULT_BROKER_ENGINE` — i.e. only
-        // when the trusted test seam above already fired — keeps production (where
-        // the engine is never overridden) byte-identical to today: NODE_OPTIONS is
-        // never forwarded there, so an ambient poisoned value stays contained.
-        if (engineSpec !== DEFAULT_BROKER_ENGINE) {
-            const nodeOptions = inv.env['NODE_OPTIONS'] ?? process.env['NODE_OPTIONS'];
-            if (nodeOptions !== undefined)
-                childEnv['NODE_OPTIONS'] = nodeOptions;
-        }
-        if (eventSource() === undefined)
-            bindBrokerEventSource(nodeId);
-        // `--canvas-home` declares broker ownership in argv so the daemon's
-        // startup epoch census can match its own canvas' brokers exactly (crtrd's
-        // brokerCommandDeclaresCanvasHome) instead of inferring from install
-        // paths; `--epoch` stamps WHICH daemon epoch launched it, so the next
-        // daemon's census reaps every prior-epoch broker without adoption (D-8).
-        // Both precede the node id: the node id is by contract the FINAL argv
-        // token (both broker-cli and the ps census parse it that way).
+        let logFd = null;
         let child;
+        let registered = false;
         try {
-            child = spawn(hostExecPath(), [resolveBrokerEntry(), '--canvas-home', crtrHome(), '--epoch', fleet.epoch(), nodeId], {
+            // Redirect the detached broker's stdout+stderr to a per-node log under the
+            // node's existing job/ dir. It retains arbitrary engine/process residue and
+            // failed-canonical fatal fallback output. Append-mode preserves crash-revive history.
+            const logDir = jobDir(nodeId);
+            mkdirSync(logDir, { recursive: true });
+            logFd = openSync(join(logDir, 'broker.log'), 'a');
+            // Launch from the crouter-branded host binary (a copy of node) so the
+            // broker shows "crouter" in macOS Full Disk Access, not "node". On
+            // non-darwin / dev / tests this is just process.execPath (see branded-host).
+            // buildBrokerEnv's default-deny allowlist has no `CRTR_` prefix, so a bare
+            // `CRTR_BROKER_ENGINE` set only in the LAUNCHING process's ambient env (the
+            // T11 test seam — see broker-sdk.ts) would never reach the child, which
+            // would silently fall back to booting the real SDK. Inject the SAME value
+            // preflightBrokerLaunch already resolved+validated above: it is
+            // parent-resolved, crtr-trusted data (the same trust category as
+            // `inv.env`), not a blanket `CRTR_*` passthrough, so this does not weaken
+            // the allowlist's hardening. In production `engineSpec` is always the real
+            // SDK default, so this is a no-op there.
+            const engineSpec = resolveEngineSpec(inv);
+            const childEnv = { ...buildBrokerEnv(inv), CRTR_BROKER_ENGINE: engineSpec };
+            // NODE_OPTIONS is deliberately absent from the operational allowlist (it is
+            // a code-execution vector — `--require`/`--import` — and DAEMON_ENV_STRIP_KEYS
+            // strips it from the daemon's own env for the identical reason: a poisoned
+            // NODE_OPTIONS in an inheriting shell must never reach a process that then
+            // handles model credentials). It is genuinely needed ONLY for the T11 test
+            // seam above: the fake engine is a `.ts` fixture, and the broker CLI entry
+            // itself is only a `.js` file under the compiled `dist/`, so the harness
+            // relies on `NODE_OPTIONS=--import tsx/esm` (set on its own ambient env, same
+            // seam as CRTR_BROKER_ENGINE) to make the spawned child resolve both under
+            // tsx. Gating this carry on `engineSpec !== DEFAULT_BROKER_ENGINE` — i.e. only
+            // when the trusted test seam above already fired — keeps production (where
+            // the engine is never overridden) byte-identical to today: NODE_OPTIONS is
+            // never forwarded there, so an ambient poisoned value stays contained.
+            if (engineSpec !== DEFAULT_BROKER_ENGINE) {
+                const nodeOptions = inv.env['NODE_OPTIONS'] ?? process.env['NODE_OPTIONS'];
+                if (nodeOptions !== undefined)
+                    childEnv['NODE_OPTIONS'] = nodeOptions;
+            }
+            if (eventSource() === undefined)
+                bindBrokerEventSource(nodeId);
+            // `--canvas-home` declares broker ownership in argv so the daemon's
+            // startup epoch census can match its own canvas' brokers exactly (crtrd's
+            // brokerCommandDeclaresCanvasHome) instead of inferring from install
+            // paths; `--epoch` stamps WHICH daemon epoch launched it, so the next
+            // daemon's census reaps every prior-epoch broker without adoption (D-8).
+            // Both precede the node id: the node id is by contract the FINAL argv
+            // token (both broker-cli and the ps census parse it that way).
+            const spawned = spawn(hostExecPath(), [resolveBrokerEntry(), '--canvas-home', crtrHome(), '--epoch', fleet.epoch(), nodeId], {
                 cwd: opts.cwd,
                 detached: true,
                 stdio: ['ignore', logFd, logFd],
                 env: childEnv,
             });
-        }
-        catch (error) {
-            fleet.releaseReservation(nodeId);
+            child = spawned;
+            // The child holds its own dup of the fd; release the parent's copy so the
+            // launching process (CLI or daemon) never leaks it.
             closeSync(logFd);
-            throw error;
-        }
-        // The child holds its own dup of the fd; release the parent's copy so the
-        // launching process (CLI or daemon) never leaks it.
-        closeSync(logFd);
-        // ONE seam for every launch path (revive/spawn/recycle/reset): record the
-        // child's real exit status as a canonical event. Readiness waits consume
-        // `exited` for fail-fast and then discard it, so before this a broker that
-        // was SIGKILLed out from under crouter left NO trace anywhere — an external
-        // kill was indistinguishable from a silent early return, and post-mortems
-        // were unprovable (see the 2026-07-27 "brokers die at startup" RCA).
-        // Emitted through the ordinary bound source: in the daemon (the process
-        // that actually launches brokers) that is the daemon stream carrying
-        // `node_id`, which is how every other daemon-observed broker event
-        // (broker.wedge.detected, broker.yield_stall.*) is recorded and how a
-        // node-scoped log query finds it. The node's own job/log.jsonl is the
-        // BROKER's stream — the reader rejects any non-broker-component line there
-        // (events/read.ts descriptorMatches) — so the daemon must not write into
-        // it. A process already bound to this node's broker source (in-process
-        // revive) naturally lands there instead.
-        const launchedAt = Date.now();
-        const exited = new Promise((resolve) => {
-            let settled = false;
-            const finish = (state) => {
-                if (settled)
-                    return;
-                settled = true;
-                resolve(state);
-            };
-            child.once('exit', (code, signal) => {
-                emitEvent({
-                    level: code === 0 ? 'info' : 'warn',
-                    event: 'broker.exited',
-                    node_id: nodeId,
-                    fields: { code, signal, uptime_ms: Date.now() - launchedAt },
+            logFd = null;
+            // ONE seam for every launch path (revive/spawn/recycle/reset): record the
+            // child's real exit status as a canonical event. Readiness waits consume
+            // `exited` for fail-fast and then discard it, so before this a broker that
+            // was SIGKILLed out from under crouter left NO trace anywhere — an external
+            // kill was indistinguishable from a silent early return, and post-mortems
+            // were unprovable (see the 2026-07-27 "brokers die at startup" RCA).
+            // Emitted through the ordinary bound source: in the daemon (the process
+            // that actually launches brokers) that is the daemon stream carrying
+            // `node_id`, which is how every other daemon-observed broker event
+            // (broker.wedge.detected, broker.yield_stall.*) is recorded and how a
+            // node-scoped log query finds it. The node's own job/log.jsonl is the
+            // BROKER's stream — the reader rejects any non-broker-component line there
+            // (events/read.ts descriptorMatches) — so the daemon must not write into
+            // it. A process already bound to this node's broker source (in-process
+            // revive) naturally lands there instead.
+            const launchedAt = Date.now();
+            const exited = new Promise((resolve) => {
+                let settled = false;
+                const finish = (state) => {
+                    if (settled)
+                        return;
+                    settled = true;
+                    resolve(state);
+                };
+                spawned.once('exit', (code, signal) => {
+                    emitEvent({
+                        level: code === 0 ? 'info' : 'warn',
+                        event: 'broker.exited',
+                        node_id: nodeId,
+                        fields: { code, signal, uptime_ms: Date.now() - launchedAt },
+                    });
+                    finish({ code, signal });
                 });
-                finish({ code, signal });
+                spawned.once('error', () => finish({ code: null, signal: null }));
             });
-            child.once('error', () => finish({ code: null, signal: null }));
-        });
-        child.unref();
-        const handle = { pid: child.pid ?? null, exited };
-        // Register the live handle synchronously — the fleet entry IS the node's
-        // liveness from here on, and its real `exit` event (never a pid probe)
-        // drives dead-node policy. A null pid (spawn itself failed) registers
-        // nothing: the `exited` promise resolves via the 'error' event and the
-        // caller's own null-pid check surfaces the failure.
-        if (handle.pid !== null) {
-            fleet.register(nodeId, handle);
-            void exited.then((status) => fleet.onChildExit(nodeId, status));
+            spawned.unref();
+            const handle = { pid: spawned.pid ?? null, exited };
+            // Register the live handle synchronously — the fleet entry IS the node's
+            // liveness from here on, and its real `exit` event (never a pid probe)
+            // drives dead-node policy. A null pid (spawn itself failed) registers
+            // nothing: the `exited` promise resolves via the 'error' event and the
+            // caller's own null-pid check surfaces the failure.
+            if (handle.pid !== null) {
+                fleet.register(nodeId, handle);
+                registered = true;
+                void exited.then((status) => fleet.onChildExit(nodeId, status));
+            }
+            return handle;
+        }
+        catch (error) {
+            if (!registered && child?.pid != null) {
+                try {
+                    child.kill('SIGTERM');
+                }
+                catch { /* no fleet handle exists to tear down */ }
+            }
+            throw error;
         }
-        else {
-            // Nothing was registered, so nothing will ever free this slot at exit.
-            fleet.releaseReservation(nodeId);
+        finally {
+            if (!registered)
+                fleet.releaseReservation(nodeId);
+            if (logFd !== null)
+                closeSync(logFd);
         }
-        return handle;
     },
     isAlive(node) {
         return isPidAlive((typeof node === 'string' ? getNode(node) : node)?.pi_pid);

package/dist/core/runtime/lifecycle.js

@@ -63,8 +63,9 @@ const TRANSITIONS = {
     crash: { status: 'dead', from: LIVE },
     // requestYield · relaunchRoot new-node safety net. Status KEPT (already active).
     yield: { intent: 'refresh', from: LIVE },
-    // stophook idle-release: free the host, stay woken by the inbox.
-    release: { status: 'idle', intent: 'idle-release', from: LIVE },
+    // Free the host, stay woken by the inbox. A parked resident can also drain
+    // here after a capacity freeze without spending a slot.
+    release: { status: 'idle', intent: 'idle-release', from: [...LIVE, 'done'] },
     // reviveNode provisional refresh launch: activate without committing the
     // refresh until session_start proves the engine booted.
     'refresh-launch': { status: 'active', intent: 'refresh', from: ANY },

package/dist/core/runtime/naming.d.ts

@@ -2,8 +2,18 @@
  *  usable survives. Lowercases, keeps [a-z0-9], collapses everything else to a
  *  single hyphen, and clamps to the first 8 words. */
 export declare function sanitizeSessionName(raw: string): string;
-/** Local fallback: derive a name straight from the prompt (no pi call). Drops
- *  stop-words, takes the first few content words. */
+/** Coerce arbitrary text into a one-line prose title, or '' if nothing usable
+ *  survives. Takes the first non-empty line, collapses runs of whitespace, drops
+ *  wrapping quotes, clamps at a word boundary, and capitalizes the opening
+ *  letter. Punctuation INSIDE the line survives — carrying it is what `title`
+ *  is for. */
+export declare function sanitizeSessionTitle(raw: string): string;
+/** Local fallback: the opening of the prompt as a title (no pi call), with its
+ *  punctuation. Whitespace collapses first so a multi-line message contributes
+ *  its actual opening words rather than whatever its first line happened to be. */
+export declare function titleFromPrompt(prompt: string): string;
+/** Local fallback: derive a kebab handle straight from the prompt (no pi call),
+ *  from the same opening words the fallback title keeps. */
 export declare function slugFromPrompt(prompt: string): string;
 /** The namer's model: the `light` rung of the DEFAULT provider's ladder, with
  *  any thinking suffix stripped because the one-shot session uses thinking off.
@@ -11,11 +21,14 @@ export declare function slugFromPrompt(prompt: string): string;
  *  user who never configured Anthropic: an OpenAI default provider resolves to
  *  its own light rung. `CRTR_NAME_MODEL` still overrides. */
 export declare function lightModel(overrideEnv?: string): string;
-/** A generated session name: the kebab-case handle plus the Nerd Font glyph the
- *  namer chose for it. `icon` is '' when the model returned nothing usable —
- *  every surface renders the name alone in that case. */
+/** A generated session label: the kebab-case handle, the prose title, and the
+ *  Nerd Font glyph the namer chose. `title` is '' when the model gave nothing
+ *  usable, leaving the caller to fall back to the prompt's own opening words;
+ *  `icon` is '' on the same terms, and every surface renders the name alone in
+ *  that case. */
 export interface SessionName {
     name: string;
+    title: string;
     icon: string;
 }
 /** Normalize a model-supplied icon to a single renderable glyph, or '' when
@@ -30,9 +43,14 @@ export interface SessionName {
  *  `nf-fa-bug`, a bare ASCII letter, and anything multi-glyph, all of which
  *  would render as noise or tofu in a label. */
 export declare function sanitizeIcon(raw: string): string;
-/** Ask Pi headlessly for a structured {name, icon} for `body`, async. Resolves
- *  to a sanitized SessionName, or `{name:'',icon:''}` on timeout, a missing tool
- *  call, or a malformed emission so the caller can fall back to a local slug.
+/** Ask Pi headlessly for a structured {name, title, icon} for `body`, async.
+ *  Resolves to a sanitized SessionName, or `{name:'',title:'',icon:''}` on
+ *  timeout, a missing tool call, or a malformed emission so the caller can fall
+ *  back to the prompt's own words.
+ *
+ *  Nothing FORCES the tool call — constrained sampling shapes the arguments once
+ *  the model decides to call it — so a model that answers in prose instead gets
+ *  one more attempt before the caller falls back.
  *
  *  This module stays canvas-free so CLI leaves can reach it. The canvas-coupled
  *  commit path lives in pi-extensions/broker-local.ts, which imports this pure

package/dist/core/runtime/naming.js

@@ -1,14 +1,15 @@
 // Session naming — turn a node's first prompt into a short, human-readable
-// handle for the editor label.
+// label.
 //
-// A node's editor label is `<mode-icon> <name> <kind>` (see editorLabel in
-// labels.ts). The `<name>` is a 3-8 word kebab-case "description" derived from
-// the first prompt by asking Pi headlessly, persisted on the node's meta so it
-// survives revives and updates the live session name.
+// One call produces BOTH forms a surface needs, so no consumer has to un-mangle
+// the other's format: `name` is the 3-8 word kebab-case handle that sits in a
+// node's editor label (`<mode-icon> <name> <kind>`, see editorLabel in
+// labels.ts) and a tmux window name, `title` is the prose sentence a person
+// reads in a conversation list, punctuation intact.
 //
-// The namer returns a STRUCTURED result — {name, icon} — produced by constrained
-// sampling through the one-shot `name_session` tool, not by parsing prose. The
-// icon is a Nerd Font glyph the model picks freely
+// The namer returns a STRUCTURED result — {name, title, icon} — produced by
+// constrained sampling through the one-shot `name_session` tool, not by parsing
+// prose. The icon is a Nerd Font glyph the model picks freely
 // (guided by example blocks, not a closed enum) and is stored as its own meta
 // field, so each surface decides whether to render it.
 //
@@ -47,13 +48,19 @@ const ICON_EXAMPLES = [
     'interface/design: U+F1FC paintbrush, U+F03E image, U+F108 display',
     'communication/coordination: U+F1D8 paper plane, U+F0E6 comments, U+F0E8 sitemap, U+F0C1 link',
 ].join('\n');
-const NAME_SYSTEM_PROMPT = 'You name coding-agent work sessions. The name is a label used to identify the ' +
-    'session at a glance among many other concurrent programming sessions, so it must ' +
-    'describe what the task is about.\n\n' +
+const NAME_SYSTEM_PROMPT = 'You label agent sessions. A session is whatever a person opened it for: a coding task, ' +
+    'a question, a piece of research, an idea they are turning over, or an ordinary ' +
+    'conversation. You are labelling that session, never taking part in it — do not answer ' +
+    'the message, do not do the work it asks for, do not comment on it. Every session gets a ' +
+    'label, however short, casual, misspelled, or open-ended its opening message is.\n\n' +
     'Call the `name_session` tool exactly once with:\n' +
-    '- `name`: a concise 3-8 word kebab-case name — lowercase words joined by single ' +
-    'hyphens (e.g. `refactor-auth-token-flow`, `add-csv-export-endpoint`). No punctuation, ' +
-    'quotes, or prose.\n' +
+    '- `title`: how a person would refer to this session in a list of their conversations — ' +
+    '2-8 words, sentence case, written naturally with its punctuation intact (e.g. ' +
+    "`What's your favorite color?`, `Payroll export mapping bug`, `Ideas for the launch " +
+    'email`). No quotes, no markdown, no trailing period.\n' +
+    '- `name`: the same subject as a concise 3-8 word kebab-case handle — lowercase words ' +
+    'joined by single hyphens (e.g. `favorite-color-question`, `refactor-auth-token-flow`). ' +
+    'No punctuation, quotes, or prose.\n' +
     '- `icon`: ONE Nerd Font glyph, written as its codepoint in `U+XXXX` form (e.g. ' +
     '`U+F188`). Emit a codepoint, not a name like `nf-fa-bug`, and not an emoji.\n\n' +
     'Choosing the icon — work through it in this order:\n' +
@@ -76,14 +83,11 @@ const NAME_SYSTEM_PROMPT = 'You name coding-agent work sessions. The name is a l
  *  text for the instruction. The source is capped first, so the closing tag is
  *  always present. */
 function nameUserPrompt(source, sourceCap = PROMPT_CAP) {
-    return `<source>\n${source.slice(0, sourceCap)}\n</source>\n\nName this session based on the work described above, and pick an icon depicting it. Call \`name_session\` once, then stop.`;
+    return `<source>\n${source.slice(0, sourceCap)}\n</source>\n\nLabel the session this text is from: call \`name_session\` once with a title, a name, and an icon depicting it, then stop. Do not answer it.`;
 }
-/** A short stop-word set so the local-slug fallback skips filler words. */
-const STOPWORDS = new Set([
-    'the', 'a', 'an', 'and', 'or', 'but', 'to', 'of', 'in', 'on', 'for', 'with',
-    'is', 'are', 'be', 'this', 'that', 'it', 'as', 'at', 'by', 'from', 'into',
-    'please', 'can', 'you', 'i', 'we', 'my', 'our', 'me', 'so', 'then',
-]);
+/** Cap on a generated title — room for a full sentence-case phrase, short
+ *  enough that a conversation list stays scannable. */
+const TITLE_CAP = 72;
 /** Coerce arbitrary text into a 3-8 word kebab-case name, or '' if nothing
  *  usable survives. Lowercases, keeps [a-z0-9], collapses everything else to a
  *  single hyphen, and clamps to the first 8 words. */
@@ -96,17 +100,34 @@ export function sanitizeSessionName(raw) {
         .filter((w) => w !== '');
     return words.slice(0, 8).join('-');
 }
-/** Local fallback: derive a name straight from the prompt (no pi call). Drops
- *  stop-words, takes the first few content words. */
+/** Coerce arbitrary text into a one-line prose title, or '' if nothing usable
+ *  survives. Takes the first non-empty line, collapses runs of whitespace, drops
+ *  wrapping quotes, clamps at a word boundary, and capitalizes the opening
+ *  letter. Punctuation INSIDE the line survives — carrying it is what `title`
+ *  is for. */
+export function sanitizeSessionTitle(raw) {
+    const line = (raw ?? '').split('\n').map((l) => l.trim()).find((l) => l !== '') ?? '';
+    const collapsed = line.replace(/\s+/g, ' ').replace(/^["'`]+|["'`]+$/g, '').trim();
+    if (collapsed === '')
+        return '';
+    let clamped = collapsed;
+    if (collapsed.length > TITLE_CAP) {
+        const cut = collapsed.slice(0, TITLE_CAP);
+        const boundary = cut.lastIndexOf(' ');
+        clamped = `${(boundary > TITLE_CAP / 2 ? cut.slice(0, boundary) : cut).trimEnd()}\u2026`;
+    }
+    return clamped.charAt(0).toUpperCase() + clamped.slice(1);
+}
+/** Local fallback: the opening of the prompt as a title (no pi call), with its
+ *  punctuation. Whitespace collapses first so a multi-line message contributes
+ *  its actual opening words rather than whatever its first line happened to be. */
+export function titleFromPrompt(prompt) {
+    return sanitizeSessionTitle((prompt ?? '').replace(/\s+/g, ' '));
+}
+/** Local fallback: derive a kebab handle straight from the prompt (no pi call),
+ *  from the same opening words the fallback title keeps. */
 export function slugFromPrompt(prompt) {
-    const words = (prompt ?? '')
-        .toLowerCase()
-        .replace(/[^a-z0-9]+/g, ' ')
-        .split(' ')
-        .filter((w) => w !== '' && !STOPWORDS.has(w));
-    const picked = (words.length > 0 ? words : (prompt ?? '').toLowerCase().replace(/[^a-z0-9]+/g, ' ').split(' ').filter(Boolean))
-        .slice(0, 3);
-    return sanitizeSessionName(picked.join('-')) || 'session';
+    return sanitizeSessionName(titleFromPrompt(prompt)) || 'session';
 }
 /** The namer's model: the `light` rung of the DEFAULT provider's ladder, with
  *  any thinking suffix stripped because the one-shot session uses thinking off.
@@ -134,6 +155,10 @@ function nameModelRequest() {
 const NAME_SESSION_SCHEMA = {
     type: 'object',
     properties: {
+        title: {
+            type: 'string',
+            description: 'A 2-8 word sentence-case title a person would recognize this session by in a list, with its punctuation intact, e.g. Payroll export mapping bug. No quotes, markdown, or trailing period.',
+        },
         name: {
             type: 'string',
             description: 'A 3-8 word kebab-case session name: lowercase words joined by single hyphens, e.g. refactor-auth-token-flow. No punctuation, quotes, or prose.',
@@ -143,7 +168,7 @@ const NAME_SESSION_SCHEMA = {
             description: 'The Nerd Font glyph depicting this session, as a codepoint in U+XXXX form (e.g. U+F188).',
         },
     },
-    required: ['name', 'icon'],
+    required: ['title', 'name', 'icon'],
     additionalProperties: false,
 };
 /** Normalize a model-supplied icon to a single renderable glyph, or '' when
@@ -181,35 +206,42 @@ export function sanitizeIcon(raw) {
         return '';
     return points[0].codePointAt(0) >= 0x2000 ? trimmed : '';
 }
-/** Ask Pi headlessly for a structured {name, icon} for `body`, async. Resolves
- *  to a sanitized SessionName, or `{name:'',icon:''}` on timeout, a missing tool
- *  call, or a malformed emission so the caller can fall back to a local slug.
+/** Ask Pi headlessly for a structured {name, title, icon} for `body`, async.
+ *  Resolves to a sanitized SessionName, or `{name:'',title:'',icon:''}` on
+ *  timeout, a missing tool call, or a malformed emission so the caller can fall
+ *  back to the prompt's own words.
+ *
+ *  Nothing FORCES the tool call — constrained sampling shapes the arguments once
+ *  the model decides to call it — so a model that answers in prose instead gets
+ *  one more attempt before the caller falls back.
  *
  *  This module stays canvas-free so CLI leaves can reach it. The canvas-coupled
  *  commit path lives in pi-extensions/broker-local.ts, which imports this pure
  *  helper and writes through crtrd's guarded generated-name operation. */
 export async function headlessName(body, sourceCap = PROMPT_CAP) {
-    const empty = { name: '', icon: '' };
-    const route = nameModelRequest();
-    const emitted = await headlessToolCall({
+    const empty = { name: '', title: '', icon: '' };
+    const request = {
         systemPrompt: NAME_SYSTEM_PROMPT,
         userPrompt: nameUserPrompt(body, sourceCap),
-        ...route,
+        ...nameModelRequest(),
         timeoutMs: NAME_TIMEOUT_MS,
         tool: {
             name: 'name_session',
             label: 'Name session',
-            description: 'Record the name and icon for this coding session. Call exactly once, then stop.',
+            description: 'Record the title, name, and icon for this session. Call exactly once, then stop.',
             parameters: NAME_SESSION_SCHEMA,
             constrainedSampling: { type: 'json_schema', strict: 'prefer' },
         },
-    });
+    };
+    const emitted = await headlessToolCall(request) ?? await headlessToolCall(request);
     if (emitted === null || typeof emitted !== 'object')
         return empty;
     const parsed = emitted;
-    const name = sanitizeSessionName(typeof parsed['name'] === 'string' ? parsed['name'] : '');
+    const title = sanitizeSessionTitle(typeof parsed['title'] === 'string' ? parsed['title'] : '');
+    const name = sanitizeSessionName(typeof parsed['name'] === 'string' ? parsed['name'] : '')
+        || sanitizeSessionName(title);
     const icon = sanitizeIcon(typeof parsed['icon'] === 'string' ? parsed['icon'] : '');
-    return name !== '' ? { name, icon } : empty;
+    return name !== '' ? { name, title, icon } : empty;
 }
 /** Generate a name from a bounded conversation source rather than a single
  *  kickoff message. The caller owns selecting representative conversation text;

package/dist/core/runtime/reset.js

@@ -111,11 +111,18 @@ export async function relaunchRoot(oldId, deps = {}) {
         ...inv.env,
         CRTR_SUBTREE: rootOfSpine(newMeta.node_id),
     };
-    const placed = launchBroker(newMeta.node_id, inv, {
-        cwd: old.cwd,
-        name: fullName(newMeta),
-        resuming: false,
-    });
+    let placed;
+    try {
+        placed = launchBroker(newMeta.node_id, inv, {
+            cwd: old.cwd,
+            name: fullName(newMeta),
+            resuming: false,
+        });
+    }
+    catch (error) {
+        transition(newMeta.node_id, 'crash');
+        throw error;
+    }
     if (placed.pid == null) {
         // The new broker never started — crash the half-born node and BAIL. The old
         // root is still live and untouched (nothing below this point has run).

package/dist/core/runtime/revive-all.d.ts

@@ -7,16 +7,9 @@ import type { NodeMeta, NodeStatus } from '../canvas/types.js';
  *  is involuntary, so it is swept. (Silas, 2026-06-13: no opt-in to include these
  *  — the exclusion is unconditional.) */
 export declare const TERMINAL_BY_CHOICE: readonly NodeStatus[];
-/** True when `meta` has no natural future cycle ahead of it — either its own
- *  work is finished (`final_report` set) or it landed deliberately in one of
- *  TERMINAL_BY_CHOICE. Nothing in the runtime (daemon supervision, the live
- *  inbox watcher's own hold-and-flush) ever brings such a node back on its
- *  own — only an explicit revive/reopen does. Shared by `isDisconnected`
- *  (mass-revive scope, below) and `node message send --tier deferred`'s terminal-edge
- *  rejection — a deferred entry appended to such a target would
- *  never be delivered, so that doorway rejects instead of silently holding
- *  it forever. */
-export declare function hasNoNaturalCycle(meta: Pick<NodeMeta, 'status' | 'final_report'>): boolean;
+/** True when `meta` has no natural future cycle ahead of it. A frozen row is
+ *  excluded because its mark records a thaw cycle already owed. */
+export declare function hasNoNaturalCycle(meta: Pick<NodeMeta, 'status' | 'final_report' | 'frozen_at'>): boolean;
 /** True when `meta`'s engine is NOT running but it has a resumable saved session
  *  — the precise "disconnected" predicate.
  *
@@ -28,7 +21,7 @@ export declare function hasNoNaturalCycle(meta: Pick<NodeMeta, 'status' | 'final
  *    it — so such a node comes back fresh).
  *  - `human`-kind rows are the `crtr human` bridge, never a pi engine, so they
  *    are never "disconnected" (mirrors the daemon's superviseTick carve-out).
- *  - terminal-by-choice (`done`/`canceled`) is always excluded.
+ *  - unfrozen terminal-by-choice (`done`/`canceled`) is excluded.
  *  - a node that already pushed its FINAL REPORT (`final_report` set) FINISHED
  *    its own work — it is excluded regardless of status. A crash mid-reap can
  *    leave it `dead` (not terminal-by-choice) with its report already committed;

package/dist/core/runtime/revive-all.js

@@ -3,8 +3,8 @@
 // After a mass-disconnect event (a reboot, a killed login/tmux session, a mass
 // crash, or the daemon being down a while) many nodes end up with their
 // canvas.db row + saved conversation intact but NO broker engine running. The
-// daemon recovers active|idle rows during its explicit startup sweep and from
-// broker exit events during its own epoch, but it deliberately never touches
+// daemon recovers active|idle rows during its row-driven supervision tick and
+// from broker exit events during its own epoch, but it deliberately never touches
 // terminal/dormant states, so the operator is left reviving survivors one id at
 // a time.
 //
@@ -24,17 +24,10 @@ import { reviveNode } from './revive.js';
  *  is involuntary, so it is swept. (Silas, 2026-06-13: no opt-in to include these
  *  — the exclusion is unconditional.) */
 export const TERMINAL_BY_CHOICE = ['done', 'canceled'];
-/** True when `meta` has no natural future cycle ahead of it — either its own
- *  work is finished (`final_report` set) or it landed deliberately in one of
- *  TERMINAL_BY_CHOICE. Nothing in the runtime (daemon supervision, the live
- *  inbox watcher's own hold-and-flush) ever brings such a node back on its
- *  own — only an explicit revive/reopen does. Shared by `isDisconnected`
- *  (mass-revive scope, below) and `node message send --tier deferred`'s terminal-edge
- *  rejection — a deferred entry appended to such a target would
- *  never be delivered, so that doorway rejects instead of silently holding
- *  it forever. */
+/** True when `meta` has no natural future cycle ahead of it. A frozen row is
+ *  excluded because its mark records a thaw cycle already owed. */
 export function hasNoNaturalCycle(meta) {
-    return meta.final_report != null || TERMINAL_BY_CHOICE.includes(meta.status);
+    return meta.frozen_at == null && (meta.final_report != null || TERMINAL_BY_CHOICE.includes(meta.status));
 }
 /** True when `meta`'s engine is NOT running but it has a resumable saved session
  *  — the precise "disconnected" predicate.
@@ -47,7 +40,7 @@ export function hasNoNaturalCycle(meta) {
  *    it — so such a node comes back fresh).
  *  - `human`-kind rows are the `crtr human` bridge, never a pi engine, so they
  *    are never "disconnected" (mirrors the daemon's superviseTick carve-out).
- *  - terminal-by-choice (`done`/`canceled`) is always excluded.
+ *  - unfrozen terminal-by-choice (`done`/`canceled`) is excluded.
  *  - a node that already pushed its FINAL REPORT (`final_report` set) FINISHED
  *    its own work — it is excluded regardless of status. A crash mid-reap can
  *    leave it `dead` (not terminal-by-choice) with its report already committed;