@north-light/crouter 0.3.216 → 0.3.218

package/dist/core/memory/extensions.js

@@ -0,0 +1,219 @@
+import { sep } from 'node:path';
+import { listInstalledPlugins, listInstalledPluginsInRoot } from '../resolver.js';
+const LOCAL_FIELD_NAME = /^[a-z][a-z0-9]*(?:-[a-z0-9]+)*$/;
+const DECLARATION_KEYS = new Set(['type', 'values', 'default', 'write_help', 'edit_help']);
+function isRecord(value) {
+    return value !== null && typeof value === 'object' && !Array.isArray(value);
+}
+export function isMemoryExtensionScalar(value) {
+    return typeof value === 'string' || typeof value === 'boolean' || (typeof value === 'number' && Number.isFinite(value));
+}
+function declarationError(path, message) {
+    return new Error(`invalid memory_extensions declaration at ${path}: ${message}`);
+}
+function validHelp(value) {
+    return typeof value === 'string' && value.trim() !== '' && !/[\r\n]/.test(value);
+}
+function validDefault(declaration, value) {
+    if (!isMemoryExtensionScalar(value))
+        return false;
+    if (declaration.type === 'enum')
+        return typeof value === 'string' && declaration.values.includes(value);
+    return typeof value === declaration.type;
+}
+/** Parse the closed declaration addendum. Callers that accept a plugin manifest
+ * invoke this at their install/preflight boundary; normal runtime catalogs only
+ * admit declarations which have already cleared that boundary. */
+export function validateMemoryExtensionDeclarations(raw) {
+    if (!isRecord(raw))
+        throw declarationError('memory_extensions', 'expected a non-empty object');
+    const declarations = {};
+    const fields = Object.entries(raw);
+    if (fields.length === 0)
+        throw declarationError('memory_extensions', 'must not be empty');
+    for (const [field, value] of fields) {
+        const path = `memory_extensions.${field}`;
+        if (!LOCAL_FIELD_NAME.test(field)) {
+            throw declarationError(path, 'field names must be lowercase kebab-case');
+        }
+        if (!isRecord(value))
+            throw declarationError(path, 'expected a declaration object');
+        for (const key of Object.keys(value)) {
+            if (!DECLARATION_KEYS.has(key))
+                throw declarationError(path, `unknown key \`${key}\``);
+        }
+        const type = value['type'];
+        if (type !== 'boolean' && type !== 'string' && type !== 'number' && type !== 'enum') {
+            throw declarationError(`${path}.type`, 'expected boolean, string, number, or enum');
+        }
+        if (!validHelp(value['write_help']))
+            throw declarationError(`${path}.write_help`, 'expected a nonblank single-line string');
+        if (!validHelp(value['edit_help']))
+            throw declarationError(`${path}.edit_help`, 'expected a nonblank single-line string');
+        if (type === 'enum') {
+            const values = value['values'];
+            if (!Array.isArray(values) || values.length === 0 || !values.every((entry) => typeof entry === 'string' && entry !== '')) {
+                throw declarationError(`${path}.values`, 'expected a non-empty string list');
+            }
+            if (new Set(values).size !== values.length)
+                throw declarationError(`${path}.values`, 'values must be unique');
+            const declaration = {
+                type,
+                values: [...values],
+                write_help: value['write_help'],
+                edit_help: value['edit_help'],
+            };
+            if ('default' in value) {
+                if (!validDefault(declaration, value['default'])) {
+                    throw declarationError(`${path}.default`, 'must be one of the declared enum values');
+                }
+                declaration.default = value['default'];
+            }
+            declarations[field] = declaration;
+            continue;
+        }
+        if ('values' in value)
+            throw declarationError(`${path}.values`, 'is allowed only for enum declarations');
+        const declaration = {
+            type,
+            write_help: value['write_help'],
+            edit_help: value['edit_help'],
+        };
+        if ('default' in value) {
+            if (!validDefault(declaration, value['default'])) {
+                throw declarationError(`${path}.default`, `must be a ${type}`);
+            }
+            declaration.default = value['default'];
+        }
+        declarations[field] = declaration;
+    }
+    return declarations;
+}
+/** Throw when a manifest carries an invalid addendum; absent is valid. */
+export function validatePluginMemoryExtensions(manifest) {
+    if (manifest.memory_extensions !== undefined)
+        validateMemoryExtensionDeclarations(manifest.memory_extensions);
+}
+function declarationsFromManifest(manifest, strict) {
+    if (manifest.memory_extensions === undefined)
+        return undefined;
+    try {
+        return validateMemoryExtensionDeclarations(manifest.memory_extensions);
+    }
+    catch (error) {
+        if (strict)
+            throw error;
+        return undefined;
+    }
+}
+function catalogForPlugins(groups, enabledOnly, candidate) {
+    const catalog = {};
+    const shadowed = new Set();
+    if (candidate !== undefined) {
+        // A candidate that removes its addendum must still hide an installed copy
+        // while that package's own documents are being validated.
+        shadowed.add(candidate.name);
+        const declarations = declarationsFromManifest(candidate, true);
+        if (declarations !== undefined)
+            catalog[candidate.name] = declarations;
+    }
+    for (const plugins of groups) {
+        for (const plugin of plugins) {
+            if (enabledOnly && !plugin.enabled)
+                continue;
+            const namespace = plugin.manifest.name;
+            if (shadowed.has(namespace) || catalog[namespace] !== undefined)
+                continue;
+            const declarations = declarationsFromManifest(plugin.manifest, false);
+            if (declarations !== undefined)
+                catalog[namespace] = declarations;
+        }
+    }
+    return catalog;
+}
+/** Declarations for a native document. Project documents use their owning
+ * project scope only, then user scope; profile/node/user docs use user scope. */
+function pluginGroupsForDocument(doc) {
+    if (doc.scope === 'project') {
+        const marker = `${sep}.crouter${sep}`;
+        const markerIndex = doc.path.lastIndexOf(marker);
+        if (markerIndex >= 0) {
+            const root = doc.path.slice(0, markerIndex + `${sep}.crouter`.length);
+            return [listInstalledPluginsInRoot('project', root), listInstalledPlugins('user')];
+        }
+    }
+    return [listInstalledPlugins('user')];
+}
+/** Installed declarations used for validation and authoring. Disabled plugins
+ * remain present so existing values can still be checked and edited. */
+export function memoryExtensionValidationCatalog(doc, options = {}) {
+    return catalogForPlugins(pluginGroupsForDocument(doc), false, options.candidate);
+}
+/** Winning enabled declarations used only to interpret structured output. */
+export function memoryExtensionEffectiveCatalog(doc) {
+    return catalogForPlugins(pluginGroupsForDocument(doc), true);
+}
+/** Validate the raw `extensions` frontmatter value. Unresolved namespaces are
+ * intentionally reported rather than discarded: removal leaves raw metadata
+ * intact but lint-invalid until its plugin returns. */
+export function validateMemoryExtensionValues(raw, catalog) {
+    if (raw === undefined)
+        return [];
+    if (!isRecord(raw))
+        return [{ path: 'extensions', message: 'expected a mapping' }];
+    const issues = [];
+    for (const [namespace, fields] of Object.entries(raw)) {
+        const namespacePath = `extensions.${namespace}`;
+        if (!isRecord(fields)) {
+            issues.push({ path: namespacePath, message: 'expected a mapping' });
+            continue;
+        }
+        const declarations = catalog[namespace];
+        if (declarations === undefined) {
+            issues.push({ path: namespacePath, message: 'unresolved extension namespace' });
+            for (const [field, value] of Object.entries(fields)) {
+                if (!isMemoryExtensionScalar(value)) {
+                    issues.push({ path: `${namespacePath}.${field}`, message: 'expected a string, boolean, or finite number' });
+                }
+            }
+            continue;
+        }
+        for (const [field, value] of Object.entries(fields)) {
+            const path = `${namespacePath}.${field}`;
+            if (!isMemoryExtensionScalar(value)) {
+                issues.push({ path, message: 'expected a string, boolean, or finite number' });
+                continue;
+            }
+            const declaration = declarations[field];
+            if (declaration === undefined) {
+                issues.push({ path, message: 'undeclared extension field' });
+                continue;
+            }
+            if (!validDefault(declaration, value)) {
+                const expected = declaration.type === 'enum' ? `one of ${declaration.values.join('|')}` : declaration.type;
+                issues.push({ path, message: `expected ${expected}` });
+            }
+        }
+    }
+    return issues;
+}
+/** Effective plugin metadata for structured consumers. It overlays only valid
+ * explicit scalars onto defaults and never mutates or serializes frontmatter. */
+export function projectEffectiveMemoryExtensions(raw, catalog) {
+    const source = isRecord(raw) ? raw : {};
+    const effective = {};
+    for (const [namespace, declarations] of Object.entries(catalog)) {
+        const values = {};
+        const explicit = isRecord(source[namespace]) ? source[namespace] : {};
+        for (const [field, declaration] of Object.entries(declarations)) {
+            if (declaration.default !== undefined)
+                values[field] = declaration.default;
+            const value = explicit[field];
+            if (validDefault(declaration, value))
+                values[field] = value;
+        }
+        if (Object.keys(values).length > 0)
+            effective[namespace] = values;
+    }
+    return effective;
+}

package/dist/core/preview-result-path.d.ts

@@ -0,0 +1,4 @@
+export declare const PREVIEW_RESULT_PATH_ENV = "CRTR_PREVIEW_RESULT_PATH";
+/** Deterministic from the tool call id, so the spawning side and the result
+ *  side derive the same path without sharing state. */
+export declare function previewResultPath(toolCallId: string): string;

package/dist/core/preview-result-path.js

@@ -0,0 +1,25 @@
+// The private structured-result side channel between a crtr CLI invocation and
+// the canvas broker that spawned it: the broker names one file per bash tool
+// call, the leaf mirrors its record there, and the broker attaches the record
+// to Pi's ToolResult.details.
+//
+// The path travels in the child process environment. It must never be spliced
+// into the command text — the executed script has to stay exactly what the
+// agent wrote, because `cmd.sh`, job inspection, and the doc substrate's
+// `command` surfaces all read that text as the agent's own words.
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+export const PREVIEW_RESULT_PATH_ENV = 'CRTR_PREVIEW_RESULT_PATH';
+/** A tool call id is unique only within one broker: some provider adapters
+ *  synthesize a missing id from a process-local counter and a millisecond
+ *  clock, so two brokers can mint the same one and collide on a shared file.
+ *  Node id and pid are equal across both sides of the transport (they run in
+ *  the same broker process) without either side sharing state. */
+function brokerToken() {
+    return `${encodeURIComponent(process.env['CRTR_NODE_ID'] ?? 'no-node')}-${process.pid}`;
+}
+/** Deterministic from the tool call id, so the spawning side and the result
+ *  side derive the same path without sharing state. */
+export function previewResultPath(toolCallId) {
+    return join(tmpdir(), 'crouter-preview-results', `${brokerToken()}-${encodeURIComponent(toolCallId)}.json`);
+}

package/dist/core/substrate/frontmatter-validation.d.ts

@@ -0,0 +1,13 @@
+/** Strict validation of one raw routing entry. Runtime parsing deliberately
+ * tolerates malformed docs; this authoring/preflight contract does not. */
+export declare function lintSubstrateSurfaces(value: unknown): string | null;
+/** Strict substrate frontmatter checker shared by lint and package preflight. */
+export declare function lintSubstrateFrontmatter(fm: Record<string, unknown> | null): string | null;
+/** Compatibility name for consumers that adopted lint's former export. */
+export declare const lintSubstrateSchema: typeof lintSubstrateFrontmatter;
+/** Parsed routing entries for checks that run after strict validation. */
+export declare function parsedSubstrateSurfaces(fm: Record<string, unknown>): {
+    on: string;
+    at: string;
+    match?: string[];
+}[];

package/dist/core/substrate/frontmatter-validation.js

@@ -0,0 +1,101 @@
+import { isDocKind, parseSubstrateFrontmatter, SURFACE_EVENTS, SURFACE_RUNGS } from './schema.js';
+const RETIRED_FIELDS = ['system-prompt-visibility', 'file-read-visibility', 'applies-to', 'read-when'];
+const SURFACE_ENTRY_KEYS = ['on', 'match', 'match-frontmatter', 'at'];
+const SUPPRESSIBLE_RULES = ['length', 'broad-memory-read'];
+/** Strict validation of one raw routing entry. Runtime parsing deliberately
+ * tolerates malformed docs; this authoring/preflight contract does not. */
+export function lintSubstrateSurfaces(value) {
+    if (value === undefined)
+        return null;
+    if (!Array.isArray(value))
+        return `invalid surfaces: ${JSON.stringify(value)} (expected a list of {on, at, match?, match-frontmatter?} entries)`;
+    for (const raw of value) {
+        if (raw === null || typeof raw !== 'object' || Array.isArray(raw)) {
+            return `invalid surfaces entry: ${JSON.stringify(raw)} (expected an {on, at, match?, match-frontmatter?} object)`;
+        }
+        const entry = raw;
+        for (const key of Object.keys(entry)) {
+            if (!SURFACE_ENTRY_KEYS.includes(key)) {
+                return `invalid surfaces entry: unknown key \`${key}\` (an entry carries only on, match, match-frontmatter, at)`;
+            }
+        }
+        const on = entry['on'];
+        if (typeof on !== 'string' || !SURFACE_EVENTS.includes(on)) {
+            return `invalid surfaces entry \`on\`: ${JSON.stringify(on)} (expected ${SURFACE_EVENTS.join('|')})`;
+        }
+        const at = entry['at'];
+        if (typeof at !== 'string' || !SURFACE_RUNGS.includes(at)) {
+            return `invalid surfaces entry \`at\`: ${JSON.stringify(at)} (expected ${SURFACE_RUNGS.join('|')})`;
+        }
+        let hasMatch = false;
+        if (entry['match'] !== undefined) {
+            if (on === 'boot' || on === 'workspace-open') {
+                return `invalid surfaces entry: \`match\` is meaningless on \`${on}\` — the entry's presence is the match; drop it`;
+            }
+            const match = entry['match'];
+            const globs = typeof match === 'string' ? [match] : Array.isArray(match) && match.every((glob) => typeof glob === 'string') ? match : null;
+            if (globs === null || globs.length === 0 || globs.some((glob) => glob.trim() === '')) {
+                return `invalid surfaces entry \`match\`: ${JSON.stringify(match)} (expected a non-empty glob or non-empty glob list)`;
+            }
+            hasMatch = true;
+        }
+        const matchFrontmatter = entry['match-frontmatter'];
+        if (matchFrontmatter !== undefined) {
+            if (on !== 'read')
+                return 'invalid surfaces entry: `match-frontmatter` is a `read`-event predicate only';
+            if (matchFrontmatter === null || typeof matchFrontmatter !== 'object' || Array.isArray(matchFrontmatter)) {
+                return `invalid surfaces entry \`match-frontmatter\`: ${JSON.stringify(matchFrontmatter)} (expected a field→matcher object)`;
+            }
+        }
+        if ((on === 'read' || on === 'memory-read' || on === 'command') && !hasMatch && matchFrontmatter === undefined) {
+            return `invalid surfaces entry: a \`${on}\` entry requires \`match\`${on === 'read' ? ' or `match-frontmatter`' : ''}`;
+        }
+    }
+    return null;
+}
+/** Strict substrate frontmatter checker shared by lint and package preflight. */
+export function lintSubstrateFrontmatter(fm) {
+    if (fm === null)
+        return 'missing frontmatter: a memory store doc requires `kind: knowledge|preference`';
+    if (!isDocKind(fm.kind))
+        return `invalid kind: ${JSON.stringify(fm.kind)} (expected knowledge|preference)`;
+    if ('when' in fm || 'why' in fm) {
+        return 'retired `when`/`why` keys: merge them into one `when-and-why-to-read` line — "When <circumstance>, this <kind> should be read because <broader downstream payoff>." WHY is the benefit unlocked by reading, not the document summary, rule, or obedience rationale.';
+    }
+    if (typeof fm['when-and-why-to-read'] !== 'string' || fm['when-and-why-to-read'].trim() === '') {
+        return 'missing `when-and-why-to-read`: one routing line — "When <circumstance>, this <kind> should be read because <broader downstream payoff>." WHY is the benefit unlocked by reading, not the document summary, rule, or obedience rationale.';
+    }
+    for (const field of RETIRED_FIELDS) {
+        if (field in fm) {
+            return `retired \`${field}\` key: the visibility axes were replaced by \`surfaces\` event routing — run \`crtr sys migrate\` to convert old-format docs, or author \`surfaces\` entries by hand (\`crtr memory write -h\`)`;
+        }
+    }
+    if (fm['unlisted'] !== undefined && typeof fm['unlisted'] !== 'boolean') {
+        return `invalid unlisted: ${JSON.stringify(fm['unlisted'])} (expected a boolean)`;
+    }
+    const surfacesError = lintSubstrateSurfaces(fm['surfaces']);
+    if (surfacesError !== null)
+        return surfacesError;
+    if (fm.gate !== undefined && (fm.gate === null || typeof fm.gate !== 'object' || Array.isArray(fm.gate))) {
+        return `invalid gate: ${JSON.stringify(fm.gate)} (expected a field→matcher object)`;
+    }
+    if (fm.slash !== undefined && typeof fm.slash !== 'boolean') {
+        return `invalid slash: ${JSON.stringify(fm.slash)} (expected a boolean)`;
+    }
+    if (fm.rationale !== undefined && typeof fm.rationale !== 'string') {
+        return `invalid rationale: ${JSON.stringify(fm.rationale)} (expected a string)`;
+    }
+    if (fm['lint-ignore'] !== undefined) {
+        const rules = Array.isArray(fm['lint-ignore']) ? fm['lint-ignore'] : [fm['lint-ignore']];
+        if (rules.length === 0 || !rules.every((rule) => typeof rule === 'string' && SUPPRESSIBLE_RULES.includes(rule))) {
+            return `invalid lint-ignore: ${JSON.stringify(fm['lint-ignore'])} (suppressible rules: ${SUPPRESSIBLE_RULES.map((rule) => `\`${rule}\``).join(', ')})`;
+        }
+    }
+    return null;
+}
+/** Compatibility name for consumers that adopted lint's former export. */
+export const lintSubstrateSchema = lintSubstrateFrontmatter;
+/** Parsed routing entries for checks that run after strict validation. */
+export function parsedSubstrateSurfaces(fm) {
+    return parseSubstrateFrontmatter(fm)?.surfaces ?? [];
+}

package/dist/core/substrate/index.d.ts

@@ -1,5 +1,6 @@
 export { KINDS, isDocKind, RUNGS, rungRank, rungAtLeast, SURFACE_EVENTS, SURFACE_RUNGS, bootRung, parseSubstrateFrontmatter, parseSubstrateDoc, previewLine, normalizeNameSegment, normalizeDocName, resolveDocName, } from './schema.js';
 export type { DocKind, Rung, GatePredicate, SubstrateSchema, SubstrateDoc, SurfaceEntry, SurfaceEvent, SurfaceRung } from './schema.js';
+export { lintSubstrateFrontmatter, lintSubstrateSchema, lintSubstrateSurfaces, parsedSubstrateSurfaces } from './frontmatter-validation.js';
 export { matchesReadEntry, matchesMemoryReadEntry, matchesCommandEntry, readDeliveryRung, workspaceOpenRung, memoryReadDeliveryRung, commandDeliveryRung, owningRootOf, underOwningRoot } from './surface-match.js';
 export { dirDedupKey, docsByName, isDirName, ancestorDirsOf, renderDirListing } from './listings.js';
 export { deliveredAtOrAbove, recordDelivery, mergeInjectedDocs } from './injected-store.js';

package/dist/core/substrate/index.js

@@ -16,6 +16,7 @@ parseSubstrateFrontmatter, parseSubstrateDoc, previewLine,
 normalizeNameSegment, normalizeDocName, 
 // substrate identity (explicit-name-then-path-fallback)
 resolveDocName, } from './schema.js';
+export { lintSubstrateFrontmatter, lintSubstrateSchema, lintSubstrateSurfaces, parsedSubstrateSurfaces } from './frontmatter-validation.js';
 export { matchesReadEntry, matchesMemoryReadEntry, matchesCommandEntry, readDeliveryRung, workspaceOpenRung, memoryReadDeliveryRung, commandDeliveryRung, owningRootOf, underOwningRoot } from './surface-match.js';
 export { dirDedupKey, docsByName, isDirName, ancestorDirsOf, renderDirListing } from './listings.js';
 export { deliveredAtOrAbove, recordDelivery, mergeInjectedDocs } from './injected-store.js';

package/dist/daemon/api/__tests__/nodes-activity-query.test.d.ts

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

package/dist/daemon/api/__tests__/nodes-activity-query.test.js

@@ -0,0 +1,101 @@
+import { after, before, beforeEach, test } from 'node:test';
+import assert from 'node:assert/strict';
+import { mkdirSync, mkdtempSync, rmSync, writeFileSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import { createNode } from '../../../core/canvas/canvas.js';
+import { closeDb } from '../../../core/canvas/db.js';
+import { reportsDir } from '../../../core/canvas/paths.js';
+import { invalidateTicketCounts } from '../../../core/canvas/attention.js';
+import { bindTicketReplyRoute } from '../../../core/human/convention.js';
+import { ticketDir } from '../../../core/human/root.js';
+import { submitPage } from '../../../core/human/tickets.js';
+import { handleList } from '../handlers/nodes.js';
+const previousCrtrHome = process.env['CRTR_HOME'];
+let home = '';
+before(() => {
+    closeDb();
+    home = mkdtempSync(join(tmpdir(), 'crtr-nodes-activity-query-'));
+    process.env['CRTR_HOME'] = home;
+});
+beforeEach(() => {
+    closeDb();
+    invalidateTicketCounts();
+    rmSync(home, { recursive: true, force: true });
+    mkdirSync(home, { recursive: true });
+});
+after(() => {
+    closeDb();
+    rmSync(home, { recursive: true, force: true });
+    if (previousCrtrHome === undefined)
+        delete process.env['CRTR_HOME'];
+    else
+        process.env['CRTR_HOME'] = previousCrtrHome;
+});
+function node(id, overrides = {}) {
+    return {
+        node_id: id,
+        name: id,
+        created: '2026-08-17T00:00:00.000Z',
+        cwd: home,
+        kind: 'developer',
+        mode: 'base',
+        lifecycle: 'terminal',
+        status: 'active',
+        parent: null,
+        profile_id: 'activity-profile-7f3a9c01',
+        launch: { model: 'anthropic/original', extensions: [], env: {} },
+        ...overrides,
+    };
+}
+function list(query) {
+    const result = handleList({
+        method: 'GET',
+        path: '/v1/nodes',
+        params: {},
+        query: new URLSearchParams(query),
+        body: null,
+    });
+    assert.equal(result.status, 200);
+    return result.body;
+}
+function report(nodeId, stamp, tier, body) {
+    const filename = `${stamp}-${tier}.md`;
+    writeFileSync(join(reportsDir(nodeId), filename), `---\nkind: ${tier}\nts: ${stamp}\n---\n${body}\n`);
+    return filename;
+}
+test('list activity query composes profile, lifecycle, topology filters and report enrichment', () => {
+    const finalName = '20260817T100000-final.md';
+    createNode(node('root', {
+        status: 'done',
+        final_report: finalName,
+        finalized_at: '2026-08-17T10:00:00.000Z',
+    }));
+    report('root', '20260817T090000', 'update', 'Started the task');
+    report('root', '20260817T100000', 'final', 'Finished the task');
+    report('root', '20260817T110000', 'update', 'Still monitoring the task');
+    createNode(node('bridge', { kind: 'human', parent: 'root' }));
+    const page = join(home, 'pending-page.tsx');
+    writeFileSync(page, `export default function PendingPage() {
+  return <Page title="Need a decision"><UserText id="answer" initialText="" /></Page>;
+}
+`);
+    const ticket = submitPage({
+        dir: ticketDir('bridge'),
+        sourceFile: page,
+        delivery: { placement: 'inline', inbox: true, reply: true },
+    });
+    bindTicketReplyRoute(ticket.dir, 'bridge');
+    invalidateTicketCounts();
+    createNode(node('child', { parent: 'root' }));
+    createNode(node('resident', { lifecycle: 'resident' }));
+    createNode(node('other-profile', { profile_id: 'other-profile-7f3a9c01' }));
+    const roots = list('profile_prefix=activity-profile-&lifecycle=terminal&top_level=true&include=activity');
+    assert.deepEqual(roots.map((row) => row.node_id), ['root']);
+    assert.equal(roots[0].activity?.final_report?.body, 'Finished the task');
+    assert.equal(roots[0].activity?.latest_report?.body, 'Still monitoring the task');
+    assert.equal(roots[0].activity?.pending_human_count, 1);
+    const children = list('profile_id=activity-profile-7f3a9c01&parent=root');
+    assert.deepEqual(children.map((row) => row.node_id), ['bridge', 'child']);
+    assert.equal(children[1].activity, undefined);
+});

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

@@ -278,6 +278,7 @@ function handleSnapshot() {
             lifecycle: row.lifecycle ?? meta?.lifecycle,
             status: row.status,
             cwd: row.cwd,
+            profile_id: meta?.profile_id ?? null,
             parent: meta?.parent ?? null,
             created: row.created,
             host_kind: hostKind,
@@ -289,6 +290,8 @@ function handleSnapshot() {
             streaming: row.streaming ?? false,
             hanging: (row.hanging ?? null),
             viewed: row.viewed ?? false,
+            final_report: meta?.final_report ?? null,
+            finalized_at: meta?.finalized_at ?? null,
         };
     });
     const subscriptions = Object.fromEntries(rows.map((row) => [row.node_id, subscriptionsOf(row.node_id).map((ref) => ref.node_id)]));

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

@@ -226,11 +226,12 @@ function handleList() {
 // GET /v1/human/inbox/history?node_id=<id> — page ticket history
 // ===========================================================================
 function handleHistory(ctx) {
+    // Home-wide when `node_id` is absent; an explicitly empty param is a caller bug.
     const nodeId = ctx.query.get('node_id');
-    if (!nodeId || typeof nodeId !== 'string') {
-        throw new ApiError(400, 'invalid_request', 'history requires a node_id query param');
+    if (nodeId === '') {
+        throw new ApiError(400, 'invalid_request', 'node_id must be nonempty when present');
     }
-    const history = scanPageHistory(nodeId);
+    const history = scanPageHistory(nodeId ?? undefined);
     const canonicalRoot = realpathSync(ticketsRoot());
     const tickets = history.map((item) => pageSummaryToDTO(item, canonicalRoot));
     return { status: 200, body: { tickets } };

package/dist/daemon/api/handlers/nodes.d.ts

@@ -6,6 +6,7 @@ interface NodeHandlerDeps {
 }
 export declare function resolveCreateKind(kind: string | undefined, profile: ReturnType<typeof assertProfileActive>): string;
 export declare function handleCreate(ctx: RequestContext, deps?: NodeHandlerDeps): Promise<HandlerResult>;
+export declare function handleList(ctx: RequestContext): HandlerResult;
 export declare function handlePromote(ctx: RequestContext, deps?: NodeHandlerDeps): Promise<HandlerResult>;
 export declare function handleYield(ctx: RequestContext, deps?: NodeHandlerDeps): Promise<HandlerResult>;
 export declare function handleConfig(ctx: RequestContext, deps?: NodeHandlerDeps): Promise<HandlerResult>;