@north-light/crouter 0.3.233 → 0.3.234

package/dist/daemon/api/__tests__/seam/api-server.test.js

@@ -72,9 +72,7 @@ function countLines(path) {
         return 0;
     }
 }
-// ---------------------------------------------------------------------------
 // A1 — /healthz ok + socket mode 0600
-// ---------------------------------------------------------------------------
 test('A1: /healthz is ok and the unix socket is bound mode 0600', async () => {
     const health = await client.healthz();
     assert.equal(health.ok, true, 'GET /healthz → { ok: true }');
@@ -86,10 +84,8 @@ test('attention counts reads only the requested node slice', async () => {
     const result = await client.attentionCounts([root, 'unknown-node']);
     assert.deepEqual(result.counts, { [root]: 0, 'unknown-node': 0 });
 });
-// ---------------------------------------------------------------------------
 // A2 — POST /nodes → live node (row + broker + recorded pid), GET shows active,
 //      view.sock exists
-// ---------------------------------------------------------------------------
 test('A2: POST /nodes boots a live broker; GET /nodes/{id} shows active + live pid + view.sock', async () => {
     const root = h.spawnRoot('a2 root'); // in-process resident, pi_pid = harness pid (alive)
     const detail = await client.createNode({ kind: 'developer', parent: root, prompt: 'a2 worker' });
@@ -103,31 +99,27 @@ test('A2: POST /nodes boots a live broker; GET /nodes/{id} shows active + live p
     assert.ok(meta?.pi_pid != null && isPidAlive(meta.pi_pid), 'row records a live broker pid');
     assert.ok(existsSync(h.brokerSock(id)), 'view.sock exists for the live broker');
 });
-// ---------------------------------------------------------------------------
 // A3 — POST .../messages appends inbox.jsonl; POST .../reports {tier:'final'}
 //      writes the report, notifies subscribers, transitions the row
-// ---------------------------------------------------------------------------
 test('A3: messages append inbox.jsonl; final report writes + notifies subscriber + transitions row', async () => {
     const A = h.spawnRoot('a3 mgr');
     const B = (await client.createNode({ kind: 'developer', parent: A, prompt: 'a3 worker' })).node_id;
     await h.awaitBoot(B);
-    // --- messages append inbox.jsonl (raw line count is cursor-independent) ---
+    // messages append inbox.jsonl (raw line count is cursor-independent)
     const inboxFile = inboxPath(B);
     const before = countLines(inboxFile);
     const msg = await client.sendMessage(B, { body: 'hello inbox' });
     assert.equal(msg.delivered, true, 'message reports delivered');
     await h.waitFor(() => countLines(inboxFile) > before, { label: 'inbox.jsonl appended', timeoutMs: 10_000 });
-    // --- final report: file written + subscriber notified + row transitioned ---
+    // final report: file written + subscriber notified + row transitioned
     const res = await client.pushReport(B, { tier: 'final', body: 'a3 done result' });
     assert.ok(existsSync(res.report_path), `report file written at ${res.report_path}`);
     assert.ok(res.notified.includes(A), `final push notifies the spawn-subscribed manager A (notified=${JSON.stringify(res.notified)})`);
     assert.deepEqual(res.transitioned, { from: 'active', to: 'done' }, 'row transitioned active→done');
     assert.equal(h.node(B)?.status, 'done', 'row status is done after final');
 });
-// ---------------------------------------------------------------------------
 // A4 — WS attach reconstructs the same settled broker snapshot as a direct
 //      ViewSocketClient; ?revive=0 on a dormant node → 409 without launching a broker
-// ---------------------------------------------------------------------------
 test('A4a: WS attach welcome.snapshot is byte-identical to a direct ViewSocketClient snapshot', async () => {
     const root = h.spawnRoot('a4 root');
     const id = (await client.createNode({ kind: 'developer', parent: root, prompt: 'a4 worker' })).node_id;
@@ -229,9 +221,7 @@ test('A4b: ?revive=0 on a dormant node refuses 409 without launching a broker',
     assert.equal(h.bootCount(dorm), bootsBefore, 'no broker was launched (boot count unchanged)');
     assert.equal(h.node(dorm)?.pi_pid ?? null, null, 'no pid recorded — the node stayed dormant');
 });
-// ---------------------------------------------------------------------------
 // A5 — POST .../close tears down the broker + cascades per edges
-// ---------------------------------------------------------------------------
 test('A5: close tears down the target broker and cascades its subtree, leaving the ancestor untouched', async () => {
     const A = h.spawnRoot('a5 root');
     const B = (await client.createNode({ kind: 'developer', parent: A, prompt: 'a5 mid' })).node_id;
@@ -259,12 +249,10 @@ test('A5: close tears down the target broker and cascades its subtree, leaving t
     assert.equal(h.node(C)?.status, 'canceled', 'cascaded child C is canceled');
     assert.equal(h.node(A)?.status, 'active', 'ancestor A is untouched (still active)');
 });
-// ---------------------------------------------------------------------------
 // A6 — PUT /profiles/{name} idempotent; PUT /model-auth/{provider} writes
 //      auth.json (sandboxed PI_CODING_AGENT_DIR).
 //      HONEST PROXY: reload fan is asserted as the file write only (the mtime
 //      watcher lives in runDaemon, not createApiServer).
-// ---------------------------------------------------------------------------
 test('A6a: PUT /profiles/{name} is idempotent (twice → same profile id)', async () => {
     // Profiles write under `join(homedir(), '.crouter', 'profiles')` — homedir()
     // honors HOME, which the harness only overrides for SUBPROCESS children. For
@@ -312,11 +300,9 @@ test('A6b: PUT /model-auth/{provider} writes auth.json (reload fan asserted as f
         rmSync(piDir, { recursive: true, force: true });
     }
 });
-// ---------------------------------------------------------------------------
 // /v1/files/peek — host file read (capped → `truncated`), plus the
 // usage/relative/404 error mapping. Covers the handler's non-trivial
 // branching (usage / notFound / directory / truncation boundary).
-// ---------------------------------------------------------------------------
 const PEEK_CAP = 512 * 1024; // MUST mirror PEEK_MAX_BYTES in handlers/files.ts
 test('files/peek: 200 returns full content, untruncated, for a small file', async () => {
     const dir = mkdtempSync(join(tmpdir(), 'crtr-peek-'));

package/dist/daemon/api/__tests__/seam/b10-attach-modelauth.test.js

@@ -60,10 +60,8 @@ after(async () => {
     await server?.close();
     await h?.dispose();
 });
-// ---------------------------------------------------------------------------
 // B2 (attach hybrid) — ensureAttach revives a DORMANT node server-side; the
 // direct view.sock snapshot streams; DETACH LEAVES THE BROKER RUNNING.
-// ---------------------------------------------------------------------------
 test('B2-attach: ensureAttach revives a dormant node, snapshot streams, detach leaves the broker running', async () => {
     const root = h.spawnRoot('b10 attach root'); // in-process resident (alive pid)
     const id = (await client.createNode({ kind: 'developer', parent: root, prompt: 'b10 attach worker' })).node_id;
@@ -87,7 +85,7 @@ test('B2-attach: ensureAttach revives a dormant node, snapshot streams, detach l
     // reviveNode's double-launch guard reads the fleet entry, so attaching in the
     // window between the kill and the child-exit delivery is correctly a no-op.
     await h.awaitFleetExit(id);
-    // --- ensureAttach (the exact call viewer.ts makes) revives it SERVER-SIDE ---
+    // ensureAttach (the exact call viewer.ts makes) revives it SERVER-SIDE
     const res = await client.ensureAttach(id, { resume: true, revive: true });
     assert.equal(res.node_id, id, 'ensureAttach echoes the node id');
     assert.equal(res.revived, true, 'server launched a fresh broker (revived=true) for the dormant node');
@@ -101,7 +99,7 @@ test('B2-attach: ensureAttach revives a dormant node, snapshot streams, detach l
     //     hop viewer.ts keeps local). ---
     const attached = await kit.attach(id, 'observer', 'b10-attach-observer');
     assert.ok(attached.welcome.snapshot != null, 'welcome frame carries a reconstructed snapshot (snapshot streams)');
-    // --- DETACH LEAVES THE BROKER RUNNING (reap-on-detach removed this batch) ---
+    // DETACH LEAVES THE BROKER RUNNING (reap-on-detach removed this batch)
     attached.close();
     // Give any (now-absent) reap path a beat to have fired, then assert the broker
     // is unmistakably still alive.
@@ -111,11 +109,9 @@ test('B2-attach: ensureAttach revives a dormant node, snapshot streams, detach l
     assert.ok(isPidAlive(afterDetachPid), 'detach left the broker RUNNING (no reap-on-detach)');
     assert.notEqual(h.node(id)?.status, 'done', 'detach did not finalize the node');
 });
-// ---------------------------------------------------------------------------
 // B2 (model-auth) — installCredential writes auth.json (content asserted), the
 // reload FAN acks against a live broker, and the API path is byte-identical to
 // the old direct-write path.
-// ---------------------------------------------------------------------------
 test('B2-modelauth: installCredential writes auth.json and the reload fan acks a live broker', async () => {
     // Sandbox pi's credential store so the write lands in a throwaway dir, never the
     // developer's real ~/.pi/agent/auth.json. authPath() honors PI_CODING_AGENT_DIR.
@@ -128,7 +124,7 @@ test('B2-modelauth: installCredential writes auth.json and the reload fan acks a
         const root = h.spawnRoot('b10 modelauth root');
         liveId = (await client.createNode({ kind: 'developer', parent: root, prompt: 'b10 fan target' })).node_id;
         await h.awaitBoot(liveId);
-        // --- installCredential (the exact call setup.ts makes) writes auth.json ---
+        // installCredential (the exact call setup.ts makes) writes auth.json
         const res = await client.installCredential('anthropic', { kind: 'api_key', api_key: 'sk-b10-test-key' });
         assert.equal(res.installed, true, 'credential reports installed');
         assert.equal(res.managed, false, 'api_key install is not a managed-pool account');
@@ -150,14 +146,12 @@ test('B2-modelauth: installCredential writes auth.json and the reload fan acks a
         rmSync(apiDir, { recursive: true, force: true });
     }
 });
-// ---------------------------------------------------------------------------
 // B2 (model-auth, oauth) — non-managed OAuth install must PRESERVE
 // provider-specific extra credential fields (e.g. github-copilot's
 // `enterpriseUrl`, load-bearing for enterprise routing/refresh). The client
 // forwards non-standard keys through `extra` and the handler re-spreads them.
 // Regression guard for review M1 (a dropped enterpriseUrl breaks
 // GitHub-Enterprise Copilot).
-// ---------------------------------------------------------------------------
 test('B2-modelauth-oauth: installCredential(oauth) preserves extra fields (enterpriseUrl)', async () => {
     const savedPiDir = process.env['PI_CODING_AGENT_DIR'];
     const apiDir = mkdtempSync(join(tmpdir(), 'crtr-b10-oauth-api-'));
@@ -192,10 +186,8 @@ test('B2-modelauth-oauth: installCredential(oauth) preserves extra fields (enter
         rmSync(apiDir, { recursive: true, force: true });
     }
 });
-// ---------------------------------------------------------------------------
 // Credential truth/removal — GET exposes only connection state and DELETE
 // clears exactly its provider's durable store.
-// ---------------------------------------------------------------------------
 test('B2-modelauth-status: list is sanitized and delete clears only the selected provider', async () => {
     const savedPiDir = process.env['PI_CODING_AGENT_DIR'];
     const apiDir = mkdtempSync(join(tmpdir(), 'crtr-b10-status-'));

package/dist/daemon/api/__tests__/seam/leaf-api-parity.test.js

@@ -127,12 +127,10 @@ after(async () => {
     else
         process.env['CRTR_NODE_ID'] = savedNodeId;
 });
-// ---------------------------------------------------------------------------
 // push final — the report write, the subscriber fan, and the lifecycle
 // transition all happen server-side, driven through the real push.ts leaf. A
 // parent spawns a child (so the parent subscribes to the child); the child
 // pushes.
-// ---------------------------------------------------------------------------
 test('`crtr push final` from a child writes a report, notifies the subscribed parent, AND transitions the child row active→done', async () => {
     const parent = h.spawnRoot('leaf-api-parity final parent');
     const child = (await client.createNode({ kind: 'developer', parent, prompt: 'final worker' })).node_id;
@@ -153,11 +151,9 @@ test('`crtr push final` from a child writes a report, notifies the subscribed pa
     // — the re-homed guard only engages for a managed-worktree owner.
     assert.equal('worktree_auto_dropped' in out, false, 'a normal node final is unaffected by the worktree guard');
 });
-// ---------------------------------------------------------------------------
 // Re-homed worktree guard/auto-drop (ambiguity-2 follow-up): the pre-B-5 CLI
 // `push final` worktree behavior now lives SERVER-side in handlers/reports.ts,
 // exercised end-to-end through the real push.ts leaf.
-// ---------------------------------------------------------------------------
 test('re-homed guard: `crtr push final` on a node with a managed worktree holding REAL unlanded commits blocks with the parity open_managed_worktree InputError (round-tripped from the server), and does NOT finalize', async () => {
     const repo = initRepo();
     try {
@@ -255,13 +251,11 @@ test('`crtr push final` keeps an absent managed worktree open when its branch is
         rmSync(repo, { recursive: true, force: true });
     }
 });
-// ---------------------------------------------------------------------------
 // `node worktree close` error parity — the SPECIFIC WorktreeError code + its
 // `next` remediation round-trip verbatim through the server → ApiError → the
 // bespoke CLI mapper in node-worktree.ts, instead of collapsing to a generic
 // status bucket. That mapper exists for exactly this contract, so this is the
 // load-bearing regression to lock.
-// ---------------------------------------------------------------------------
 test('`crtr node worktree close` on a node with NO managed worktree round-trips the specific `no_managed_worktree` code + its exact next-hint (not a generic status bucket)', async () => {
     const id = 'wt-close-none';
     createNode({ node_id: id, name: id, created: new Date().toISOString(), cwd: process.cwd(), kind: 'developer', mode: 'base', lifecycle: 'terminal', status: 'active' });

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

@@ -5,7 +5,8 @@
 // is bridge.ts's (A-8) — NOT routed here.
 //
 // `{id}` is the target node being attached to.
-import { getNode, reviveNode } from '../../../index.js';
+import { getNode } from '../../../core/canvas/canvas.js';
+import { reviveNode } from '../../../core/runtime/revive.js';
 import { viewSocketPath } from '../../../core/canvas/paths.js';
 import { waitForBrokerViewSocket } from '../../../core/runtime/placement-tmux.js';
 import { notFound, usage } from '../../../core/errors.js';

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

@@ -6,7 +6,7 @@ import { editorLabel } from '../../../core/canvas/labels.js';
 import { assembleNodeSubject } from '../../../core/substrate/subject.js';
 import { withCanvasWrite } from '../../../core/canvas/db.js';
 import { notFound, usage } from '../../../core/errors.js';
-import { readCursor, readInboxSince, writeCursor } from '../../../core/feed/inbox.js';
+import { hasUnseenWakeMail, readCursor, readInboxSince, writeCursor } from '../../../core/feed/inbox.js';
 import { clearYieldMessage } from '../../../core/runtime/kickoff.js';
 import { transition } from '../../../core/runtime/lifecycle.js';
 import { focusOf, tearDownNode } from '../../../core/runtime/placement.js';
@@ -224,9 +224,6 @@ function handleSessionBound(ctx) {
     });
     return { status: 200, body: result };
 }
-function hasUnseenNonDeferredInbox(nodeId) {
-    return readInboxSince(nodeId, readCursor(nodeId)).some((entry) => entry.tier !== 'deferred');
-}
 /** Commit the complete broker-settlement policy while holding one canvas write
  * boundary. This handler intentionally never invokes the broker that called it:
  * the returned directive is the only Pi-side consequence. */
@@ -300,14 +297,14 @@ function settleBroker(nodeId, request) {
     if (decision.action === 'reprompt')
         return { action: 'reprompt', prompt: decision.message };
     if (decision.reason === 'finished') {
-        return hasUnseenNonDeferredInbox(nodeId) ? { action: 'stay_dormant' } : { action: 'shutdown' };
+        return hasUnseenWakeMail(nodeId) ? { action: 'stay_dormant' } : { action: 'shutdown' };
     }
     if (decision.reason !== 'awaiting' && decision.reason !== 'scheduled') {
         return { action: 'stay_dormant' };
     }
     if (focusOf(nodeId) !== null
         || hasAttachedBrokerViewers(nodeId)
-        || hasUnseenNonDeferredInbox(nodeId))
+        || hasUnseenWakeMail(nodeId))
         return { action: 'stay_dormant' };
     transition(nodeId, 'release');
     return { action: 'shutdown' };

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