@north-light/crouter 0.3.230 → 0.3.232

package/dist/daemon/api/__tests__/canvas-snapshot-fields.test.js

@@ -0,0 +1,188 @@
+import { after, before, test } from 'node:test';
+import assert from 'node:assert/strict';
+import { createServer } from 'node:net';
+import { mkdirSync, mkdtempSync, rmSync, writeFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { closeDb } from '../../../core/canvas/db.js';
+import { createNode, getNode } from '../../../core/canvas/canvas.js';
+import { contextDir, jobDir, viewSocketPath } from '../../../core/canvas/paths.js';
+import { recordFault } from '../../../core/runtime/fault.js';
+import { headlessBrokerHost } from '../../../core/runtime/host.js';
+import { handleCreate } from '../handlers/nodes.js';
+import { canvasRoutes } from '../handlers/canvas.js';
+let home = '';
+const previousHome = process.env['CRTR_HOME'];
+const brokers = [];
+const launchedBrokers = new Map();
+let originalLaunch;
+before(() => {
+    home = mkdtempSync('/tmp/crtr-snapshot-fields-');
+    process.env['CRTR_HOME'] = home;
+    originalLaunch = headlessBrokerHost.launch;
+    headlessBrokerHost.launch = (nodeId) => {
+        const broker = createServer();
+        brokers.push(broker);
+        launchedBrokers.set(nodeId, broker);
+        broker.listen(viewSocketPath(nodeId));
+        return { pid: process.pid, exited: new Promise(() => { }) };
+    };
+});
+after(async () => {
+    headlessBrokerHost.launch = originalLaunch;
+    await Promise.all(brokers.map((broker) => new Promise((resolve) => {
+        if (broker.listening)
+            broker.close(() => resolve());
+        else
+            resolve();
+    })));
+    closeDb();
+    rmSync(home, { recursive: true, force: true });
+    if (previousHome === undefined)
+        delete process.env['CRTR_HOME'];
+    else
+        process.env['CRTR_HOME'] = previousHome;
+});
+function meta(nodeId, overrides = {}) {
+    return {
+        node_id: nodeId,
+        name: nodeId,
+        created: new Date().toISOString(),
+        cwd: home,
+        kind: 'general',
+        mode: 'base',
+        lifecycle: 'resident',
+        status: 'idle',
+        host_kind: null,
+        profile_id: null,
+        parent: null,
+        ...overrides,
+    };
+}
+function request(method, path, body) {
+    return {
+        method,
+        path,
+        params: {},
+        query: new URLSearchParams(),
+        body,
+    };
+}
+function snapshotRoute() {
+    const route = canvasRoutes.find((entry) => entry.method === 'GET' && entry.pattern === '/v1/canvas/snapshot');
+    assert.ok(route, 'snapshot route exists');
+    return route;
+}
+/** A live broker is the pid + view socket pair used by isBrokerLive(). */
+async function listenFor(nodeId) {
+    const broker = createServer();
+    brokers.push(broker);
+    await new Promise((resolve, reject) => {
+        broker.once('error', reject);
+        broker.listen(viewSocketPath(nodeId), resolve);
+    });
+    return broker;
+}
+function activeJob(nodeId) {
+    const id = `${Date.now()}-snapshot-test`;
+    const dir = join(contextDir(nodeId), 'jobs', id);
+    mkdirSync(dir, { recursive: true });
+    writeFileSync(join(dir, 'cmd.sh'), 'printf live');
+    writeFileSync(join(dir, 'job.bg'), '');
+}
+test('one canvas snapshot carries title, brief, jobs, busy, latch, fault, and controller facts', async () => {
+    // Use the public create request for the brief: A2's birth contract is the
+    // source of the description that A3 must expose without a follow-up read.
+    const created = await handleCreate(request('POST', '/v1/nodes', {
+        kind: 'general',
+        root: true,
+        profile: null,
+        cwd: home,
+        prompt: '',
+        name: 'Live outcome',
+        description: 'Review the live outcome',
+    }));
+    const liveJobId = created.body.node_id;
+    activeJob(liveJobId);
+    const busyId = 'snapshot-busy';
+    createNode(meta(busyId, {
+        name: 'Busy outcome',
+        parent: liveJobId,
+        host_kind: 'broker',
+        pi_pid: process.pid,
+    }));
+    writeFileSync(join(jobDir(busyId), 'busy'), '');
+    const finalId = 'snapshot-final';
+    const finalizedAt = new Date().toISOString();
+    createNode(meta(finalId, {
+        name: 'Final outcome',
+        parent: liveJobId,
+        lifecycle: 'terminal',
+        status: 'done',
+        final_report: 'final.md',
+        finalized_at: finalizedAt,
+    }));
+    const faultId = 'snapshot-fault';
+    createNode(meta(faultId, {
+        name: 'Fault outcome',
+        parent: liveJobId,
+        status: 'dead',
+    }));
+    recordFault(faultId, {
+        link: 'viewer↔broker',
+        op: 'snapshot-test',
+        kind: 'connection',
+        retry: { disposition: 'manual', by: 'client' },
+        message: 'forced snapshot fault',
+    });
+    const controllerId = 'snapshot-controller';
+    createNode(meta(controllerId, { name: 'Controller', parent: liveJobId }));
+    const waitingId = 'snapshot-waiting';
+    createNode(meta(waitingId, {
+        name: 'Waiting outcome',
+        parent: liveJobId,
+        waiting_for: controllerId,
+    }));
+    const liveBroker = launchedBrokers.get(liveJobId);
+    assert.ok(liveBroker, 'created node has a live broker');
+    const busyBroker = await listenFor(busyId);
+    try {
+        const result = await snapshotRoute().handler(request('GET', '/v1/canvas/snapshot'));
+        const body = result.body;
+        const byId = new Map(body.nodes.map((node) => [node['node_id'], node]));
+        const live = byId.get(liveJobId);
+        assert.ok(live);
+        assert.equal(live['title'], 'Live outcome');
+        assert.equal(live['description'], 'Review the live outcome');
+        assert.equal(live['name'], 'Live outcome Review the live outcome');
+        assert.equal(live['jobs_active'], 1);
+        assert.equal(live['streaming'], false);
+        assert.equal(live['waiting_for'], null);
+        const busy = byId.get(busyId);
+        assert.ok(busy);
+        assert.equal(busy['title'], 'Busy outcome');
+        assert.equal(busy['jobs_active'], 0);
+        assert.equal(busy['streaming'], true);
+        const final = byId.get(finalId);
+        assert.ok(final);
+        assert.equal(final['title'], 'Final outcome');
+        assert.equal(final['final_report'], 'final.md');
+        assert.equal(final['finalized_at'], finalizedAt);
+        const fault = byId.get(faultId);
+        assert.ok(fault);
+        const hanging = fault['hanging'];
+        assert.equal(hanging.link, 'viewer↔broker');
+        assert.equal(hanging.op, 'snapshot-test');
+        assert.equal(hanging.kind, 'connection');
+        assert.deepEqual(hanging.retry, { disposition: 'manual', by: 'client' });
+        assert.equal(hanging.message, 'forced snapshot fault');
+        const waiting = byId.get(waitingId);
+        assert.ok(waiting);
+        assert.equal(waiting['title'], 'Waiting outcome');
+        assert.equal(waiting['waiting_for'], controllerId);
+        assert.equal(waiting['jobs_active'], 0);
+    }
+    finally {
+        await Promise.all([liveBroker, busyBroker].map((broker) => new Promise((resolve) => broker.close(() => resolve()))));
+    }
+    assert.ok(getNode(liveJobId));
+});

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

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

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

@@ -0,0 +1,83 @@
+import { after, before, test } from 'node:test';
+import assert from 'node:assert/strict';
+import { createServer } from 'node:net';
+import { mkdtempSync, rmSync } from 'node:fs';
+import { join } from 'node:path';
+import { closeDb } from '../../../core/canvas/db.js';
+import { getNode } from '../../../core/canvas/canvas.js';
+import { nodeDir } from '../../../core/canvas/paths.js';
+import { headlessBrokerHost } from '../../../core/runtime/host.js';
+import { handleCreate, nodeRoutes } from '../handlers/nodes.js';
+import { brokerOperationRoutes } from '../handlers/broker-ops.js';
+let home = '';
+let originalHome;
+let originalLaunch;
+const brokers = [];
+before(() => {
+    originalHome = process.env['CRTR_HOME'];
+    // macOS Unix-domain sockets have a short path limit; keep the canvas home short.
+    home = mkdtempSync('/tmp/crtr-node-description-');
+    process.env['CRTR_HOME'] = home;
+    originalLaunch = headlessBrokerHost.launch;
+    headlessBrokerHost.launch = (nodeId) => {
+        const broker = createServer();
+        brokers.push(broker);
+        broker.listen(join(nodeDir(nodeId), 'view.sock'));
+        return { pid: process.pid, exited: new Promise(() => { }) };
+    };
+});
+after(async () => {
+    headlessBrokerHost.launch = originalLaunch;
+    await Promise.all(brokers.map((broker) => new Promise((resolve) => {
+        if (broker.listening)
+            broker.close(() => resolve());
+        else
+            resolve();
+    })));
+    closeDb();
+    rmSync(home, { recursive: true, force: true });
+    if (originalHome === undefined)
+        delete process.env['CRTR_HOME'];
+    else
+        process.env['CRTR_HOME'] = originalHome;
+});
+function context(method, path, id, body) {
+    return {
+        method,
+        path,
+        params: id === undefined ? {} : { id },
+        query: new URLSearchParams(),
+        body,
+    };
+}
+test('node create stores caller description and automatic naming leaves it and name unchanged', async () => {
+    const created = await handleCreate(context('POST', '/v1/nodes', undefined, {
+        kind: 'general',
+        root: true,
+        profile: null,
+        cwd: home,
+        prompt: '',
+        name: 'Review worker',
+        description: 'Review the worker conversation',
+    }));
+    assert.equal(created.status, 201);
+    const nodeId = created.body.node_id;
+    const detailRoute = nodeRoutes.find((route) => route.method === 'GET' && route.pattern === '/v1/nodes/:id');
+    assert.ok(detailRoute);
+    const detail = await detailRoute.handler(context('GET', `/v1/nodes/${nodeId}`, nodeId));
+    assert.equal(detail.body.name, 'Review worker');
+    assert.equal(detail.body.description, 'Review the worker conversation');
+    const generatedNameRoute = brokerOperationRoutes.find((route) => route.method === 'POST' && route.pattern === '/v1/nodes/:id/broker/generated-name');
+    assert.ok(generatedNameRoute);
+    const generated = await generatedNameRoute.handler(context('POST', `/v1/nodes/${nodeId}/broker/generated-name`, nodeId, {
+        kind: 'initial',
+        description: 'Generated replacement',
+        icon: '',
+    }));
+    assert.deepEqual(generated.body, { applied: false });
+    assert.equal(getNode(nodeId)?.name, 'Review worker');
+    assert.equal(getNode(nodeId)?.description, 'Review the worker conversation');
+    const fetched = await detailRoute.handler(context('GET', `/v1/nodes/${nodeId}`, nodeId));
+    assert.equal(fetched.body.name, 'Review worker');
+    assert.equal(fetched.body.description, 'Review the worker conversation');
+});

package/dist/daemon/api/__tests__/profile-metadata-route.test.d.ts

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

package/dist/daemon/api/__tests__/profile-metadata-route.test.js

@@ -0,0 +1,92 @@
+import { after, afterEach, beforeEach, test } from 'node:test';
+import assert from 'node:assert/strict';
+import { mkdtempSync, rmSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import { routes } from '../../../api/index.js';
+import { CrtrError } from '../../../core/errors.js';
+import { closeDb } from '../../../core/canvas/db.js';
+import { createProfile, loadProfileManifest } from '../../../core/profiles/manifest.js';
+import { resetScopeCache } from '../../../core/scope.js';
+import { profileRoutes } from '../handlers/profiles.js';
+const previousCrtrHome = process.env['CRTR_HOME'];
+const previousHome = process.env.HOME;
+let home = '';
+beforeEach(() => {
+    closeDb();
+    home = mkdtempSync(join(tmpdir(), 'crtr-profile-metadata-home-'));
+    process.env.HOME = home;
+    process.env['CRTR_HOME'] = join(home, 'canvas');
+    resetScopeCache();
+});
+afterEach(() => {
+    closeDb();
+    rmSync(home, { recursive: true, force: true });
+    resetScopeCache();
+});
+after(() => {
+    if (previousHome === undefined)
+        delete process.env.HOME;
+    else
+        process.env.HOME = previousHome;
+    if (previousCrtrHome === undefined)
+        delete process.env['CRTR_HOME'];
+    else
+        process.env['CRTR_HOME'] = previousCrtrHome;
+    resetScopeCache();
+});
+function route(method, pattern) {
+    const found = profileRoutes.find((entry) => entry.method === method && entry.pattern === pattern);
+    assert.ok(found, `missing ${method} ${pattern} route`);
+    return found;
+}
+function context(params, body) {
+    return {
+        method: 'PATCH',
+        path: routes.profileMetadata(params['name']),
+        params,
+        query: new URLSearchParams(),
+        body,
+    };
+}
+async function invoke(entry, ctx) {
+    return entry.handler(ctx);
+}
+test('PATCH metadata updates an existing profile and GET returns the opaque value', async () => {
+    const profile = createProfile('worker profile');
+    assert.deepEqual(loadProfileManifest(profile.profileId).manifest.metadata, undefined);
+    const patch = route('PATCH', '/v1/profiles/:name/metadata');
+    const patched = await invoke(patch, context({ name: profile.manifest.name }, {
+        set: { northlight_default_node_id: 'nlw-applet-42' },
+    }));
+    assert.equal(patched.status, 200);
+    assert.deepEqual(patched.body.metadata, {
+        northlight_default_node_id: 'nlw-applet-42',
+    });
+    const get = route('GET', '/v1/profiles/:name');
+    const read = await invoke(get, context({ name: profile.manifest.name }, undefined));
+    assert.deepEqual(read.body.metadata, {
+        northlight_default_node_id: 'nlw-applet-42',
+    });
+});
+test('PATCH metadata rejects an unknown profile and invalid metadata keys', async () => {
+    const patch = route('PATCH', '/v1/profiles/:name/metadata');
+    await assert.rejects(() => invoke(patch, context({ name: 'missing-profile' }, { set: { role: 'worker' } })), (error) => error instanceof CrtrError && error.code === 'not_found');
+    const profile = createProfile('metadata validation');
+    await assert.rejects(() => invoke(patch, context({ name: profile.manifest.name }, { set: { 'not a key': 'value' } })), (error) => error instanceof CrtrError && error.code === 'usage');
+    assert.deepEqual(loadProfileManifest(profile.profileId).manifest.metadata, undefined);
+});
+test('PUT remains create-only after a metadata PATCH', async () => {
+    const profile = createProfile('create-only profile');
+    const patch = route('PATCH', '/v1/profiles/:name/metadata');
+    await invoke(patch, context({ name: profile.manifest.name }, { set: { role: 'worker' } }));
+    const ensure = route('PUT', '/v1/profiles/:name');
+    const result = await invoke(ensure, {
+        ...context({ name: profile.manifest.name }, { metadata: { role: 'changed' } }),
+        method: 'PUT',
+        path: routes.profile(profile.manifest.name),
+    });
+    assert.deepEqual(result.body.metadata, {
+        role: 'worker',
+    });
+});

package/dist/daemon/api/__tests__/reopen-delivery.test.d.ts

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

package/dist/daemon/api/__tests__/reopen-delivery.test.js

@@ -0,0 +1,173 @@
+import { after, before, beforeEach, test } from 'node:test';
+import assert from 'node:assert/strict';
+import { mkdtempSync, rmSync } from 'node:fs';
+import { createServer } from 'node:net';
+import { createNode, getNode, openDb } from '../../../core/canvas/index.js';
+import { closeDb } from '../../../core/canvas/db.js';
+import { viewSocketPath } from '../../../core/canvas/paths.js';
+import { readInboxSince } from '../../../core/feed/inbox.js';
+import { headlessBrokerHost } from '../../../core/runtime/host.js';
+import { messageRoutes } from '../handlers/messages.js';
+let home;
+const priorHome = process.env['CRTR_HOME'];
+before(() => {
+    // macOS limits Unix-socket paths to 104 bytes; the system temp directory's
+    // per-user prefix is already most of that budget.
+    home = mkdtempSync('/tmp/crtr-reopen-');
+    process.env['CRTR_HOME'] = home;
+});
+beforeEach(() => {
+    closeDb();
+    rmSync(home, { recursive: true, force: true });
+});
+after(() => {
+    closeDb();
+    rmSync(home, { recursive: true, force: true });
+    if (priorHome === undefined)
+        delete process.env['CRTR_HOME'];
+    else
+        process.env['CRTR_HOME'] = priorHome;
+});
+function node(id, lifecycle, status, piPid) {
+    return {
+        node_id: id,
+        name: id,
+        created: new Date().toISOString(),
+        cwd: '/tmp',
+        kind: 'general',
+        mode: 'base',
+        lifecycle,
+        status,
+        ...(piPid !== undefined ? { pi_pid: piPid } : {}),
+    };
+}
+function finalize(id) {
+    openDb()
+        .prepare("UPDATE nodes SET final_report = ?, finalized_at = ? WHERE node_id = ?")
+        .run('final.md', new Date().toISOString(), id);
+}
+async function sendMessage(id, body) {
+    const ctx = {
+        method: 'POST',
+        path: `/v1/nodes/${id}/messages`,
+        params: { id },
+        query: new URLSearchParams(),
+        body,
+    };
+    return messageRoutes[0].handler(ctx);
+}
+async function startLiveBroker(id, failDelivery = false) {
+    let observed = null;
+    const server = createServer((socket) => {
+        let pending = '';
+        socket.on('data', (chunk) => {
+            pending += chunk.toString('utf8');
+            let newline = pending.indexOf('\n');
+            while (newline !== -1) {
+                const line = pending.slice(0, newline);
+                pending = pending.slice(newline + 1);
+                const frame = JSON.parse(line);
+                if (frame.type === 'deliver') {
+                    observed = getNode(id);
+                    socket.write(`${JSON.stringify({
+                        type: 'ack',
+                        for: 'deliver',
+                        id: frame.id,
+                        ok: !failDelivery,
+                        detail: failDelivery ? 'forced delivery failure' : 'prompt',
+                    })}\n`);
+                }
+                newline = pending.indexOf('\n');
+            }
+        });
+    });
+    await new Promise((resolve, reject) => {
+        server.once('error', reject);
+        server.listen(viewSocketPath(id), resolve);
+    });
+    return {
+        close: () => closeServer(server),
+        deliveryState: () => observed,
+    };
+}
+function closeServer(server) {
+    return new Promise((resolve, reject) => server.close((err) => (err === undefined ? resolve() : reject(err))));
+}
+function assertReopened(id) {
+    const meta = getNode(id);
+    assert.equal(meta?.lifecycle, 'resident');
+    assert.equal(meta?.final_report, null);
+}
+test('reopen makes live terminal, finalized terminal, and parked targets resident and unlatched before delivery', async () => {
+    const liveId = 'live-terminal';
+    createNode(node(liveId, 'terminal', 'active', process.pid));
+    const liveBroker = await startLiveBroker(liveId);
+    try {
+        const result = await sendMessage(liveId, { body: 'continue live work', reopen: true, delivery: 'interactive' });
+        assert.equal(result.body.delivered_via, 'engine');
+        assertReopened(liveId);
+        assert.equal(liveBroker.deliveryState()?.lifecycle, 'resident', 'engine delivery sees resident lifecycle');
+        assert.equal(liveBroker.deliveryState()?.final_report, null, 'engine delivery sees no final latch');
+        assert.equal(readInboxSince(liveId).length, 0, 'live delivery does not append an inbox entry');
+    }
+    finally {
+        await liveBroker.close();
+    }
+    const originalLaunch = headlessBrokerHost.launch;
+    headlessBrokerHost.launch = (() => ({ pid: 0x7ffffffe, exited: Promise.resolve({ code: 0, signal: null }) }));
+    try {
+        const finalizedId = 'finalized-terminal';
+        createNode(node(finalizedId, 'terminal', 'done'));
+        finalize(finalizedId);
+        await sendMessage(finalizedId, { body: 'new mandate', reopen: true });
+        assertReopened(finalizedId);
+        assert.equal(readInboxSince(finalizedId).length, 1, 'finalized target receives its durable message after reopening');
+        const parkedId = 'parked-resident';
+        createNode(node(parkedId, 'resident', 'done'));
+        await sendMessage(parkedId, { body: 'resume the parked session', reopen: true });
+        assertReopened(parkedId);
+        assert.equal(readInboxSince(parkedId).length, 1, 'parked target receives its durable message after reopening');
+    }
+    finally {
+        headlessBrokerHost.launch = originalLaunch;
+    }
+});
+test('a reopen commit failure delivers nothing', async () => {
+    const id = 'commit-failure';
+    createNode(node(id, 'terminal', 'done'));
+    finalize(id);
+    const finalReport = getNode(id)?.final_report;
+    openDb().exec(`
+    CREATE TRIGGER fail_reopen_latch_clear
+    BEFORE UPDATE OF final_report ON nodes
+    WHEN NEW.final_report IS NULL
+    BEGIN
+      SELECT RAISE(FAIL, 'forced reopen failure');
+    END;
+  `);
+    try {
+        await assert.rejects(() => sendMessage(id, { body: 'must not deliver', reopen: true }), /forced reopen failure/);
+    }
+    finally {
+        openDb().exec('DROP TRIGGER IF EXISTS fail_reopen_latch_clear');
+    }
+    assert.equal(getNode(id)?.lifecycle, 'resident', 'lifecycle commit precedes the failed latch CAS');
+    assert.equal(getNode(id)?.final_report, finalReport, 'a failed CAS preserves the canonical-final pointer');
+    assert.equal(readInboxSince(id).length, 0, 'no inbox entry precedes a failed reopen commit');
+});
+test('a delivery failure after reopen leaves the target resident, unlatched, and without a message', async () => {
+    const id = 'delivery-failure';
+    createNode(node(id, 'terminal', 'done', process.pid));
+    finalize(id);
+    const broker = await startLiveBroker(id, true);
+    try {
+        await assert.rejects(() => sendMessage(id, { body: 'broker rejects this', reopen: true, delivery: 'interactive' }), /forced delivery failure/);
+        assertReopened(id);
+        assert.equal(broker.deliveryState()?.lifecycle, 'resident', 'failed engine delivery happened after reopen committed');
+        assert.equal(broker.deliveryState()?.final_report, null, 'failed engine delivery saw the cleared latch');
+        assert.equal(readInboxSince(id).length, 0, 'failed engine delivery creates no durable fallback message');
+    }
+    finally {
+        await broker.close();
+    }
+});

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

@@ -16,6 +16,8 @@ import { evaluateStop } from '../../../core/runtime/stop-guard.js';
 import { clearFault } from '../../../core/runtime/fault.js';
 import { updateModelRecipe } from '../../../core/runtime/model-swap.js';
 import { completeCompanionRequestedSubmit } from '../../review/finish.js';
+import { consumePendingPark } from '../../park-pending.js';
+import { parkEvent } from '../../reconcilers/live-obligation.js';
 function objectBody(body, operation) {
     if (typeof body !== 'object' || body === null || Array.isArray(body)) {
         throw usage(`${operation} requires a JSON body`);
@@ -229,6 +231,11 @@ function hasUnseenNonDeferredInbox(nodeId) {
  * boundary. This handler intentionally never invokes the broker that called it:
  * the returned directive is the only Pi-side consequence. */
 function settleBroker(nodeId, request) {
+    // A parking turn in flight ends HERE, whatever it ended as. Consuming
+    // unconditionally is the abort rule expressed once: every early return below
+    // — clean quit, pushed final, human ask, interrupted turn, refresh — discards
+    // the park and leaves the node live under a restarted clock.
+    const parkPending = consumePendingPark(nodeId);
     const node = getNode(nodeId);
     if (node === null) {
         // A command may have recorded its Pi-local completion marker just as an
@@ -274,6 +281,20 @@ function settleBroker(nodeId, request) {
         clearFault(nodeId);
         return { action: 'shutdown' };
     }
+    // The parking turn just ended. Re-evaluate the verdict the clock reached
+    // before this turn ran: a `crtr human send`, new wake-worthy mail, a fresh
+    // subscription to a child it spawned, or a pending structured-output request
+    // all make the node live work again, and the ordinary stop policy applies
+    // instead. `pushedFinal` was checked above, so a node that finished during
+    // its parking turn ends latched rather than parked.
+    if (parkPending && parkEvent(nodeId, node.lifecycle) === 'park') {
+        clearFault(nodeId);
+        transition(nodeId, 'park');
+        if (focusOf(nodeId) !== null)
+            tearDownNode(nodeId);
+        setPresence(nodeId, { pane: null, tmux_session: null, window: null });
+        return { action: 'shutdown' };
+    }
     const decision = evaluateStop(nodeId, signals, request.backgroundJobsRunning);
     clearFault(nodeId);
     if (decision.action === 'reprompt')

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

@@ -13,6 +13,9 @@ import { existsSync, readdirSync } from 'node:fs';
 import { join } from 'node:path';
 import { listNodes, nowIso, ticketsAcrossCanvas } from '../../../index.js';
 import { getNode, pruneNodes, pruneToLimit, rebuildIndex, rosterEdges, rosterNodes, subscriptionsOf } from '../../../core/canvas/canvas.js';
+import { activeBackgroundBashJobs } from '../../../core/bash-jobs.js';
+import { contextDir } from '../../../core/canvas/paths.js';
+import { isBrokerLive } from '../../../core/runtime/model-swap.js';
 import { dashboardRowsAll, enrichRows } from '../../../core/canvas/render.js';
 import { ticketCountsForNodes } from '../../../core/canvas/attention.js';
 import { buildCorpus, resolveRef, } from '../../../core/canvas/history.js';
@@ -26,6 +29,7 @@ function handleAttention() {
             name: t.name,
             cwd: t.cwd,
             count: t.count,
+            subjects: t.subjects,
         })),
     };
     return { status: 200, body };
@@ -273,6 +277,8 @@ function handleSnapshot() {
         return {
             node_id: row.node_id,
             name: row.name,
+            title: meta?.name ?? row.name,
+            description: meta?.description ?? null,
             kind: row.kind,
             mode: row.mode,
             lifecycle: row.lifecycle ?? meta?.lifecycle,
@@ -288,6 +294,10 @@ function handleSnapshot() {
             ...(row.mtimeMs !== undefined ? { last_activity: new Date(row.mtimeMs).toISOString() } : {}),
             ctx_tokens: row.ctx_tokens,
             streaming: row.streaming ?? false,
+            jobs_active: meta !== null && isBrokerLive(meta)
+                ? activeBackgroundBashJobs(contextDir(row.node_id)).length
+                : 0,
+            waiting_for: meta?.waiting_for ?? null,
             hanging: (row.hanging ?? null),
             viewed: row.viewed ?? false,
             final_report: meta?.final_report ?? null,