@north-light/crouter 0.3.231 → 0.3.233

package/dist/core/substrate/surface-match.js

@@ -102,21 +102,173 @@ export function matchesMemoryReadEntry(entry, routingAnchor, subject, name) {
         return false;
     return entry.match.some((g) => memoryReadGlobMatches(g, routingAnchor, name));
 }
-/** A command glob is a STRING glob over the whole command line, not a path
- *  glob: `*` crosses every character (including `/` — command lines carry
- *  paths), `?` matches one. Translated to a regex rather than fed to
- *  `matchesGlob`, whose `*` stops at path separators. */
-function commandGlobMatches(glob, command) {
-    const rx = glob
+function splitCommandSegments(command) {
+    const segments = [];
+    let current = '';
+    let quote = null;
+    let escaped = false;
+    const finish = () => {
+        segments.push(current);
+        current = '';
+    };
+    for (let i = 0; i < command.length; i += 1) {
+        const ch = command[i];
+        if (escaped) {
+            current += ch;
+            escaped = false;
+            continue;
+        }
+        if (ch === '\\' && quote !== "'") {
+            current += ch;
+            escaped = true;
+            continue;
+        }
+        if (quote !== null) {
+            current += ch;
+            if (ch === quote)
+                quote = null;
+            continue;
+        }
+        if (ch === "'" || ch === '"') {
+            current += ch;
+            quote = ch;
+            continue;
+        }
+        if (ch === '\n' || ch === ';') {
+            finish();
+            continue;
+        }
+        if ((ch === '&' || ch === '|') && command[i + 1] === ch) {
+            finish();
+            i += 1;
+            continue;
+        }
+        if (ch === '|') {
+            finish();
+            continue;
+        }
+        current += ch;
+    }
+    finish();
+    return segments;
+}
+function tokenizeCommandSegment(segment) {
+    const tokens = [];
+    let text = '';
+    let opaque = false;
+    let started = false;
+    let quote = null;
+    let escaped = false;
+    const finish = () => {
+        if (started)
+            tokens.push({ text, opaque });
+        text = '';
+        opaque = false;
+        started = false;
+    };
+    for (let i = 0; i < segment.length; i += 1) {
+        const ch = segment[i];
+        if (escaped) {
+            text += ch;
+            started = true;
+            escaped = false;
+            continue;
+        }
+        if (ch === '\\' && quote !== "'") {
+            escaped = true;
+            started = true;
+            continue;
+        }
+        if (quote !== null) {
+            started = true;
+            if (ch === quote) {
+                quote = null;
+            }
+            else {
+                text += ch;
+            }
+            continue;
+        }
+        if (ch === "'" || ch === '"') {
+            quote = ch;
+            opaque = true;
+            started = true;
+            continue;
+        }
+        if (/\s/.test(ch)) {
+            finish();
+            continue;
+        }
+        text += ch;
+        started = true;
+    }
+    if (escaped)
+        text += '\\';
+    finish();
+    return tokens;
+}
+function commandSegments(command) {
+    return splitCommandSegments(command)
+        .map(tokenizeCommandSegment)
+        .map((tokens) => {
+        let first = 0;
+        while (first < tokens.length && /^[A-Za-z_][A-Za-z0-9_]*=/.test(tokens[first].text))
+            first += 1;
+        return tokens.slice(first);
+    })
+        .filter((tokens) => tokens.length > 0);
+}
+function commandGlobPattern(glob) {
+    const words = glob.trim().split(/\s+/);
+    if (words.length === 1 && words[0] === '')
+        return null;
+    const pattern = [];
+    for (const word of words) {
+        const parts = word.split('*');
+        for (let i = 0; i < parts.length; i += 1) {
+            if (parts[i] !== '')
+                pattern.push({ kind: 'literal', text: parts[i] });
+            if (i < parts.length - 1)
+                pattern.push({ kind: 'any' });
+        }
+    }
+    return pattern;
+}
+function tokenMatches(pattern, token) {
+    const rx = pattern
         .split('')
-        .map((ch) => (ch === '*' ? '[\\s\\S]*' : ch === '?' ? '[\\s\\S]' : ch.replace(/[.+^${}()|[\]\\]/g, '\\$&')))
+        .map((ch) => (ch === '?' ? '[\\s\\S]' : ch.replace(/[.+^${}()|[\]\\]/g, '\\$&')))
         .join('');
-    try {
-        return new RegExp(`^${rx}$`).test(command);
-    }
-    catch {
+    return new RegExp(`^${rx}$`).test(token);
+}
+function segmentMatches(pattern, tokens) {
+    const memo = new Map();
+    const match = (patternIndex, tokenIndex) => {
+        const key = `${patternIndex}:${tokenIndex}`;
+        const cached = memo.get(key);
+        if (cached !== undefined)
+            return cached;
+        let result;
+        if (patternIndex === pattern.length) {
+            result = tokenIndex === tokens.length;
+        }
+        else if (pattern[patternIndex].kind === 'any') {
+            result = match(patternIndex + 1, tokenIndex) || (tokenIndex < tokens.length && match(patternIndex, tokenIndex + 1));
+        }
+        else {
+            const token = tokens[tokenIndex];
+            result = token !== undefined && !token.opaque && tokenMatches(pattern[patternIndex].text, token.text) && match(patternIndex + 1, tokenIndex + 1);
+        }
+        memo.set(key, result);
+        return result;
+    };
+    return match(0, 0);
+}
+function commandGlobMatches(glob, command) {
+    const pattern = commandGlobPattern(glob);
+    if (pattern === null)
         return false;
-    }
+    return commandSegments(command).some((tokens) => segmentMatches(pattern, tokens));
 }
 /** Does a `command` entry fit the executed command string? */
 export function matchesCommandEntry(entry, subject, command) {
@@ -124,6 +276,53 @@ export function matchesCommandEntry(entry, subject, command) {
         return false;
     return entry.match.some((g) => commandGlobMatches(g, command));
 }
+const HEREDOC_OPEN = /<<(-?)\s*(["']?)([A-Za-z_][A-Za-z0-9_]*)\2/g;
+/** Remove heredoc BODIES (the stdin data between `<<DELIM` and its closing
+ *  `DELIM` line) from a command before it is matched. The opening line is kept
+ *  — `crtr push final <<'EOF'` is still a real `push final` invocation — but the
+ *  body lines, which are data fed on stdin and never executed as commands, are
+ *  dropped. Without this a doc-writing command whose body merely MENTIONS a
+ *  matched invocation would have its whole call held. Post-execution `command`
+ *  delivery does not need this (a spurious late injection costs a paragraph);
+ *  a `pre-command` block costs the agent a turn, so it does. */
+export function stripHeredocs(command) {
+    const lines = command.split('\n');
+    const out = [];
+    let i = 0;
+    while (i < lines.length) {
+        const line = lines[i];
+        out.push(line);
+        i += 1;
+        // Every heredoc opened on this line, left to right; their bodies stack and
+        // are consumed in that order.
+        const delims = [];
+        HEREDOC_OPEN.lastIndex = 0;
+        let m;
+        while ((m = HEREDOC_OPEN.exec(line)) !== null)
+            delims.push({ name: m[3], dash: m[1] === '-' });
+        for (const d of delims) {
+            while (i < lines.length) {
+                // `<<-` strips leading TABS from the body and the closing delimiter.
+                const probe = d.dash ? lines[i].replace(/^\t+/, '') : lines[i];
+                i += 1;
+                if (probe === d.name)
+                    break; // closing delimiter line — drop it, stop
+            }
+        }
+    }
+    return out.join('\n');
+}
+/** Does a `pre-command` entry fit a command that is ABOUT to run? The same
+ *  glob machinery `command` uses — one matcher, one semantics — applied to the
+ *  command with its heredoc bodies stripped. Subshell parentheses, backticks,
+ *  and path-prefixed binaries stay unhandled: this is a guardrail against the
+ *  faithful-but-uninformed action, not an enforcement boundary. */
+export function matchesPreCommandEntry(entry, subject, command) {
+    if (entry.on !== 'pre-command' || entry.match === undefined || !surfaceEntryGatePasses(entry, subject))
+        return false;
+    const stripped = stripHeredocs(command);
+    return entry.match.some((g) => commandGlobMatches(g, stripped));
+}
 // ---------------------------------------------------------------------------
 // Per-doc rung folds — a doc's delivery rung for one event occurrence is the
 // highest `at` over its matching entries of that event, `none` when none
@@ -179,3 +378,16 @@ export function commandDeliveryRung(doc, subject, command) {
     }
     return r;
 }
+/** The doc's delivery rung for a command about to run — the highest `at`
+ *  over the doc's matching `pre-command` entries, folded the same way as every
+ *  other event. */
+export function preCommandDeliveryRung(doc, subject, command) {
+    let r = 'none';
+    for (const e of doc.surfaces) {
+        if (!matchesPreCommandEntry(e, subject, command))
+            continue;
+        if (rungRank(e.at) > rungRank(r))
+            r = e.at;
+    }
+    return r;
+}

package/dist/core/termrender/version.d.ts

@@ -1 +1 @@
-export declare const TERMRENDER_VERSION = "4.12.10";
+export declare const TERMRENDER_VERSION = "4.12.11";

package/dist/core/termrender/version.js

@@ -1 +1 @@
-export const TERMRENDER_VERSION = '4.12.10';
+export const TERMRENDER_VERSION = '4.12.11';

package/dist/core/user-settings.js

@@ -197,7 +197,7 @@ export const CONFIG_SETTINGS_COVERAGE = {
         setting: {
             key: 'page_surface',
             label: 'Page human surface',
-            description: 'Prompt agents to use JSX pages by default for structured or interactive content shown to you.',
+            description: 'This host reads pages in a browser rather than a terminal. Agents are told the page module runs as written, HTML pages are offered, and document review and live display leave the command tree.',
             valueConstraint: 'true|false',
             applies: 'Applies when human command help is assembled.',
             group: 'display',

package/dist/daemon/api/__tests__/broker-settle-park.test.d.ts

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

package/dist/daemon/api/__tests__/broker-settle-park.test.js

@@ -0,0 +1,102 @@
+// Run with: node --conditions=crtr-src --import tsx/esm --test src/daemon/api/__tests__/broker-settle-park.test.ts
+//
+// The park clock hands terminalization to broker settlement: it arms a pending
+// park, delivers one summary prompt to the live engine, and this handler
+// decides what the ending turn meant. The defect surface is the re-evaluation —
+// the verdict the clock reached 15 minutes ago must not be enacted when the
+// summary turn itself created live work (a human ask, new wake-worthy mail, a
+// pushed final), and the pending park must be consumed exactly once regardless.
+import { after, before, beforeEach, test } from 'node:test';
+import assert from 'node:assert/strict';
+import { mkdtempSync, rmSync } from 'node:fs';
+import { createNode, getNode } from '../../../core/canvas/canvas.js';
+import { closeDb } from '../../../core/canvas/db.js';
+import { appendInbox } from '../../../core/feed/inbox.js';
+import { beginPendingPark, isPendingPark } from '../../park-pending.js';
+import { brokerOperationRoutes } from '../handlers/broker-ops.js';
+let home = '';
+let originalHome;
+const settleRoute = brokerOperationRoutes.find((route) => route.method === 'POST' && route.pattern === '/v1/nodes/:id/broker/settle');
+before(() => {
+    originalHome = process.env['CRTR_HOME'];
+    home = mkdtempSync('/tmp/crtr-settle-park-');
+    process.env['CRTR_HOME'] = home;
+});
+beforeEach(() => {
+    closeDb();
+    rmSync(home, { recursive: true, force: true });
+});
+after(() => {
+    closeDb();
+    rmSync(home, { recursive: true, force: true });
+    if (originalHome === undefined)
+        delete process.env['CRTR_HOME'];
+    else
+        process.env['CRTR_HOME'] = originalHome;
+});
+/** A live resident mid-parking-turn: the clock armed the park and the summary
+ *  turn is what is now settling. */
+function residentMidParkingTurn(id) {
+    const meta = {
+        node_id: id,
+        name: id,
+        created: new Date().toISOString(),
+        cwd: home,
+        kind: 'general',
+        mode: 'base',
+        lifecycle: 'resident',
+        status: 'active',
+    };
+    createNode(meta);
+    beginPendingPark(id, Date.now());
+}
+async function settle(id, over = {}) {
+    const ctx = {
+        method: 'POST',
+        path: `/v1/nodes/${id}/broker/settle`,
+        params: { id },
+        query: new URLSearchParams(),
+        body: {
+            stopReason: 'stop',
+            backgroundJobsRunning: false,
+            pushedFinal: false,
+            requestedHumanReply: false,
+            ...over,
+        },
+    };
+    return (await settleRoute.handler(ctx)).body;
+}
+test('a summary turn that ends with nothing new parks the node: done + intent=parked, no latch', async () => {
+    residentMidParkingTurn('summarized');
+    const directive = await settle('summarized');
+    assert.deepEqual(directive, { action: 'shutdown' });
+    const parked = getNode('summarized');
+    assert.equal(parked.status, 'done');
+    assert.equal(parked.intent, 'parked');
+    assert.equal(parked.final_report ?? null, null, 'a park never sets the finalization latch');
+    assert.equal(isPendingPark('summarized'), false, 'the pending park is consumed');
+});
+test('a human ask raised during the parking turn keeps the node live instead of parking it', async () => {
+    residentMidParkingTurn('asked');
+    const directive = await settle('asked', { requestedHumanReply: true });
+    assert.deepEqual(directive, { action: 'stay_dormant' });
+    assert.equal(getNode('asked').status, 'active', 'the node stays live awaiting its answer');
+    assert.equal(getNode('asked').intent ?? null, null);
+    assert.equal(isPendingPark('asked'), false, 'the park is discarded, not held for the next settle');
+});
+test('wake-worthy mail arriving during the parking turn flips the verdict back to release', async () => {
+    residentMidParkingTurn('mailed');
+    appendInbox('mailed', { from: null, tier: 'normal', kind: 'message', label: 'x', data: { body: 'work' } });
+    const directive = await settle('mailed');
+    assert.equal(directive.action, 'stay_dormant');
+    assert.equal(getNode('mailed').status, 'active', 're-evaluation saw the new obligation and did not park');
+    assert.equal(getNode('mailed').intent ?? null, null);
+    assert.equal(isPendingPark('mailed'), false);
+});
+test('a final pushed during the parking turn finishes the node rather than parking it', async () => {
+    residentMidParkingTurn('finished');
+    const directive = await settle('finished', { pushedFinal: true });
+    assert.deepEqual(directive, { action: 'shutdown' });
+    assert.equal(getNode('finished').intent ?? null, null, 'a pushed final is not a park');
+    assert.equal(isPendingPark('finished'), false);
+});

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

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

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 {};