@north-light/crouter 0.3.232 → 0.3.234

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

@@ -11,13 +11,15 @@
 // the sanctioned place for it.
 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 { getNode, listNodes, 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 { nowIso } from '../../../core/fs-utils.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 { dashboardRowsAllFromSource, enrichRowsFromSource } from '../../../core/canvas/render-source.js';
+import { localCanvasSource } from '../../../core/canvas/source.js';
+import { listFocuses } from '../../../core/canvas/focuses.js';
+import { ticketCountsForNodes, ticketsAcrossCanvas } from '../../../core/canvas/attention.js';
 import { buildCorpus, resolveRef, } from '../../../core/canvas/history.js';
 import { nodeDir, nodesRoot } from '../../../core/canvas/paths.js';
 import { reapEmptyNodes } from '../../../core/runtime/placement.js';
@@ -49,7 +51,6 @@ function handleAttentionCounts(ctx) {
     const body = { counts: ticketCountsForNodes(rawIds) };
     return { status: 200, body };
 }
-// ---------------------------------------------------------------------------
 // history search / grep / read \u2014 the ranked corpus search, the required-
 // pattern line-hit search, and ref resolution. Lifted verbatim from
 // `commands/canvas-history/{search,grep,read}.ts`' run() bodies: the pure
@@ -57,7 +58,6 @@ function handleAttentionCounts(ctx) {
 // now parses+validates flags and POSTs the normalized query). search and grep
 // share the corpus builder and cursor helpers but are distinct wire contracts
 // \u2014 no `--grep` flag survives on the search query.
-// ---------------------------------------------------------------------------
 function encodeCursor(offset) {
     return Buffer.from(String(offset), 'utf8').toString('base64');
 }
@@ -168,7 +168,7 @@ function handleHistorySearch(ctx) {
     const limit = Math.min(100, Math.max(1, q.limit ?? 20));
     const arts = buildCorpusFromQuery(q);
     const offset = q.cursor !== undefined ? decodeCursor(q.cursor) : 0;
-    // --- ranked / browse mode ---
+    // ranked / browse mode
     const terms = query.toLowerCase().split(/\s+/).filter((t) => t.length > 0);
     let pool = arts;
     let scored;
@@ -264,13 +264,13 @@ function handleHistoryRead(ctx) {
     };
     return { status: 200, body };
 }
-// ---------------------------------------------------------------------------
 // snapshot \u2014 the enriched browser canvas roster + subscribes_to adjacency.
 // Lifted from `commands/canvas-snapshot.ts` run() (dashboardRowsAll + enrichRows).
-// ---------------------------------------------------------------------------
-function handleSnapshot() {
-    const rows = dashboardRowsAll();
-    enrichRows(rows);
+async function handleSnapshot() {
+    const focusedNodeIds = new Set(listFocuses().map((f) => f.node_id));
+    const rows = await dashboardRowsAllFromSource(localCanvasSource, focusedNodeIds);
+    const asks = ticketCountsForNodes(rows.map((r) => r.node_id));
+    await enrichRowsFromSource(localCanvasSource, rows, asks);
     const nodes = rows.map((row) => {
         const meta = getNode(row.node_id);
         const hostKind = meta?.host_kind ?? 'tmux';
@@ -308,13 +308,11 @@ function handleSnapshot() {
     const body = { generated_at: nowIso(), nodes, subscriptions };
     return { status: 200, body };
 }
-// ---------------------------------------------------------------------------
 // roster - the lean, set-based topology read (daemon-starvation fix step 2).
 // Exactly two indexed queries (rosterNodes() + rosterEdges()), no enrichRows,
 // no per-row getNode/subscriptionsOf loop, no isStreaming/isPidAlive process
 // probe. Single-flighted below so a burst of concurrent pollers (attach +
 // browser, or several attach viewers) shares one DB pass instead of stacking N.
-// ---------------------------------------------------------------------------
 function buildRoster() {
     const nodes = rosterNodes().map((row) => {
         const hostKind = row.host_kind ?? 'tmux';
@@ -370,10 +368,8 @@ async function handleRoster() {
     const body = await rosterCoalesced();
     return { status: 200, body };
 }
-// ---------------------------------------------------------------------------
 // prune \u2014 the three exclusive modes (COUNT > EMPTY > TTL sweep) + target-gone
 // notification. Lifted from `commands/canvas-prune.ts` run().
-// ---------------------------------------------------------------------------
 /** Validate + narrow the prune body (all fields optional). */
 function parsePruneBody(body) {
     if (body === undefined || body === null)
@@ -436,10 +432,8 @@ function handlePrune(ctx) {
     const body = { pruned, dry_run: dryRun, ttl_days: ttlDays };
     return { status: 200, body };
 }
-// ---------------------------------------------------------------------------
 // rebuild-index \u2014 re-derive rows from on-disk metas + the fail-loud guard.
 // Lifted from `commands/canvas-rebuild-index.ts` (countOnDiskMetas + throw).
-// ---------------------------------------------------------------------------
 function countOnDiskMetas() {
     const root = nodesRoot();
     if (!existsSync(root))

package/dist/daemon/api/handlers/feedback-comments.js

@@ -18,9 +18,7 @@ import { requireTicketId, resolveTicket } from './inbox.js';
 import { invalidRequest, objectBody, optionalString, requiredString } from './validate.js';
 import { toPageFeedbackDTO, toPageFeedbackCommentDTO } from '../map.js';
 const COMMENT_ID = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/;
-// ---------------------------------------------------------------------------
 // Shared guards
-// ---------------------------------------------------------------------------
 /** Resolve a mutable page ticket: it must exist, be a page, and not have a
  * terminal outcome. Passive pages never settle, so they stay commentable.
  * A terminal ticket refuses every feedback action — settlement won. */
@@ -45,9 +43,7 @@ function requireCommentId(params) {
     }
     return commentId;
 }
-// ---------------------------------------------------------------------------
 // Delivery — the person's turn in the companion conversation
-// ---------------------------------------------------------------------------
 /** The comment as the person's own words: the quoted page content and the
  * note, nothing else. The companion's briefing rides its bearings and
  * persona, never the human turn. */
@@ -79,9 +75,7 @@ async function deliverCommentTurn(args) {
         return { target_node_id: target, status: 'failed', woke: false, error: error instanceof Error ? error.message : String(error) };
     }
 }
-// ---------------------------------------------------------------------------
 // POST /v1/human/inbox/:ticket_id/feedback-comments — create
-// ---------------------------------------------------------------------------
 function parseCreate(ctx) {
     const violations = [];
     const body = objectBody(ctx.body, ['quote', 'context', 'note'], violations);
@@ -154,9 +148,7 @@ async function handleCreate(ctx) {
     };
     return { status: 200, body };
 }
-// ---------------------------------------------------------------------------
 // POST .../feedback-comments/:comment_id/resolve — the companion's report
-// ---------------------------------------------------------------------------
 function parseResolve(ctx) {
     const violations = [];
     const body = objectBody(ctx.body, ['node_id'], violations);

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

@@ -6,11 +6,12 @@
 // Both run INSIDE crtrd, so `daemon_up` is trivially true and `daemon_pid` is
 // this process. Store access is probed by a cheap `listNodes()` — a throw means
 // the store is inaccessible.
-import { listNodes } from '../../../index.js';
+import { listNodes } from '../../../core/canvas/canvas.js';
 import { apiSocketPath } from '../../../core/canvas/paths.js';
 import { currentVersion } from '../../../core/self-update.js';
 import { API_VERSION } from '../../../api/index.js';
 import { DEFAULT_INTERVAL_MS } from '../../supervise-cadence.js';
+import { envCrtrdTcp } from '../../../shared/env.js';
 // The daemon's supervise-loop cadence, echoed as an informational field; the
 // loop itself is unchanged (hard constraint). Derived from the single shared
 // constant so it can never drift from crtrd's actual interval.
@@ -45,7 +46,7 @@ function handleStatus() {
         // The store is unreachable — spec §8 store_unavailable.
         throw { status: 503, code: 'store_unavailable', message: 'canvas store is inaccessible' };
     }
-    const tcp = process.env['CRTRD_TCP'];
+    const tcp = envCrtrdTcp();
     const body = {
         daemon_pid: process.pid,
         tick_interval_ms: TICK_INTERVAL_MS,

package/dist/daemon/api/handlers/human-requests.js

@@ -21,9 +21,7 @@ const REASON_MAX = 1000;
 const ACTOR_MAX = 200;
 const DEFAULT_DELIVERY = { placement: 'inline', inbox: true, reply: false };
 const SOURCE_FIELDS = ['sessionName', 'askedBy', 'emittedAt', 'profileName', 'nodeId'];
-// ===========================================================================
 // Body validation
-// ===========================================================================
 function isPlainObject(value) {
     return typeof value === 'object' && value !== null && !Array.isArray(value);
 }
@@ -259,9 +257,7 @@ function requestToDTO(request) {
     }
     return dto;
 }
-// ===========================================================================
 // POST /v1/human/requests — create
-// ===========================================================================
 /** Authoring failure is the caller's malformed page, never a server fault. */
 function prepareOrReject(dialect, document, source, delivery) {
     try {
@@ -312,15 +308,11 @@ function handleCreate(ctx) {
         },
     };
 }
-// ===========================================================================
 // GET /v1/human/requests/:request_id — read
-// ===========================================================================
 function handleGet(ctx) {
     return { status: 200, body: requestToDTO(resolveRequest(ctx)) };
 }
-// ===========================================================================
 // POST /v1/human/requests/:request_id/replace — revise the pending page
-// ===========================================================================
 function handleReplace(ctx) {
     const request = resolveRequest(ctx);
     if (request.result !== null)
@@ -332,9 +324,7 @@ function handleReplace(ctx) {
     publishPage(request.dir, prepared);
     return { status: 200, body: requestToDTO({ ...request, manifest: prepared.manifest }) };
 }
-// ===========================================================================
 // Settlement — respond, dismiss, cancel
-// ===========================================================================
 /** The settlement funnels speak the inbox's error vocabulary; requests speak
  * the wire contract's. This is the one translation. */
 function settlementError(error) {

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

@@ -19,9 +19,7 @@ function requireInteractionTicketId(ctx) {
     }
     return ticketId;
 }
-// ===========================================================================
 // POST /v1/human/bridge — create a terminal bridge without a broker
-// ===========================================================================
 function handleCreateBridge(ctx) {
     const req = ctx.body;
     if (req === undefined || typeof req !== 'object') {
@@ -46,9 +44,7 @@ function handleCreateBridge(ctx) {
         throw new ApiError(400, 'invalid_request', String(error));
     }
 }
-// ===========================================================================
 // POST /v1/human/tickets/:ticket_id/resolve and /cancel
-// ===========================================================================
 function reviewSubmitGuidance() {
     return new ApiError(400, 'invalid_request', 'review approvals use POST /v1/human/reviews/:review_id/submit');
 }
@@ -100,7 +96,7 @@ async function handleResolve(ctx) {
     return { status: 200, body: { completed: true, reply_delivered: replyExpected, kind: 'page' } };
 }
 function hasPublishedTicket(dir) {
-    return existsSync(pageManifestPath(dir)) || existsSync(reviewPath(dir)) || readTicketResult(dir) !== null;
+    return existsSync(pageManifestPath(dir)) || readTicketResult(dir) !== null;
 }
 async function handleCancel(ctx) {
     const ticketId = requireInteractionTicketId(ctx);

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

@@ -18,9 +18,7 @@ import { filterTerminalReviewTickets } from '../../../core/review/ticket-filter.
 const DEFAULT_CANCEL_REASON = 'Canceled from the inbox.';
 const CANCEL_REASON_MAX = 1000;
 const TICKET_ID_PATTERN = /^[a-f0-9]{64}$/;
-// ===========================================================================
 // Opaque ticket id resolution
-// ===========================================================================
 function ticketHash(canonicalRoot, ticketBasename) {
     return createHash('sha256').update(`${canonicalRoot}\0${ticketBasename}`, 'utf8').digest('hex');
 }
@@ -70,9 +68,7 @@ export function requireTicketId(params) {
     }
     return ticketId;
 }
-// ===========================================================================
 // Projections — humanloop canonical shapes → wire DTOs
-// ===========================================================================
 function pageSlotToDTO(slot) {
     const dto = {
         kind: slot.kind,
@@ -166,9 +162,7 @@ const SLOT_VALIDATION_PATTERNS = [
 function isSlotValidationError(err) {
     return err instanceof Error && SLOT_VALIDATION_PATTERNS.some((pattern) => pattern.test(err.message));
 }
-// ===========================================================================
 // GET /v1/human/inbox — enumerate
-// ===========================================================================
 /** The one page-summary projection: the pending list and the per-node history differ only in which tickets they walk. */
 function pageSummaryToDTO(item, canonicalRoot) {
     const dto = {
@@ -222,9 +216,7 @@ function handleList() {
     });
     return { status: 200, body: { tickets } };
 }
-// ===========================================================================
 // 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');
@@ -236,9 +228,7 @@ function handleHistory(ctx) {
     const tickets = history.map((item) => pageSummaryToDTO(item, canonicalRoot));
     return { status: 200, body: { tickets } };
 }
-// ===========================================================================
 // GET /v1/human/inbox/:ticket_id — read a page ticket
-// ===========================================================================
 function handleGetPage(ctx) {
     const ticketId = requireTicketId(ctx.params);
     const resolved = resolveTicket(ticketId);
@@ -270,9 +260,7 @@ function handleGetPage(ctx) {
         },
     };
 }
-// ===========================================================================
 // POST /v1/human/inbox/:ticket_id/respond — submit
-// ===========================================================================
 async function handleRespond(ctx) {
     const ticketId = requireTicketId(ctx.params);
     const request = validateRespondRequest(ctx.body);
@@ -317,9 +305,7 @@ async function handleRespond(ctx) {
         throw new ApiError(500, 'internal', 'the ticket could not be finalized');
     }
 }
-// ===========================================================================
 // POST /v1/human/inbox/:ticket_id/progress — autosave
-// ===========================================================================
 function handleProgress(ctx) {
     const ticketId = requireTicketId(ctx.params);
     const request = validateProgressRequest(ctx.body);
@@ -346,9 +332,7 @@ function handleProgress(ctx) {
         throw new ApiError(500, 'internal', 'progress could not be saved');
     }
 }
-// ===========================================================================
 // POST /v1/human/inbox/:ticket_id/cancel — cancel
-// ===========================================================================
 async function handleCancel(ctx) {
     const ticketId = requireTicketId(ctx.params);
     const request = validateCancelRequest(ctx.body);
@@ -378,9 +362,7 @@ async function handleCancel(ctx) {
         throw new ApiError(500, 'internal', 'the ticket could not be canceled');
     }
 }
-// ===========================================================================
 // GET /v1/human/inbox/:ticket_id/response — published response
-// ===========================================================================
 function handleGetResponse(ctx) {
     const ticketId = requireTicketId(ctx.params);
     const resolved = resolveTicket(ticketId);

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

@@ -8,7 +8,7 @@
 // to different documents for two nodes (each has its own context store, project
 // stack, and profile). Resolution therefore runs target-addressed —
 // `resolveMemoryDocForTarget` with the node's cwd/profile/id off canvas.
-import { getNode } from '../../../index.js';
+import { getNode } from '../../../core/canvas/canvas.js';
 import { notFound, usage } from '../../../core/errors.js';
 import { resolveMemoryDocForTarget } from '../../../core/memory-resolver.js';
 import { isDocLinkName } from '../../../core/memory/doc-link-grammar.js';

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

@@ -1,13 +1,13 @@
 // Message handler (spec §6.2). `POST /v1/nodes/{id}/messages` delivers an
 // inbox message now (201) or fresh-revives with no inbox entry. `{id}` is the
 // target node.
-import { appendInbox, getNode, reviveNode } from '../../../index.js';
+import { appendInbox, cancelPendingHumanMessages } from '../../../core/feed/inbox.js';
+import { reviveNode } from '../../../core/runtime/revive.js';
 import { BrokerUnreachableError } from '../../../core/runtime/broker-request.js';
 import { isBrokerLive } from '../../../core/runtime/model-swap.js';
 import { deliverLive, interruptLive } from '../../../core/runtime/interactive-deliver.js';
-import { cancelPendingHumanMessages } from '../../../core/feed/inbox.js';
 import { isProfilePaused } from '../../../core/profiles/manifest.js';
-import { withFreshTerminalGuard } from '../../../core/canvas/canvas.js';
+import { getNode, withFreshTerminalGuard } from '../../../core/canvas/canvas.js';
 import { assertNotFinalized, assertFinalizedForReopen, commitReopen, commitReopenResident, } from '../../../core/runtime/reopen.js';
 import { writeOutputSchema } from '../../../core/runtime/structured-output.js';
 import { appendSituationalContext, formatSituationalProse } from '../../../core/runtime/situational-context.js';
@@ -17,9 +17,7 @@ import { hasFreshGroundState } from '../../../core/runtime/revive.js';
 import { notFound, usage } from '../../../core/errors.js';
 import { InputError } from '../../../core/io.js';
 import { ApiError } from '../../../api/index.js';
-// ---------------------------------------------------------------------------
 // POST /v1/nodes/{id}/messages
-// ---------------------------------------------------------------------------
 const TIERS = ['critical', 'urgent', 'normal', 'deferred'];
 /** Validate + narrow one caller-supplied runtime card. A bare kind is crouter's
  *  own closed vocabulary, so a caller must namespace: no product can shadow a
@@ -209,7 +207,7 @@ async function handleMessage(ctx) {
     const schema = req.output_schema !== undefined && req.output_schema.trim() !== ''
         ? parseSchema(req.output_schema)
         : null;
-    // --- Fresh revive: no inbox entry, resume:false (spec §7.7). ---
+    // Fresh revive: no inbox entry, resume:false (spec §7.7).
     // Mirrors the CLI's immediate --fresh: validate/clear the finalization latch
     // (--reopen) and upsert the situational sidecar BEFORE the revive, so the
     // fresh kickoff picks up the update. The goal/roadmap recoverable-state guard
@@ -344,9 +342,7 @@ async function handleMessage(ctx) {
     };
     return { status: 201, body };
 }
-// ---------------------------------------------------------------------------
 // POST /v1/nodes/{id}/interrupt
-// ---------------------------------------------------------------------------
 /** The human Esc, first-class. Cancel pending undelivered human sends FIRST,
  *  then abort the live turn — in that order, so a watcher injection racing
  *  between the two is caught by the abort right behind it. A dormant target is

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

@@ -6,12 +6,15 @@
 // map.ts carries no projector — it is frozen under concurrency).
 //
 // `{id}` is the target node.
+import { envProfileId } from '../../../shared/env.js';
 import { readdirSync } from 'node:fs';
 import { basename } from 'node:path';
-import { appendSituationalContext, closeNode, getNode, listNodes, nowIso, reviveNode, } from '../../../index.js';
-import { formatSituationalProse } from '../../../core/runtime/situational-context.js';
+import { appendSituationalContext, formatSituationalProse } from '../../../core/runtime/situational-context.js';
+import { closeNode } from '../../../core/runtime/close.js';
+import { reviveNode } from '../../../core/runtime/revive.js';
+import { nowIso } from '../../../core/fs-utils.js';
 import { assertLaunchModelRegistered, forkNode, spawnChild } from '../../../core/runtime/spawn.js';
-import { childrenOf, subscribersOf, subscriptionsOf, setMessageWait, updateNode } from '../../../core/canvas/canvas.js';
+import { childrenOf, getNode, listNodes, subscribersOf, subscriptionsOf, setMessageWait, updateNode } from '../../../core/canvas/canvas.js';
 import { subtreeIds } from '../../../core/canvas/nav-model.js';
 import { ticketCountsForNodes } from '../../../core/canvas/attention.js';
 import { contextDir, reportsDir } from '../../../core/canvas/paths.js';
@@ -40,9 +43,7 @@ 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)
@@ -76,9 +77,7 @@ function countFiles(id) {
     }
     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) {
@@ -192,7 +191,7 @@ export async function handleCreate(ctx, deps = {}) {
     // 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. ---
+    // 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)');
     }
@@ -233,9 +232,7 @@ export async function handleCreate(ctx, deps = {}) {
         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 singleQueryValue(ctx, name) {
     const values = ctx.query.getAll(name);
     if (values.length > 1)
@@ -343,9 +340,7 @@ function handleDetail(ctx) {
     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);
@@ -458,9 +453,7 @@ function handleArtifacts(ctx) {
     const body = { node_id: id, artifacts };
     return { status: 200, body };
 }
-// ---------------------------------------------------------------------------
 // Lifecycle verbs
-// ---------------------------------------------------------------------------
 async function handleFork(ctx) {
     const id = ctx.params['id'];
     requireMeta(id);
@@ -601,9 +594,7 @@ function handleReviveAll() {
     const body = { revived: [...result.revived], failed: [...result.failed] };
     return { status: 200, body };
 }
-// ---------------------------------------------------------------------------
 // PATCH /v1/nodes/{id}/config — model / situational-context (spec §6.2)
-// ---------------------------------------------------------------------------
 export async function handleConfig(ctx, deps = {}) {
     const id = ctx.params['id'];
     let meta = requireMeta(id);
@@ -646,7 +637,7 @@ export async function handleConfig(ctx, deps = {}) {
         // Re-read so the launch-spec rebuild below sees the fresh model pin.
         meta = requireMeta(id);
     }
-    // --- kind / mode / lifecycle: reshape via canonical primitive (CLI parity). ---
+    // kind / mode / lifecycle: reshape via canonical primitive (CLI parity).
     if (patch.kind !== undefined || patch.mode !== undefined || patch.lifecycle !== undefined) {
         if (patch.kind !== undefined)
             await assertKindServer(patch.kind);
@@ -671,7 +662,7 @@ export async function handleConfig(ctx, deps = {}) {
             ...(patch.lifecycle !== undefined ? { lifecycle: newLifecycle } : {}),
         }, beforePersist);
     }
-    // --- name: rename the row and, when it has a live viewer window, that window. ---
+    // 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)
@@ -685,15 +676,13 @@ export async function handleConfig(ctx, deps = {}) {
  * ambient configuration; prospective reads validate their resolved target. The
  * read is subprocess-isolated — crtrd must never resolve config on its own loop. */
 async function assertKindServer(kind) {
-    const kinds = Object.keys((await readMergedLaunchConfigAsync(process.cwd(), process.env['CRTR_PROFILE_ID'] || null)).kinds);
+    const kinds = Object.keys((await readMergedLaunchConfigAsync(process.cwd(), envProfileId() || null)).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 },

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

@@ -6,7 +6,7 @@
 // `{id}` is the REPORTING node (client-side = CRTR_NODE_ID).
 import { existsSync, readdirSync, readFileSync, statSync } from 'node:fs';
 import { join } from 'node:path';
-import { getNode } from '../../../index.js';
+import { getNode } from '../../../core/canvas/canvas.js';
 import { push, FinalizationError } from '../../../core/feed/feed.js';
 import { autoDropCleanManagedWorktree, hasOpenManagedWorktree, missingWorktreeRecoveryHint } from '../../../core/worktree.js';
 import { reportsDir } from '../../../core/canvas/paths.js';

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

@@ -1,10 +1,8 @@
 // Canonical daemon-owned review lifecycle routes. Handlers validate the full
 // wire request, delegate lifecycle work to review services, and project only
 // committed daemon state.
-import { existsSync } from 'node:fs';
-import { ApiError } from '../../../api/index.js';
 import { isSafeNodeId, reviewResultPath } from '../../../core/canvas/paths.js';
-import { responsePath, reviewPath } from '../../../core/human/convention.js';
+import { responsePath } from '../../../core/human/convention.js';
 import { ticketDir } from '../../../core/human/root.js';
 import { createReview } from '../../../core/review/birth.js';
 import { readAnchorBase, getReviewByBridge, listReviews, requireVisibleReview } from '../../../core/review/store.js';
@@ -168,9 +166,6 @@ function handleByBridge(ctx) {
     const review = getReviewByBridge(bridgeNodeId);
     if (review !== null)
         return { status: 200, body: toReviewResponseDTO(review) };
-    if (existsSync(reviewPath(ticketDir(bridgeNodeId)))) {
-        throw new ApiError(409, 'review_predates_system', 'this review predates canonical review records; cancel it and re-file the review', { bridge_node_id: bridgeNodeId });
-    }
     throw new ReviewOperationError('unknown_review', 'review was not found', { received: bridgeNodeId });
 }
 async function handleSubmit(ctx) {

package/dist/daemon/api/map.js

@@ -20,9 +20,7 @@ import { ExitCode } from '../../types.js';
 import { sinkDisplay } from '../cron-sink.js';
 import { responsePath } from '../../core/human/convention.js';
 import { ticketDir } from '../../core/human/root.js';
-// ---------------------------------------------------------------------------
 // Node projections
-// ---------------------------------------------------------------------------
 /** Project the queryable row (what `listNodes` yields) into a summary DTO. */
 export function toNodeSummaryDTO(row) {
     return {
@@ -144,9 +142,7 @@ export function toNodeDetailDTO(meta, edges) {
         dto.worktree = toNodeWorktreeDTO(meta.managed_worktree);
     return dto;
 }
-// ---------------------------------------------------------------------------
 // Action-result projections
-// ---------------------------------------------------------------------------
 /** Project a `reviveNode` result. `revived` is true only when a fresh launch
  *  actually happened — the double-revive no-op (already-alive) returns without a
  *  `launch` handle, so its absence is the "nothing relaunched" signal. `status`
@@ -398,9 +394,7 @@ export function toFeedbackResultDTO(result) {
 }
 const _exitIntentParity = true;
 void _exitIntentParity;
-// ---------------------------------------------------------------------------
 // Error → HTTP status mapping (spec §8)
-// ---------------------------------------------------------------------------
 /** The only internal review-error to public HTTP projection. Every internal
  * review failure is listed explicitly so handlers never need to invent a status
  * or public code. */

package/dist/daemon/api/router.js

@@ -102,9 +102,7 @@ export class Router {
         }
     }
 }
-// ---------------------------------------------------------------------------
 // Matching
-// ---------------------------------------------------------------------------
 /** Split a path/pattern into non-empty segments (leading/trailing '/' ignored). */
 function splitPath(p) {
     return p.split('/').filter((s) => s.length > 0);
@@ -127,9 +125,7 @@ function matchSegments(pattern, actual) {
     }
     return params;
 }
-// ---------------------------------------------------------------------------
 // Body + response I/O
-// ---------------------------------------------------------------------------
 class BodyTooLargeError extends Error {
 }
 /** Read and JSON-parse the request body. Returns `undefined` for an empty body.

package/dist/daemon/api/server.js

@@ -16,6 +16,7 @@ import { createServer } from 'node:http';
 import { chmodSync, existsSync, unlinkSync } from 'node:fs';
 import { apiSocketPath } from '../../core/canvas/paths.js';
 import { emitEvent } from '../../core/events/emit.js';
+import { envCrtrdTcp } from '../../shared/env.js';
 import { Router } from './router.js';
 import { handleAttachUpgrade } from './bridge.js';
 import { attachRoutes } from './handlers/attach.js';
@@ -204,10 +205,8 @@ export function createApiServer(opts = {}) {
             emitEvent({ event: 'api.server.failed', level: 'error', error: err });
         });
     };
-    // -------------------------------------------------------------------------
     // Unix socket — ALWAYS bound. Unlink any stale socket first (mirror
     // broker.ts's listener setup), listen, then chmod 0600 once the file exists.
-    // -------------------------------------------------------------------------
     const socketServer = createServer(onRequest);
     socketServer.on('upgrade', onUpgrade);
     bindErrorHandler(socketServer);
@@ -230,11 +229,9 @@ export function createApiServer(opts = {}) {
             });
         }
     });
-    // -------------------------------------------------------------------------
     // TCP — opt-in only. A SECOND http.Server sharing the same handlers.
-    // -------------------------------------------------------------------------
     let tcpServer;
-    const tcpSpec = opts.tcp ?? process.env['CRTRD_TCP'];
+    const tcpSpec = opts.tcp ?? envCrtrdTcp();
     if (tcpSpec !== undefined && tcpSpec !== '') {
         const parsed = parseTcp(tcpSpec);
         if (parsed === null) {

package/dist/daemon/boot-migrations.d.ts

@@ -0,0 +1,14 @@
+export interface BootMigrationResult {
+    changed: boolean;
+    summary: Record<string, unknown>;
+}
+export interface BootMigration {
+    readonly id: string;
+    readonly description: string;
+    /** Runs unconditionally at every daemon boot. Must be safe to re-run every
+     *  time (idempotent via its own convergence, not a version gate) and must
+     *  isolate its own per-item failures — a thrown error here is NOT caught by
+     *  the boot sequence and would abort daemon startup. */
+    apply(): BootMigrationResult;
+}
+export declare const BOOT_MIGRATIONS: readonly BootMigration[];