@north-light/crouter 0.3.235 → 0.3.236

package/dist/commands/__tests__/node-new.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/commands/__tests__/node-new.test.js

@@ -0,0 +1,58 @@
+import { test } from 'node:test';
+import assert from 'node:assert/strict';
+import { createServer } from 'node:http';
+import { mkdtempSync, rmSync } from 'node:fs';
+import { join } from 'node:path';
+import { parseArgv } from '../../core/command.js';
+import { nodeNew } from '../node/create.js';
+function listen(server, path) {
+    return new Promise((resolve, reject) => {
+        server.once('error', reject);
+        server.listen(path, resolve);
+    });
+}
+function close(server) {
+    return new Promise((resolve, reject) => server.close((error) => error ? reject(error) : resolve()));
+}
+test('node new forwards --resident in the create request', async () => {
+    const previousHome = process.env['CRTR_HOME'];
+    const home = mkdtempSync('/tmp/crtr-node-new-resident-');
+    const socketPath = join(home, 'crtrd.sock');
+    let requestBody;
+    const server = createServer((req, res) => {
+        const chunks = [];
+        req.on('data', (chunk) => chunks.push(chunk));
+        req.on('end', () => {
+            requestBody = JSON.parse(Buffer.concat(chunks).toString('utf8'));
+            const body = JSON.stringify({
+                node_id: 'resident-test',
+                name: 'Review worker',
+                status: 'active',
+                cwd: home,
+            });
+            res.writeHead(201, { 'content-type': 'application/json', 'content-length': Buffer.byteLength(body) });
+            res.end(body);
+        });
+    });
+    process.env['CRTR_HOME'] = home;
+    try {
+        await listen(server, socketPath);
+        const input = await parseArgv(nodeNew.help.params ?? [], [
+            'Review the worker.',
+            '--root',
+            '--resident',
+            '--name',
+            'Review worker',
+        ]);
+        await nodeNew.run(input);
+        assert.equal(requestBody?.['root_lifecycle'], 'resident');
+    }
+    finally {
+        await close(server);
+        if (previousHome === undefined)
+            delete process.env['CRTR_HOME'];
+        else
+            process.env['CRTR_HOME'] = previousHome;
+        rmSync(home, { recursive: true, force: true });
+    }
+});

package/dist/commands/node/create.js

@@ -81,6 +81,7 @@ function nodeNewParams() {
         { kind: 'flag', name: 'parent', type: 'string', required: false, constraint: 'Parent node id. Defaults to the calling node.' },
         { kind: 'flag', name: 'node-id', type: 'string', required: false, constraint: 'Exact id for the new node; lowercase letters, digits, and hyphens only, at most 128 characters. Rejected if already present.' },
         { kind: 'flag', name: 'root', type: 'bool', required: false, constraint: 'Spawn an independent resident root with no parent or subscription. Mutually exclusive with --worktree.' },
+        { kind: 'flag', name: 'resident', type: 'bool', required: false, constraint: 'Birth the node as resident: it parks and stays wakeable without being forced to submit a final. Applies to managed children and roots; roots default to resident.' },
         { kind: 'flag', name: 'worktree', type: 'string', required: false, constraint: 'Local base branch for a crouter-managed worktree for this child. Mutually exclusive with --root.' },
         { kind: 'flag', name: 'fork-from', type: 'string', required: false, constraint: 'Fork the new node from an existing node id, absolute session path, or partial pi session uuid.' },
         {
@@ -179,6 +180,7 @@ async function runNodeCreation(input) {
     const name = input['name'];
     const parent = input['parent'];
     const root = input['root'] === true;
+    const resident = input['resident'] === true;
     const worktreeBaseRaw = input['worktree'];
     if (worktreeBaseRaw !== undefined && worktreeBaseRaw.trim() === '') {
         throw new InputError({ error: 'worktree_base_required', message: '--worktree requires a base branch', field: 'worktree', next: 'Pass an existing local branch that landing can fast-forward.' });
@@ -221,6 +223,7 @@ async function runNodeCreation(input) {
         ...(name !== undefined ? { name } : {}),
         prompt,
         ...(root ? { root: true } : { parent: parentId ?? null }),
+        ...(resident ? { root_lifecycle: 'resident' } : {}),
         ...(worktreeBase !== undefined ? { worktree: worktreeBase } : {}),
         ...(forkFrom !== undefined ? { fork_from: forkFrom } : {}),
         ...(modelSpec !== undefined ? { model: modelSpec } : {}),

package/dist/commands/node/lifecycle.js

@@ -247,7 +247,7 @@ export const nodePromote = defineLeaf({
         summary: 'promote yourself to an orchestrator when worthwhile parallel delegation should make coordination your primary job; task duration, sequential phases, or one helper do not qualify. Mode only — lifecycle stays as-is unless you pass --resident',
         params: [
             { kind: 'flag', name: 'kind', type: 'string', required: false, constraint: 'Specialize as this kind of orchestrator. The <kinds> list below names every top-level installable kind and when to use each; a registered sub-kind is valid too by exact path but not listed here. For an exact composed persona list, use `crtr sys prompt-review --list --kind <kind>` with the target kind. Defaults to your current kind. Promoting from a generic kind? CHOOSE a concrete one — it sets the orchestrator persona you revive into.' },
-            { kind: 'flag', name: 'resident', type: 'bool', required: false, constraint: 'ALSO flip lifecycle→resident: make the node interactable — it is never forced to submit a final, stays wakeable while attached or awaiting something live, and completes after the unattended grace otherwise. Omit to stay terminal/orchestrator (delegates + holds a roadmap, but still owes a final up the spine and reaps when done).' },
+            { kind: 'flag', name: 'resident', type: 'bool', required: false, constraint: 'ALSO flip lifecycle→resident: make the node interactable — it is never forced to submit a final, and unattended grace parks it after a summary turn instead, leaving it revivable fresh against its goal and roadmap. Omit to stay terminal/orchestrator (delegates + holds a roadmap, but still owes a final up the spine and reaps when done).' },
             { kind: 'flag', name: 'model', type: 'enum', choices: ['ultra', 'strong'], required: false, constraint: 'Change the model you run on, by capability tier: `ultra` (frontier — reserve for high-taste judgment or enormous work: speccing, planning something large, e2e-testing something hard to test) or `strong` (opus — regular dev work). Omit to keep your current model. An orchestrator steering work is never weaker than opus, so these are the only two choices; the change is durable across future revives.' },
             { kind: 'flag', name: 'node', type: 'string', required: false, constraint: 'Node to promote. Defaults to the caller (CRTR_NODE_ID).' },
         ],

package/dist/core/__tests__/canvas-inbox-watcher-naming.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/core/__tests__/canvas-inbox-watcher-naming.test.js

@@ -0,0 +1,258 @@
+// Tests for the naming/goal-capture gap on the durable-inbox delivery path.
+//
+// Run with: node --conditions=crtr-src --import tsx/esm --test src/core/__tests__/canvas-inbox-watcher-naming.test.ts
+//
+// A cold-booting child's first message falls to the durable inbox and pi's
+// `input` event never fires for it, so canvas-goal-capture's first-message
+// hooks (naming, goal capture) never run for it. The inbox watcher now mirrors
+// both on its own `kind: 'human'` visible delivery. This pins that mirror:
+// a human delivery reaches the naming pipeline and captures the goal, a
+// card/envelope delivery touches neither, and an already-described node's
+// naming call still fetches state (the daemon owns the compare-and-set) but
+// never issues a commit.
+//
+// The naming attempt is observed at the daemon socket exactly as in
+// canvas-goal-capture-envelope.test.ts: generateAndCommitInitialName starts by
+// asking crtrd for the node's projection (GET .../broker/extension-state), so
+// a request for a node id is proof the pipeline ran for it. An unnamed node's
+// GET is answered with an error — same as that file — so the test never
+// reaches the real headless model call; a "described" node's GET succeeds with
+// a non-empty description, which is enough to prove the guard short-circuits
+// before any commit (POST .../broker/generated-name) is sent.
+import { test, before, after, afterEach } from 'node:test';
+import assert from 'node:assert/strict';
+import { existsSync, mkdirSync, mkdtempSync, readFileSync, rmSync } from 'node:fs';
+import { createServer } from 'node:net';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import registerCanvasInboxWatcher from '../../pi-extensions/canvas-inbox-watcher.js';
+import { createNode } from '../canvas/canvas.js';
+import { closeDb } from '../canvas/db.js';
+import { apiSocketPath } from '../canvas/paths.js';
+import { appendInbox } from '../feed/inbox.js';
+const TICK_MS = 20;
+const DEBOUNCE_MS = 25;
+let home;
+let socket;
+const getRequests = [];
+const postRequests = [];
+/** node_id -> description the stub answers `extension-state` with. Absent =
+ *  the GET errors (mirrors canvas-goal-capture-envelope.test.ts: proof of
+ *  attempt without a real model call). Present (even '') = the GET succeeds. */
+const descriptions = new Map();
+function node(id) {
+    return {
+        node_id: id,
+        name: id,
+        created: new Date().toISOString(),
+        cwd: '/tmp/work',
+        kind: 'general',
+        mode: 'base',
+        lifecycle: 'terminal',
+        status: 'active',
+    };
+}
+function initialPromptPath(id) {
+    return join(home, 'nodes', id, 'context', 'initial-prompt.md');
+}
+function respond(connection, status, body) {
+    const json = JSON.stringify(body);
+    connection.end(`HTTP/1.1 ${status}\r\n`
+        + 'Content-Type: application/json\r\n'
+        + `Content-Length: ${Buffer.byteLength(json)}\r\n`
+        + 'Connection: close\r\n\r\n'
+        + json);
+}
+function nodeIdFromPath(path) {
+    return path.split('/nodes/')[1]?.split('/')[0] ?? '';
+}
+/** Every node's watcher fetches `extension-state` ONCE at session_start (to
+ *  seed report-node names for card rendering) regardless of what it later
+ *  delivers, so a bare presence check can't tell a startup fetch from a
+ *  naming-triggered one. Naming issues a SECOND, independent fetch for the
+ *  same node id — count occurrences instead of checking presence. */
+function getRequestCount(nodeId) {
+    return getRequests.filter((line) => line.includes(`/nodes/${nodeId}/`)).length;
+}
+function makeFakePi() {
+    const handlers = {};
+    return {
+        injected: [],
+        sentMessages: [],
+        on(e, h) { handlers[e] = h; },
+        sendUserMessage(content, options) { this.injected.push({ content, deliverAs: options?.deliverAs }); },
+        sendMessage(message) { this.sentMessages.push(message); },
+        fire(e, ev, ctx) { handlers[e]?.(ev, ctx); },
+    };
+}
+const wait = (ms) => new Promise((r) => setTimeout(r, ms));
+async function waitFor(predicate, timeoutMs = 3000, stepMs = 10) {
+    const deadline = Date.now() + timeoutMs;
+    while (Date.now() < deadline) {
+        if (predicate())
+            return;
+        await wait(stepMs);
+    }
+}
+const disposers = [];
+function registerWatcher(pi) {
+    const dispose = registerCanvasInboxWatcher(pi);
+    pi.fire('session_start', { type: 'session_start' }, undefined);
+    return dispose;
+}
+/** Point CRTR_HOME/CRTR_NODE_ID at this node and make sure it exists in canvas.db. */
+function freshNode(id) {
+    process.env['CRTR_NODE_ID'] = id;
+    createNode(node(id));
+}
+let origHome;
+let origNode;
+let origTick;
+let origDebounce;
+before(async () => {
+    origHome = process.env['CRTR_HOME'];
+    origNode = process.env['CRTR_NODE_ID'];
+    origTick = process.env['CRTR_WATCHER_TICK_MS'];
+    origDebounce = process.env['CRTR_WATCHER_DEBOUNCE_MS'];
+    home = mkdtempSync(join(tmpdir(), 'crtr-inbox-naming-'));
+    mkdirSync(join(home, 'nodes'), { recursive: true });
+    process.env['CRTR_HOME'] = home;
+    process.env['CRTR_WATCHER_TICK_MS'] = String(TICK_MS);
+    process.env['CRTR_WATCHER_DEBOUNCE_MS'] = String(DEBOUNCE_MS);
+    socket = createServer((connection) => {
+        connection.on('data', (chunk) => {
+            const raw = chunk.toString('utf8');
+            const requestLine = raw.split('\r\n')[0] ?? '';
+            const [method, path] = requestLine.split(' ');
+            if (method === 'GET' && path?.includes('/broker/extension-state')) {
+                getRequests.push(raw);
+                const nodeId = nodeIdFromPath(path);
+                if (!descriptions.has(nodeId)) {
+                    respond(connection, '500 Internal Server Error', { error: { code: 'internal', message: 'stub daemon' } });
+                    return;
+                }
+                respond(connection, '200 OK', {
+                    node: {
+                        node_id: nodeId, name: nodeId, description: descriptions.get(nodeId), kind: 'general',
+                        mode: 'base', lifecycle: 'terminal', status: 'active', cwd: '/tmp/work',
+                        parent: null, fork_from: null, profile_id: null, intent: null, created: new Date().toISOString(),
+                    },
+                    warm_spare: false, ancestors: [], children: [], fork_source: null,
+                    subject: { kind: 'general', mode: 'base', lifecycle: 'terminal', hasManager: false, cwd: '/tmp/work', scope: 'project', orchestration: { depth: 0 }, profile: null },
+                    report_nodes: [],
+                });
+                return;
+            }
+            if (method === 'POST' && path?.includes('/broker/generated-name')) {
+                postRequests.push(raw);
+                respond(connection, '200 OK', { applied: false });
+                return;
+            }
+            // Everything else (e.g. advanceBrokerInboxCursor) — a harmless error is
+            // fine: the watcher retries cursor commits later and never blocks
+            // visible delivery on them.
+            respond(connection, '500 Internal Server Error', { error: { code: 'internal', message: 'stub daemon' } });
+        });
+    });
+    await new Promise((resolve) => socket.listen(apiSocketPath(), resolve));
+});
+afterEach(() => {
+    while (disposers.length > 0)
+        disposers.pop()();
+});
+after(async () => {
+    closeDb();
+    await new Promise((resolve) => socket.close(() => resolve()));
+    rmSync(home, { recursive: true, force: true });
+    if (origHome === undefined)
+        delete process.env['CRTR_HOME'];
+    else
+        process.env['CRTR_HOME'] = origHome;
+    if (origNode === undefined)
+        delete process.env['CRTR_NODE_ID'];
+    else
+        process.env['CRTR_NODE_ID'] = origNode;
+    if (origTick === undefined)
+        delete process.env['CRTR_WATCHER_TICK_MS'];
+    else
+        process.env['CRTR_WATCHER_TICK_MS'] = origTick;
+    if (origDebounce === undefined)
+        delete process.env['CRTR_WATCHER_DEBOUNCE_MS'];
+    else
+        process.env['CRTR_WATCHER_DEBOUNCE_MS'] = origDebounce;
+});
+test('an inbox-delivered human first message reaches the naming pipeline and captures the goal', async () => {
+    freshNode('inbox-human-unnamed');
+    const pi = makeFakePi();
+    disposers.push(registerWatcher(pi));
+    await wait(TICK_MS + 100);
+    appendInbox('inbox-human-unnamed', {
+        from: 'human',
+        tier: 'normal',
+        kind: 'message',
+        label: 'build me a receipt tracker',
+        data: { body: 'build me a receipt tracker' },
+    });
+    await waitFor(() => pi.injected.length >= 1);
+    assert.equal(pi.injected[0].content, 'build me a receipt tracker', 'the human body still rides the visible digest verbatim');
+    // One GET at session_start (report-node seed) plus one from the naming
+    // pipeline (generateAndCommitInitialName's own state fetch) = 2.
+    await waitFor(() => getRequestCount('inbox-human-unnamed') >= 2);
+    assert.equal(getRequestCount('inbox-human-unnamed'), 2, 'an inbox-delivered human message reaches the same naming pipeline a live message does');
+    assert.equal(readFileSync(initialPromptPath('inbox-human-unnamed'), 'utf8').trim(), 'build me a receipt tracker', 'an inbox-delivered first message is also captured as the goal, for fresh-revive recovery');
+});
+test('a card/envelope delivery never reaches naming or goal capture', async () => {
+    freshNode('inbox-card-only');
+    const pi = makeFakePi();
+    const dispose = registerWatcher(pi);
+    await wait(TICK_MS + 100);
+    appendInbox('inbox-card-only', { from: 'child-9', tier: 'normal', kind: 'update', label: 'phase one done' });
+    await waitFor(() => pi.injected.length >= 1, 3000);
+    assert.equal(pi.injected.length, 1, 'the card still reaches the digest as a visible send');
+    dispose(); // release ownership of this node id before a second watcher binds a new one
+    // Clock: a human message to a DIFFERENT node whose naming pipeline we know
+    // fires (proven above). Once its GET lands, the card node's window to fire
+    // its own GET has already passed — the watcher fires naming synchronously
+    // off the same delivery cycle, not on a later timer.
+    freshNode('inbox-card-clock');
+    const clockPi = makeFakePi();
+    disposers.push(registerWatcher(clockPi));
+    await wait(TICK_MS + 100);
+    appendInbox('inbox-card-clock', { from: 'human', tier: 'normal', kind: 'message', label: 'clock', data: { body: 'clock' } });
+    await waitFor(() => getRequests.some((line) => line.includes('inbox-card-clock')));
+    // Exactly the one startup GET (report-node seed) — no second, naming-triggered fetch.
+    assert.equal(getRequestCount('inbox-card-only'), 1, 'a card/envelope delivery never asks the naming pipeline to name the node');
+    assert.equal(existsSync(initialPromptPath('inbox-card-only')), false, 'a card/envelope delivery never seeds a goal file either');
+});
+test('an already-described node fetches state but never commits a new name', async () => {
+    descriptions.set('inbox-already-named', 'existing-description');
+    freshNode('inbox-already-named');
+    const pi = makeFakePi();
+    const dispose = registerWatcher(pi);
+    await wait(TICK_MS + 100);
+    appendInbox('inbox-already-named', {
+        from: 'human',
+        tier: 'normal',
+        kind: 'message',
+        label: 'second thing to do',
+        data: { body: 'second thing to do' },
+    });
+    await waitFor(() => pi.injected.length >= 1);
+    // One GET at session_start plus one from the naming pipeline's own state
+    // fetch: the guard is checked AFTER this fetch resolves, not before it.
+    await waitFor(() => getRequestCount('inbox-already-named') >= 2);
+    assert.equal(getRequestCount('inbox-already-named'), 2, 'the naming pipeline still asks the daemon for the current projection');
+    dispose(); // release ownership of this node id before a second watcher binds a new one
+    // Clock: a second node's naming pipeline fires synchronously off the same
+    // delivery cycle (proven in the first test above). Once its GET has landed,
+    // this node's guard — checked in the very same .then() before any commit
+    // call — has already resolved one way or the other.
+    freshNode('inbox-commit-clock');
+    const clockPi = makeFakePi();
+    disposers.push(registerWatcher(clockPi));
+    await wait(TICK_MS + 100);
+    appendInbox('inbox-commit-clock', { from: 'human', tier: 'normal', kind: 'message', label: 'clock', data: { body: 'clock' } });
+    await waitFor(() => getRequests.some((line) => line.includes('inbox-commit-clock')));
+    await wait(DEBOUNCE_MS + 100);
+    assert.equal(postRequests.some((line) => line.includes('inbox-already-named')), false, 'an already-described node is untouched: the guard short-circuits before any generated-name commit');
+});

package/dist/core/__tests__/helpers/harness.js

@@ -505,6 +505,7 @@ export async function createHarness(opts = {}) {
                 prompt: task,
                 parent: parentId,
                 ...(o.mode !== undefined ? { mode: o.mode } : {}),
+                ...(o.lifecycle !== undefined ? { rootLifecycle: o.lifecycle } : {}),
                 ...(o.model !== undefined ? { model: o.model } : {}),
             });
             await harness.awaitBoot(result.node.node_id);

package/dist/core/__tests__/seam/dormancy-release.test.js

@@ -22,7 +22,7 @@ import assert from 'node:assert/strict';
 import { existsSync, readFileSync, writeFileSync } from 'node:fs';
 import { join } from 'node:path';
 import { appendInbox, readCursor, readInboxSince } from '../../feed/inbox.js';
-import { registerWarmSpare, subscribe, updateNode } from '../../canvas/index.js';
+import { registerWarmSpare, subscribe, subscriptionsOf, updateNode } from '../../canvas/index.js';
 import { isPidAlive } from '../../canvas/pid.js';
 import { reviveNode } from '../../runtime/revive.js';
 import { createHarness } from '../helpers/harness.js';
@@ -349,6 +349,75 @@ test('the unattended park clock cancels an obligation-free terminal node and spa
             process.env['CRTR_TEST_UNATTENDED_PARK_MS'] = priorParkMs;
     }
 });
+test('a resident managed child parks without finalizing while a terminal child is settled by the same grace sweep', { timeout: 40_000 }, async () => {
+    const priorParkMs = process.env['CRTR_TEST_UNATTENDED_PARK_MS'];
+    const priorGraceMs = process.env['CRTR_TEST_PARK_SUMMARY_GRACE_MS'];
+    process.env['CRTR_TEST_UNATTENDED_PARK_MS'] = '1500';
+    process.env['CRTR_TEST_PARK_SUMMARY_GRACE_MS'] = '1000';
+    try {
+        const resident = h.fabricateBrokerNode({
+            id: 'resident-managed-child',
+            parent: root,
+            lifecycle: 'resident',
+            status: 'idle',
+            intent: 'idle-release',
+            pi_session_id: 'resident-managed-session',
+        });
+        subscribe(root, resident, true);
+        // Keep a managed terminal child in the same sweep, but make its parent
+        // historical so no live subscriber remains to hold an unfinished report.
+        const terminalManager = h.fabricateBrokerNode({ id: 'terminal-manager', status: 'done' });
+        const terminal = h.fabricateBrokerNode({
+            id: 'terminal-managed-child',
+            parent: terminalManager,
+            lifecycle: 'terminal',
+            status: 'idle',
+            intent: 'idle-release',
+            pi_session_id: 'terminal-managed-session',
+        });
+        subscribe(terminalManager, terminal, true);
+        const boot = async (id) => {
+            updateNode(id, { launch: { extensions: [], tools: [], systemPrompt: '', env: {} } });
+            reviveNode(id, { resume: true });
+            return (await h.awaitBoot(id)).pid;
+        };
+        const residentPid = await boot(resident);
+        const terminalPid = await boot(terminal);
+        const seenAt = 50_000;
+        await h.tick(seenAt);
+        // Clock expiry arms the resident's pending park and requests its summary
+        // turn; the terminal child is cancelled outright by the same pass.
+        await h.tick(seenAt + 1500);
+        // Summary grace expiry: the degraded enactment parks without a report.
+        await h.tick(seenAt + 1500 + 1000);
+        await h.waitFor(() => h.node(resident)?.status === 'done' && h.node(resident)?.intent === 'parked' && !isPidAlive(residentPid), {
+            timeoutMs: 10_000,
+            intervalMs: 20,
+            label: 'resident managed child parks and releases its broker',
+        });
+        await h.waitFor(() => h.node(terminal)?.status === 'canceled' && !isPidAlive(terminalPid), {
+            timeoutMs: 10_000,
+            intervalMs: 20,
+            label: 'terminal managed child settles and releases its broker',
+        });
+        await h.awaitFleetExit(resident);
+        await h.awaitFleetExit(terminal);
+        assert.equal(h.node(resident)?.intent, 'parked', 'resident child carries the durable park marker, not a final');
+        assert.equal(h.node(resident)?.final_report ?? null, null, 'resident child has no forced final report');
+        assert.ok(subscriptionsOf(root).some((edge) => edge.node_id === resident && edge.active), 'resident child keeps its active parent subscription');
+        assert.equal(h.node(terminal)?.status, 'canceled', 'terminal child is settled by unattended grace without a final');
+    }
+    finally {
+        if (priorParkMs === undefined)
+            delete process.env['CRTR_TEST_UNATTENDED_PARK_MS'];
+        else
+            process.env['CRTR_TEST_UNATTENDED_PARK_MS'] = priorParkMs;
+        if (priorGraceMs === undefined)
+            delete process.env['CRTR_TEST_PARK_SUMMARY_GRACE_MS'];
+        else
+            process.env['CRTR_TEST_PARK_SUMMARY_GRACE_MS'] = priorGraceMs;
+    }
+});
 test('an unattended resident awaiting a live child remains wakeable', { timeout: 30_000 }, async () => {
     const priorParkMs = process.env['CRTR_TEST_UNATTENDED_PARK_MS'];
     process.env['CRTR_TEST_UNATTENDED_PARK_MS'] = '1500';

package/dist/core/canvas/types.d.ts

@@ -11,8 +11,8 @@
  *  only `dead` is a fault. */
 export type NodeStatus = 'active' | 'idle' | 'done' | 'dead' | 'canceled';
 /** Does stopping finalize the node? terminal = worker (finalizes on push --final);
- *  resident = interactable while attached or holding a live obligation. An
- *  unattended obligation-free resident completes after the daemon grace. */
+ *  resident = an interactable conversation that parks and remains wakeable
+ *  without being forced to submit a final. */
 export type Lifecycle = 'terminal' | 'resident';
 /** base = hands-on worker; orchestrator = delegating manager. Bespoke per kind. */
 export type Mode = 'base' | 'orchestrator';

package/dist/core/runtime/launch-target.js

@@ -32,7 +32,7 @@ export async function resolveLaunchTarget(req, options = {}) {
         await assertLaunchKind(kind, cwd, profileId);
     const mode = (req.mode ?? 'base');
     const launch = (await buildLaunchSpecAsync(kind, mode, {
-        lifecycle: req.root === true ? (req.root_lifecycle ?? 'resident') : 'terminal',
+        lifecycle: req.root_lifecycle ?? (req.root === true ? 'resident' : 'terminal'),
         hasManager: req.root !== true,
         ...(req.model !== undefined ? { model: req.model } : {}),
         cwd,

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

@@ -15,19 +15,11 @@ export interface SpawnChildOpts {
      *  subscription back to the spawner, spawned_by=spawner. Resident and brought
      *  forefront by default — see `rootLifecycle` for the unattended variant. */
     root?: boolean;
-    /** Only meaningful with `root`. The independent node's lifecycle.
-     *
-     *  `'resident'` (default) is the ATTENDED root: a standing conversation a
-     *  human picks up, so it owes no final, never reaps on its own, and is
-     *  brought forefront in tmux on spawn.
-     *
-     *  `'terminal'` is the UNATTENDED root: still parentless (nobody subscribes,
-     *  so nothing receives its push) but it still owes a final, so it reaps when
-     *  its work is done — and it is NEVER brought forefront. This is what
-     *  machinery firing with no human present must birth: the cron executor
-     *  spawns one when its cron's creating node is gone. A resident root there
-     *  would accrete one permanently-live node per fire (the count-based prune
-     *  never deletes live nodes) and steal the human's tmux focus every time. */
+    /** Lifecycle for the new node. Roots default to resident and managed
+     *  children default to terminal. A resident child remains an interactable,
+     *  wakeable conversation without owing a final; a terminal child remains a
+     *  bounded worker that must finalize. For roots, terminal keeps the
+     *  unattended no-viewer behavior. */
     rootLifecycle?: Lifecycle;
     /** Direct root creation waits until the broker accepts viewers before it
      *  returns. Cron-launched births use `launch`: the daemon must never wait in

package/dist/core/runtime/spawn.js

@@ -209,16 +209,10 @@ export async function spawnChildPrepared(opts, beforeBrokerLaunch) {
     const root = opts.root === true;
     const spawner = resolveSpawner(opts.parent, ctx.nodeId ?? null, root);
     const mode = opts.mode ?? 'base';
-    // Lifecycle keys on ROOT-ness only, independent of mode: an independent root
-    // (or `--root`) is resident by default (a conversation that persists, woken by
-    // inbox/human); every spawned child is terminal — it owes a final up the spine
-    // and reaps when done. A child born as an orchestrator is terminal/orchestrator
-    // (delegates + holds a roadmap, but still reports up), NOT resident.
-    //
-    // `rootLifecycle: 'terminal'` is the one deliberate exception: a parentless
-    // node that STILL owes a final (see the option's docblock). It is unattended
-    // by construction, so `attendedRoot` below also suppresses viewer placement.
-    const lifecycle = root ? (opts.rootLifecycle ?? 'resident') : 'terminal';
+    // Roots are resident by default; managed children are terminal workers by
+    // default. The one lifecycle option deliberately applies to both shapes so a
+    // child can be born as a standing, wakeable conversation too.
+    const lifecycle = opts.rootLifecycle ?? (root ? 'resident' : 'terminal');
     const attendedRoot = root && lifecycle === 'resident';
     // Born WITHOUT a name — the canvas-goal-capture extension names it async from
     // its first message (the kickoff task) inside its own pi process, so spawn

package/dist/daemon/api/handlers/nodes.js

@@ -108,9 +108,6 @@ function parseCreateBody(body) {
         rootLifecycle !== 'terminal') {
         throw usage("root_lifecycle must be 'resident' or 'terminal'");
     }
-    if (rootLifecycle !== undefined && b['root'] !== true) {
-        throw usage('root_lifecycle is only valid with root: true');
-    }
     return b;
 }
 /** Build the immediate spawn recipe. */

package/dist/pi-extensions/canvas-inbox-watcher.js

@@ -14,6 +14,7 @@
 import { envNodeId, envProfileId, envWatcherDebounceMs, envWatcherTickMs } from '../shared/env.js';
 import { coalesceBrokerInbox, entryCards, readBrokerCanceledEntryIds, readBrokerCursor, readBrokerInboxSince, reportRefNodeId, } from '../core/runtime/broker/inbox.js';
 import { advanceBrokerInboxCursor, brokerExtensionState } from '../core/runtime/broker/daemon-ops.js';
+import { captureGoalIfAbsent, generateAndCommitInitialName } from './broker-local.js';
 import { emitEvent } from '../core/events/emit.js';
 import { errorClassFromError } from '../core/events/errors.js';
 import { operationIdContext } from '../core/events/operation-id.js';
@@ -795,6 +796,17 @@ class CanvasInboxWatcher {
                 for (const entry of delivery.entries)
                     requeueEntryIds.add(entry.entry_id);
             }
+            else if (delivery.kind === 'human') {
+                // A person's own words, delivered through the durable inbox because the
+                // broker was cold when they arrived (crtrd's revive path, not pi's live
+                // socket). pi never fires its own `input` event for this path, so
+                // canvas-goal-capture's first-message hooks never run — mirror both here
+                // so an inbox-delivered first message names the node and survives a
+                // fresh revive exactly like a live-socket one. Both helpers are
+                // idempotent (no-op once a goal/description already exists).
+                captureGoalIfAbsent(nodeId, delivery.text);
+                generateAndCommitInitialName(nodeId, delivery.text);
+            }
         }
         return { inactive: false, requeueEntryIds };
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@north-light/crouter",
-  "version": "0.3.235",
+  "version": "0.3.236",
   "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.235",
+  "version": "0.3.236",
   "lockfileVersion": 3,
   "requires": true,
   "packages": {
     "": {
       "name": "@north-light/crouter",
-      "version": "0.3.235",
+      "version": "0.3.236",
       "hasInstallScript": true,
       "license": "MIT",
       "dependencies": {