@north-light/crouter 0.3.154

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

@@ -0,0 +1,540 @@
+// Node resource + lifecycle handlers (spec §6.2, §7.7). Create, list, detail,
+// the read endpoints (snapshot/transcript/context/artifacts), the lifecycle
+// verbs (revive/close/recycle/demote/promote/yield/wait + revive-all), and the
+// config PATCH. Each relocates the sanctioned core primitive behind the API
+// caller and projects through map.ts (or an inlined server-side projection where
+// map.ts carries no projector — it is frozen under concurrency).
+//
+// `{id}` is the target node.
+import { readdirSync } from 'node:fs';
+import { appendSituationalContext, closeNode, getNode, listNodes, nowIso, reviveNode, } from '../../../index.js';
+import { forkNode, spawnChild } from '../../../core/runtime/spawn.js';
+import { childrenOf, subscribersOf, subscriptionsOf, setMessageWait, updateNode } from '../../../core/canvas/canvas.js';
+import { subtreeIds } from '../../../core/canvas/nav-model.js';
+import { contextDir, reportsDir } from '../../../core/canvas/paths.js';
+import { nodeArtifacts } from '../../../core/canvas/history.js';
+import { readNodeSession, readNodeSnapshot, transcriptMarkdown } from '../../../core/runtime/node-read.js';
+import { reviveAll } from '../../../core/runtime/revive-all.js';
+import { promote, requestYield } from '../../../core/runtime/promote.js';
+import { recycleNode } from '../../../core/runtime/recycle.js';
+import { relaunchRoot } from '../../../core/runtime/reset.js';
+import { assertReopenGate } from '../../../core/runtime/reopen.js';
+import { writeYieldMessage, readGoal } from '../../../core/runtime/kickoff.js';
+import { hasRoadmap, seedRoadmap } from '../../../core/runtime/roadmap.js';
+import { renameWindow } from '../../../core/runtime/placement.js';
+import { readMergedLaunchConfig } from '../../../core/config.js';
+import { buildLaunchSpec, isProviderPinnedModelToken, normalizeModel } from '../../../core/runtime/launch.js';
+import { BrokerUnreachableError } from '../../../core/runtime/broker-request.js';
+import { isBrokerLive, persistDormantModel, setModelLive } from '../../../core/runtime/model-swap.js';
+import { writeOutputSchema } from '../../../core/runtime/structured-output.js';
+import { claimWarmNode, refillWarmPool, warmPoolEnabled } from '../../../core/runtime/warm-pool.js';
+import { fullName } from '../../../core/canvas/labels.js';
+import { getCron } from '../../../core/canvas/crons.js';
+import { cronWakeOrigin } from '../../../core/runtime/bearings.js';
+import { notFound, usage } from '../../../core/errors.js';
+import { toCloseResultDTO, toNodeDetailDTO, toNodeSummaryDTO, toReviveResultDTO } from '../map.js';
+import { ApiError } from '../../../api/index.js';
+// ---------------------------------------------------------------------------
+// Shared helpers
+// ---------------------------------------------------------------------------
+function requireMeta(id) {
+    const meta = getNode(id);
+    if (meta === null)
+        throw notFound(`unknown node: ${id}`, { received: id });
+    return meta;
+}
+/** Gather a node's spine + subscription edges (map.ts stays a pure projection,
+ *  so the db reach lives here). Children = rows whose parent is this node,
+ *  read via the indexed `idx_nodes_parent` point query — never a full scan. */
+function edgesFor(id) {
+    return {
+        subscribesTo: subscriptionsOf(id),
+        subscribers: subscribersOf(id),
+        children: childrenOf(id),
+    };
+}
+/** Re-read a node fresh and project its detail DTO (post-action response). */
+function detailOf(id) {
+    return toNodeDetailDTO(requireMeta(id), edgesFor(id));
+}
+/** Count context + report files under a node (the context-roster `files`). */
+function countFiles(id) {
+    let n = 0;
+    for (const dir of [contextDir(id), reportsDir(id)]) {
+        try {
+            n += readdirSync(dir).length;
+        }
+        catch {
+            /* dir absent — zero */
+        }
+    }
+    return n;
+}
+// ---------------------------------------------------------------------------
+// POST /v1/nodes — create immediately (201)
+// ---------------------------------------------------------------------------
+/** Validate + narrow the create body (spec §6.2). */
+function parseCreateBody(body) {
+    if (typeof body !== 'object' || body === null) {
+        throw usage('a node create requires a JSON body { kind, ... }');
+    }
+    const b = body;
+    if (typeof b['kind'] !== 'string' || b['kind'].trim() === '') {
+        throw usage('a node create requires a kind');
+    }
+    return b;
+}
+/** Build the immediate spawn recipe. */
+function buildRecipe(req, parent) {
+    const recipe = {
+        kind: req.kind,
+        cwd: req.cwd ?? process.cwd(),
+        prompt: req.prompt ?? '',
+    };
+    if (req.mode !== undefined)
+        recipe.mode = req.mode;
+    if (req.name !== undefined)
+        recipe.name = req.name;
+    if (parent !== undefined)
+        recipe.parent = parent;
+    if (req.root === true)
+        recipe.root = true;
+    if (req.worktree === true || typeof req.worktree === 'string')
+        recipe.worktree = true;
+    if (typeof req.worktree === 'string')
+        recipe.worktreeBase = req.worktree;
+    if (req.fork_from !== undefined)
+        recipe.forkFrom = req.fork_from;
+    if (req.model !== undefined)
+        recipe.model = req.model;
+    if (req.profile !== undefined)
+        recipe.profile = req.profile;
+    if (req.situational_context !== undefined)
+        recipe.situationalContext = req.situational_context;
+    if (req.node_id !== undefined)
+        recipe.nodeId = req.node_id;
+    return recipe;
+}
+/** The warm-pool request this create is asking for, or null when it carries
+ *  something a pre-booted spare cannot honor. A spare is a bare root with no
+ *  kickoff, so anything that shapes the node AT BIRTH — a prompt to run, a
+ *  forked conversation, a managed worktree, a caller-pinned node id, a spine
+ *  parent — disqualifies it. `kind`, `mode`, `model`, `name`, `situational_context`
+ *  and `output_schema` are all applied at claim time and so do not. */
+function warmRequestFor(req) {
+    if (!warmPoolEnabled())
+        return null;
+    if (req.prefer_warm !== true)
+        return null;
+    if (req.root !== true || req.parent != null)
+        return null;
+    if ((req.prompt ?? '') !== '')
+        return null;
+    if (req.fork_from !== undefined || req.worktree !== undefined || req.node_id !== undefined)
+        return null;
+    return {
+        kind: req.kind,
+        mode: (req.mode ?? 'base'),
+        cwd: req.cwd ?? process.cwd(),
+        profile: req.profile,
+        model: req.model ?? null,
+        situationalContext: req.situational_context ?? null,
+        name: req.name ?? null,
+    };
+}
+async function handleCreate(ctx) {
+    const req = parseCreateBody(ctx.body);
+    // `no_kickoff` needs no dedicated recipe field: an empty prompt IS the
+    // no-kickoff mechanism (spawnChild runs no launch turn on prompt===''), and
+    // buildRecipe already defaults `prompt` to ''. The CLI keeps every no_kickoff
+    // guards (root-only / no-prompt / no-orchestrator).
+    const parent = req.parent ?? undefined;
+    // --- Immediate spawn (201). A managed child needs a parent; a root does not. ---
+    if (parent == null && req.root !== true) {
+        throw usage('a node create requires a parent (or root: true for an independent root)');
+    }
+    // Parse BEFORE spawning: a malformed schema must not leave behind a live,
+    // schema-less node that was told to submit a structured result.
+    let schema = null;
+    if (req.output_schema !== undefined) {
+        try {
+            schema = JSON.parse(req.output_schema);
+        }
+        catch {
+            throw usage('output_schema must be a JSON schema string');
+        }
+    }
+    // --- Warm path: hand out an already-booted spare instead of paying a full
+    //     engine boot. A miss is not a failure — it falls through to the cold
+    //     spawn below and mints the spare that serves the NEXT create. ---
+    const warm = warmRequestFor(req);
+    if (warm !== null) {
+        const claimed = await claimWarmNode(warm);
+        refillWarmPool(warm);
+        if (claimed !== null) {
+            if (schema !== null)
+                writeOutputSchema(claimed, 'terminal', schema);
+            return { status: 201, body: detailOf(claimed) };
+        }
+    }
+    const recipe = buildRecipe(req, parent);
+    recipe.readiness = req.root === true ? 'await' : 'launch';
+    const result = await spawnChild(recipe);
+    if (schema !== null)
+        writeOutputSchema(result.node.node_id, 'terminal', schema);
+    return { status: 201, body: detailOf(result.node.node_id) };
+}
+// ---------------------------------------------------------------------------
+// GET /v1/nodes — list (filters) ; GET /v1/nodes/{id} — detail
+// ---------------------------------------------------------------------------
+function handleList(ctx) {
+    const status = ctx.query.get('status');
+    const kind = ctx.query.get('kind');
+    const mode = ctx.query.get('mode');
+    const under = ctx.query.get('under');
+    const hanging = ctx.query.get('hanging');
+    let rows = status !== null ? listNodes({ status }) : listNodes();
+    if (kind !== null)
+        rows = rows.filter((r) => r.kind === kind);
+    if (mode !== null)
+        rows = rows.filter((r) => r.mode === mode);
+    if (under !== null) {
+        const scope = new Set(subtreeIds(under));
+        rows = rows.filter((r) => scope.has(r.node_id));
+    }
+    if (hanging === '1' || hanging === 'true') {
+        // A dangling manager edge: a non-root whose recorded parent is gone.
+        rows = rows.filter((r) => r.parent !== null && getNode(r.parent) === null);
+    }
+    const body = rows.map(toNodeSummaryDTO);
+    return { status: 200, body };
+}
+function handleDetail(ctx) {
+    const id = ctx.params['id'];
+    requireMeta(id);
+    return { status: 200, body: detailOf(id) };
+}
+// ---------------------------------------------------------------------------
+// Read endpoints (snapshot / transcript / context / artifacts)
+// ---------------------------------------------------------------------------
+async function handleSnapshot(ctx) {
+    const id = ctx.params['id'];
+    requireMeta(id);
+    const read = await readNodeSnapshot(id);
+    const body = {
+        node_id: id,
+        snapshot: {
+            messages: read.snapshot.messages,
+            stats: read.snapshot.stats,
+            state: read.snapshot.state,
+        },
+        commands: read.commands.map((c) => ({ name: c.name, description: c.description, source: c.source })),
+        captured_at: nowIso(),
+    };
+    return { status: 200, body };
+}
+/** The faithful export read: raw `.jsonl` bytes + assembled system prompt.
+ *  `/snapshot` reconstructs a cycle-flattened `AgentMessage[]` for renderers and
+ *  drops what a renderer cannot show; this drops nothing. */
+function handleSession(ctx) {
+    const id = ctx.params['id'];
+    requireMeta(id);
+    const read = readNodeSession(id);
+    const body = {
+        node_id: id,
+        session_file: read.sessionFile,
+        session_jsonl: read.sessionJsonl,
+        system_prompt: read.systemPrompt,
+        captured_at: nowIso(),
+    };
+    return { status: 200, body };
+}
+async function handleTranscript(ctx) {
+    const id = ctx.params['id'];
+    requireMeta(id);
+    const body = { node_id: id, markdown: await transcriptMarkdown(id) };
+    return { status: 200, body };
+}
+function handleContext(ctx) {
+    const id = ctx.params['id'];
+    requireMeta(id);
+    // The roster of context roots this node can read: its own dir plus each
+    // publisher it subscribes to (the shared-document store, spec §Reports).
+    const roots = [
+        { node_id: id, label: getNode(id)?.name ?? id, dir: contextDir(id), self: true, files: countFiles(id) },
+    ];
+    for (const ref of subscriptionsOf(id)) {
+        roots.push({
+            node_id: ref.node_id,
+            label: getNode(ref.node_id)?.name ?? ref.node_id,
+            dir: contextDir(ref.node_id),
+            self: false,
+            files: countFiles(ref.node_id),
+        });
+    }
+    return { status: 200, body: { node_id: id, roots } };
+}
+function handleArtifacts(ctx) {
+    const id = ctx.params['id'];
+    requireMeta(id);
+    // Optional corpus narrowing (spec §6.2). Absent → the default report/doc/
+    // roadmap set; `inbox` is opt-in and only reachable via an explicit type.
+    const type = ctx.query.get('type');
+    const artifacts = nodeArtifacts(id, type !== null ? [type] : undefined).map((a) => ({
+        ref: a.ref,
+        source: a.source === 'report' && a.reportKind !== undefined ? `report:${a.reportKind}` : a.source,
+        ts: a.ts,
+        title: a.title,
+    }));
+    const body = { node_id: id, artifacts };
+    return { status: 200, body };
+}
+// ---------------------------------------------------------------------------
+// Lifecycle verbs
+// ---------------------------------------------------------------------------
+async function handleFork(ctx) {
+    const id = ctx.params['id'];
+    requireMeta(id);
+    const result = await forkNode(id);
+    return { status: 201, body: detailOf(result.node.node_id) };
+}
+function handleRevive(ctx) {
+    const id = ctx.params['id'];
+    requireMeta(id);
+    const body = ctx.body;
+    const resume = body?.resume ?? true;
+    const reopen = body?.reopen ?? false;
+    // #339 gate, enforced server-side (the latch clear is a canvas write the CLI
+    // caller cannot reach): --reopen CAS-clears a spent `final_report`; the
+    // no-reopen path refuses a still-latched node (`node_finalized`). reviveNode
+    // keeps its own belt-and-suspenders latch guard under the launch lock.
+    assertReopenGate(id, reopen);
+    // Wake provenance (only a FRESH revive has a kickoff to carry it): a cron run
+    // forwards its `CRTR_CRON_ID`, so the revived node is told a CLOCK woke it
+    // rather than a message. A cron id that no longer resolves (canceled or
+    // consumed mid-run) simply yields no block — prose, never an error.
+    const cron = !resume && body?.cron_id !== undefined ? getCron(body.cron_id) : null;
+    const result = reviveNode(id, {
+        resume,
+        ...(cron !== null ? { wakeReason: cronWakeOrigin(cron, 'schedule_revive') } : {}),
+    });
+    const status = (getNode(id)?.status ?? 'active');
+    return { status: 200, body: toReviveResultDTO(id, result, status) };
+}
+async function handleRelaunchRoot(ctx) {
+    const id = ctx.params['id'];
+    const result = await relaunchRoot(id);
+    return { status: 200, body: { newNodeId: result?.newNodeId ?? null } };
+}
+function handleClose(ctx) {
+    const id = ctx.params['id'];
+    requireMeta(id);
+    // closeNode always computes the cascade + spared set itself; the DTO `cascade`
+    // opt-out has no primitive knob in this version (documented Stage-A limit).
+    // `finish` selects the root disposition: finalize to `done` (browse `x`) vs the
+    // default cancel.
+    const body = ctx.body;
+    const result = closeNode(id, { rootEvent: body?.finish === true ? 'finish' : 'cancel' });
+    return { status: 200, body: toCloseResultDTO(result) };
+}
+async function handleRecycle(ctx) {
+    const id = ctx.params['id'];
+    requireMeta(id);
+    // The server has no tmux pane, so recycle's destructive pane re-exec is a
+    // Stage-B local concern; the server half runs pane-less and returns
+    // `recycled:false` without a destructive op.
+    const result = await recycleNode(id);
+    return {
+        status: 200,
+        body: {
+            recycled: result.recycled,
+            finalized: result.finalized,
+            new_root: result.newRoot,
+            delivered: result.delivered,
+        },
+    };
+}
+function handleDemote(ctx) {
+    const id = ctx.params['id'];
+    const meta = requireMeta(id);
+    // No demote primitive exists — replicate the setLifecycle reshape to terminal.
+    const { launch } = buildLaunchSpec(meta.kind, meta.mode, {
+        lifecycle: 'terminal',
+        hasManager: meta.parent != null,
+        ...(meta.model_override != null ? { model: meta.model_override } : {}),
+        ...(meta.launch?.modelProviderPinned !== undefined
+            ? { modelProviderPinned: meta.launch.modelProviderPinned }
+            : {}),
+        cwd: meta.cwd,
+        profileId: meta.profile_id ?? null,
+    });
+    updateNode(id, { lifecycle: 'terminal', launch });
+    return { status: 200, body: detailOf(id) };
+}
+function handlePromote(ctx) {
+    const id = ctx.params['id'];
+    requireMeta(id);
+    const req = ctx.body ?? {};
+    const result = promote(id, {
+        ...(req.kind !== undefined ? { kind: req.kind } : {}),
+        ...(req.resident === true ? { resident: true } : {}),
+        ...(req.model !== undefined ? { model: req.model } : {}),
+    });
+    const dto = toNodeDetailDTO(result.meta, edgesFor(id));
+    // Surface the promote-only roadmap/goal facts the primitive returns beyond the
+    // node meta (the CLI renders roadmap_written/roadmap_path/goal_path).
+    dto.roadmap_written = result.roadmapWritten;
+    dto.roadmap_path = result.roadmapPath;
+    dto.goal_path = result.goalPath;
+    return { status: 200, body: dto };
+}
+function handleYield(ctx) {
+    const id = ctx.params['id'];
+    requireMeta(id);
+    const req = ctx.body ?? {};
+    const note = req.note ?? 'Refresh: continue against your roadmap or goal.';
+    writeYieldMessage(id, note);
+    const result = requestYield(id, {
+        ...(req.promote === true ? { promote: true } : {}),
+        ...(req.kind !== undefined ? { kind: req.kind } : {}),
+        ...(req.model !== undefined ? { model: req.model } : {}),
+    });
+    return { status: 200, body: toNodeDetailDTO(result.meta, edgesFor(id)) };
+}
+function handleWait(ctx) {
+    const id = ctx.params['id'];
+    requireMeta(id);
+    const req = ctx.body;
+    if (req === undefined || typeof req.controller !== 'string' || req.controller.trim() === '') {
+        throw usage('a wait requires a controller node id');
+    }
+    const controller = getNode(req.controller);
+    if (controller === null)
+        throw notFound(`unknown controller: ${req.controller}`, { received: req.controller });
+    if (controller.status !== 'active' && controller.status !== 'idle') {
+        // A dead controller can never settle the wait — reject as unprocessable.
+        // ApiError (not a plain literal) so its message survives `toErrorBody`'s
+        // String(err) on the wire.
+        throw new ApiError(422, 'unprocessable', `controller ${req.controller} is ${controller.status}`);
+    }
+    setMessageWait(id, req.controller);
+    return { status: 200, body: detailOf(id) };
+}
+function handleReviveAll() {
+    const result = reviveAll();
+    const body = { revived: [...result.revived], failed: [...result.failed] };
+    return { status: 200, body };
+}
+// ---------------------------------------------------------------------------
+// PATCH /v1/nodes/{id}/config — model / situational-context (spec §6.2)
+// ---------------------------------------------------------------------------
+async function handleConfig(ctx) {
+    const id = ctx.params['id'];
+    let meta = requireMeta(id);
+    const patch = ctx.body ?? {};
+    if (patch.situational_context !== undefined) {
+        appendSituationalContext(id, patch.situational_context);
+    }
+    if (patch.model !== undefined) {
+        const pinned = isProviderPinnedModelToken(patch.model);
+        const persistDormant = () => {
+            // Dormant: persist a fully-qualified `provider/id` spec to the row.
+            const spec = normalizeModel(patch.model);
+            if (!spec.includes('/'))
+                throw usage(`model must resolve to a provider/id spec: ${patch.model}`);
+            persistDormantModel(id, spec, pinned);
+        };
+        if (isBrokerLive(meta)) {
+            // Live broker: swap the model over its view socket (spec §6.2). The
+            // liveness heuristic (pid alive + socket present) can win the race against
+            // a broker that is mid-revive: the socket file exists but the connection
+            // is refused/closed before any frame. That surfaces as a
+            // BrokerUnreachableError — fall back to the durable dormant persist (the
+            // next revive applies it, the same guarantee the dormant branch gives)
+            // rather than 500ing. A genuine broker rejection (e.g. an invalid model)
+            // rejects with a plain Error and still surfaces.
+            try {
+                await setModelLive(id, normalizeModel(patch.model), pinned);
+            }
+            catch (err) {
+                if (!(err instanceof BrokerUnreachableError))
+                    throw err;
+                persistDormant();
+            }
+        }
+        else {
+            persistDormant();
+        }
+        // Re-read so the launch-spec rebuild below sees the fresh model pin.
+        meta = requireMeta(id);
+    }
+    // --- kind / mode / lifecycle: rebuild the launch spec (CLI parity). ---
+    if (patch.kind !== undefined || patch.mode !== undefined || patch.lifecycle !== undefined) {
+        if (patch.kind !== undefined)
+            assertKindServer(patch.kind);
+        const newKind = patch.kind ?? meta.kind;
+        const newMode = (patch.mode ?? meta.mode);
+        const newLifecycle = patch.lifecycle ?? meta.lifecycle;
+        // Setting orchestrator seeds a roadmap scaffold if absent (from the goal).
+        if (newMode === 'orchestrator' && !hasRoadmap(id)) {
+            const goal = readGoal(id);
+            seedRoadmap(id, goal !== null && goal.trim() !== '' ? { goal: goal.trim() } : {});
+        }
+        const { launch } = buildLaunchSpec(newKind, newMode, {
+            lifecycle: newLifecycle,
+            hasManager: meta.parent !== null,
+            ...(meta.model_override != null ? { model: meta.model_override } : {}),
+            ...(meta.launch?.modelProviderPinned !== undefined ? { modelProviderPinned: meta.launch.modelProviderPinned } : {}),
+            cwd: meta.cwd,
+            profileId: meta.profile_id ?? null,
+        });
+        meta = updateNode(id, {
+            ...(patch.kind !== undefined ? { kind: newKind } : {}),
+            ...(patch.mode !== undefined ? { mode: newMode } : {}),
+            ...(patch.lifecycle !== undefined ? { lifecycle: newLifecycle } : {}),
+            launch,
+        });
+    }
+    // --- name: rename the row and, when it has a live viewer window, that window. ---
+    if (patch.name !== undefined) {
+        meta = updateNode(id, { name: patch.name });
+        if (meta.window)
+            renameWindow(meta.window, fullName(meta));
+    }
+    // `thinking` is a live-only frame (set_thinking); a dormant node has no broker
+    // to receive it, so it is a documented Stage-A no-op here.
+    return { status: 200, body: detailOf(id) };
+}
+/** Validate a `--kind` against the installed personas server-side (crtrd reads
+ *  the merged launch config). Mirrors the CLI's assertKind. */
+function assertKindServer(kind) {
+    const kinds = Object.keys(readMergedLaunchConfig().kinds);
+    if (!kinds.includes(kind)) {
+        throw usage(`unknown kind: ${kind}`, { received: kind, next: `Valid kinds: ${kinds.sort().join(', ')}.` });
+    }
+}
+// ---------------------------------------------------------------------------
+// Route table (revive-all registered before `:id` collisions are impossible —
+// different methods — but ordered defensively).
+// ---------------------------------------------------------------------------
+export const nodeRoutes = [
+    { method: 'POST', pattern: '/v1/nodes', handler: handleCreate },
+    { method: 'GET', pattern: '/v1/nodes', handler: handleList },
+    { method: 'POST', pattern: '/v1/nodes/revive-all', handler: () => handleReviveAll() },
+    { method: 'GET', pattern: '/v1/nodes/:id', handler: handleDetail },
+    { method: 'GET', pattern: '/v1/nodes/:id/snapshot', handler: handleSnapshot },
+    { method: 'GET', pattern: '/v1/nodes/:id/session', handler: handleSession },
+    { method: 'GET', pattern: '/v1/nodes/:id/transcript', handler: handleTranscript },
+    { method: 'GET', pattern: '/v1/nodes/:id/context', handler: handleContext },
+    { method: 'GET', pattern: '/v1/nodes/:id/artifacts', handler: handleArtifacts },
+    { method: 'POST', pattern: '/v1/nodes/:id/fork', handler: handleFork },
+    { method: 'POST', pattern: '/v1/nodes/:id/revive', handler: handleRevive },
+    { method: 'POST', pattern: '/v1/nodes/:id/relaunch-root', handler: handleRelaunchRoot },
+    { method: 'POST', pattern: '/v1/nodes/:id/close', handler: handleClose },
+    { method: 'POST', pattern: '/v1/nodes/:id/recycle', handler: handleRecycle },
+    { method: 'POST', pattern: '/v1/nodes/:id/demote', handler: handleDemote },
+    { method: 'POST', pattern: '/v1/nodes/:id/promote', handler: handlePromote },
+    { method: 'POST', pattern: '/v1/nodes/:id/yield', handler: handleYield },
+    { method: 'POST', pattern: '/v1/nodes/:id/wait', handler: handleWait },
+    { method: 'PATCH', pattern: '/v1/nodes/:id/config', handler: handleConfig },
+];

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

@@ -0,0 +1,2 @@
+import type { RouteTable } from '../router.js';
+export declare const profileRoutes: RouteTable;

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

@@ -0,0 +1,69 @@
+// Profile handlers (spec §6.6). Server-side for remote/Core (P2) consumers; the
+// local `crtr profile *` verbs stay fs-local (they never open canvas.db, so the
+// exit criterion is untouched by their staying local). The profile store is a
+// deliberately multi-writer fs store serialized by `withProfileManifestLock`
+// (spec §12), so crtrd installing a profile here coexists with the CLI verbs.
+//
+//   PUT    /v1/profiles/:name    idempotent ensure (create-or-return)
+//   GET    /v1/profiles          list all profiles
+//   GET    /v1/profiles/:name    resolve one profile by name or id
+//   DELETE /v1/profiles/:name    idempotent delete (missing → 204)
+//
+// The primitive is unchanged — the caller is relocated into crtrd (spec §4.3).
+import { CrtrError } from '../../../core/errors.js';
+import { createProfile, deleteProfile, ensureRootProfile, listProfiles, loadProfileManifest, } from '../../../core/profiles/manifest.js';
+import { toProfileDTO } from '../map.js';
+const ROOT_PROFILE_NAME = 'root';
+/** `PUT /v1/profiles/:name` — idempotent ensure. `root` maps to the singleton
+ *  root profile; any other name returns the existing same-named profile if one
+ *  exists (so a re-PUT yields the same id), else creates it. */
+function handleEnsure(ctx) {
+    const name = ctx.params['name'];
+    const req = (ctx.body ?? {});
+    if (name === ROOT_PROFILE_NAME) {
+        return { status: 200, body: toProfileDTO(ensureRootProfile()) };
+    }
+    const existing = listProfiles().find((p) => p.manifest.name === name);
+    if (existing !== undefined) {
+        return { status: 200, body: toProfileDTO(existing) };
+    }
+    const created = createProfile(name, req.projects ?? []);
+    return { status: 200, body: toProfileDTO(created) };
+}
+/** `GET /v1/profiles` — every profile with a readable manifest. */
+function handleList() {
+    return { status: 200, body: listProfiles().map(toProfileDTO) };
+}
+/** `GET /v1/profiles/:name` — resolve one profile by exact id or unique name.
+ *  A miss throws `notFound` (→ 404); an ambiguous name throws `ambiguous`
+ *  (→ 400) — both from the manifest resolver, mapped by `errorToStatus`. */
+function handleGet(ctx) {
+    const name = ctx.params['name'];
+    return { status: 200, body: toProfileDTO(loadProfileManifest(name)) };
+}
+/** `DELETE /v1/profiles/:name` — idempotent delete by exact id or unique name.
+ *  A miss is success (204): the caller's goal — the profile is gone — already
+ *  holds, so reconcile/retry loops (e.g. Core's applet-delete leg) are safe to
+ *  re-run. An ambiguous name still throws `ambiguous` (→ 400): with several
+ *  same-named profiles there is no safe pick, and the state is NOT "already
+ *  deleted". */
+function handleDelete(ctx) {
+    const name = ctx.params['name'];
+    let profileId;
+    try {
+        ({ profileId } = loadProfileManifest(name));
+    }
+    catch (err) {
+        if (err instanceof CrtrError && err.code === 'not_found')
+            return { status: 204 };
+        throw err;
+    }
+    deleteProfile(profileId);
+    return { status: 204 };
+}
+export const profileRoutes = [
+    { method: 'PUT', pattern: '/v1/profiles/:name', handler: handleEnsure },
+    { method: 'DELETE', pattern: '/v1/profiles/:name', handler: handleDelete },
+    { method: 'GET', pattern: '/v1/profiles', handler: handleList },
+    { method: 'GET', pattern: '/v1/profiles/:name', handler: handleGet },
+];

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

@@ -0,0 +1,2 @@
+import type { RouteTable } from '../router.js';
+export declare const reportRoutes: RouteTable;