@north-light/crouter 0.3.175 → 0.3.176

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

@@ -7,4 +7,5 @@ export { gatePasses } from './gate.js';
 export { INDEX_NAME, isIndexName, indexDirOf, displayName, buildCeilingIndex, effectiveSystemPromptRung, } from './ceiling.js';
 export { renderPreferencesForSubject, renderKnowledgeForSubject } from './render.js';
 export { renderPreferencesSection, renderKnowledgeBlock } from './render-node.js';
-export { renderOnReadDocs, renderWorkspaceOpenDocs } from './on-read.js';
+export { renderOnReadDocsForSubject, renderWorkspaceOpenDocsForSubject } from './on-read.js';
+export { renderOnReadDocs, renderWorkspaceOpenDocs } from './on-read-node.js';

package/dist/core/substrate/index.js

@@ -22,4 +22,5 @@ export { gatePasses } from './gate.js';
 export { INDEX_NAME, isIndexName, indexDirOf, displayName, buildCeilingIndex, effectiveSystemPromptRung, } from './ceiling.js';
 export { renderPreferencesForSubject, renderKnowledgeForSubject } from './render.js';
 export { renderPreferencesSection, renderKnowledgeBlock } from './render-node.js';
-export { renderOnReadDocs, renderWorkspaceOpenDocs } from './on-read.js';
+export { renderOnReadDocsForSubject, renderWorkspaceOpenDocsForSubject } from './on-read.js';
+export { renderOnReadDocs, renderWorkspaceOpenDocs } from './on-read-node.js';

package/dist/core/substrate/on-read-node.d.ts

@@ -0,0 +1,7 @@
+/** Surface docs matched by a successful read tool call. An unknown node id or
+ *  an unreadable canvas renders nothing. */
+export declare function renderOnReadDocs(nodeId: string, readFilePath: string, seen?: Set<string>): string;
+/** Surface workspace-wide docs during first-message assembly, using the node's
+ *  recorded cwd and selected profile. `.` is a reserved applies-to target
+ *  meaning “when this project store is mounted by cwd/profile”. */
+export declare function renderWorkspaceOpenDocs(nodeId: string): string;

package/dist/core/substrate/on-read-node.js

@@ -0,0 +1,37 @@
+// on-read-node.ts — the CANVAS-DB wrappers over the pure on-read functions.
+// Both take a node id, assemble its subject from the canvas-db, then delegate
+// to on-read.ts. Split out for the same reason as render-node.ts: a consumer
+// that already holds a subject imports on-read.js without subject.js's
+// canvas-db reach.
+import { getNode } from '../canvas/index.js';
+import { assembleNodeSubject } from './subject.js';
+import { renderOnReadDocsForSubject, renderWorkspaceOpenDocsForSubject } from './on-read.js';
+/** Surface docs matched by a successful read tool call. An unknown node id or
+ *  an unreadable canvas renders nothing. */
+export function renderOnReadDocs(nodeId, readFilePath, seen = new Set()) {
+    let subject;
+    try {
+        subject = assembleNodeSubject(nodeId);
+    }
+    catch {
+        return '';
+    }
+    if (subject === null)
+        return '';
+    return renderOnReadDocsForSubject(subject, readFilePath, seen);
+}
+/** Surface workspace-wide docs during first-message assembly, using the node's
+ *  recorded cwd and selected profile. `.` is a reserved applies-to target
+ *  meaning “when this project store is mounted by cwd/profile”. */
+export function renderWorkspaceOpenDocs(nodeId) {
+    try {
+        const subject = assembleNodeSubject(nodeId);
+        const node = getNode(nodeId);
+        if (subject === null || node === null)
+            return '';
+        return renderWorkspaceOpenDocsForSubject(subject, node.cwd, node.profile_id ?? null);
+    }
+    catch {
+        return '';
+    }
+}

package/dist/core/substrate/on-read.d.ts

@@ -1,5 +1,7 @@
-/** Surface docs matched by a successful read tool call. */
-export declare function renderOnReadDocs(nodeId: string, readFilePath: string, seen?: Set<string>): string;
-/** Surface workspace-wide docs during first-message assembly. `.` is a reserved
- * applies-to target meaning “when this project store is mounted by cwd/profile”. */
-export declare function renderWorkspaceOpenDocs(nodeId: string): string;
+import type { NodeConfigSubject } from './subject-fields.js';
+/** Surface docs matched by a successful read tool call using the caller-supplied
+ * daemon snapshot subject. */
+export declare function renderOnReadDocsForSubject(subject: NodeConfigSubject, readFilePath: string, seen?: Set<string>): string;
+/** Workspace boot docs using the snapshot's cwd/profile instead of a canvas
+ * lookup. */
+export declare function renderWorkspaceOpenDocsForSubject(subject: NodeConfigSubject, cwd: string, profileId: string | null): string;

package/dist/core/substrate/on-read.js

@@ -1,4 +1,8 @@
-// on-read.ts — file-context delivery for the document substrate.
+// on-read.ts — the pure file-context delivery functions for the document
+// substrate. Both take a caller-supplied subject; the canvas-db wrappers that
+// resolve one from a node id live in on-read-node.ts, so a consumer that
+// already holds a subject imports this module WITHOUT pulling subject.js's
+// canvas-db reach (the same split as render.ts / render-node.ts).
 //
 // A memory with file-read visibility participates only through an explicit
 // `applies-to` path glob (authoring lint requires one). Two events use that one
@@ -28,9 +32,10 @@ import { pathExists, readText, walkFiles } from '../fs-utils.js';
 import { parseFrontmatterGeneric } from '../frontmatter.js';
 import { evalCondition } from '../predicate.js';
 import { listAllMemoryDocs, listProjectMemoryDocs } from '../memory-resolver.js';
-import { getNode } from '../canvas/index.js';
 import { userScopeRoot } from '../scope.js';
-import { assembleNodeSubject, displayName, gatePasses, normalizeDocName, parseSubstrateDoc, parseSubstrateFrontmatter, previewLine, resolveDocName, } from './index.js';
+import { displayName } from './ceiling.js';
+import { gatePasses } from './gate.js';
+import { normalizeDocName, parseSubstrateDoc, parseSubstrateFrontmatter, previewLine, resolveDocName } from './schema.js';
 import { cachedSubstrateDocs } from './session-cache.js';
 const JUNK_DIRS = new Set(['node_modules', '.git', 'dist', 'build', '.next', '.cache', '.yalc']);
 function realpathOrSelf(p) {
@@ -237,17 +242,9 @@ function renderCandidates(subject, docs, seen) {
         ? ''
         : `<auto-loaded-context>\n${rendered.join('\n')}\n</auto-loaded-context>`;
 }
-/** Surface docs matched by a successful read tool call. */
-export function renderOnReadDocs(nodeId, readFilePath, seen = new Set()) {
-    let subject;
-    try {
-        subject = assembleNodeSubject(nodeId);
-    }
-    catch {
-        return '';
-    }
-    if (subject === null)
-        return '';
+/** Surface docs matched by a successful read tool call using the caller-supplied
+ * daemon snapshot subject. */
+export function renderOnReadDocsForSubject(subject, readFilePath, seen = new Set()) {
     const absReadFile = realpathOrSelf(readFilePath);
     const readFrontmatter = readFileFrontmatter(absReadFile);
     const docs = dedupeByPhysicalPath([...enclosingProjectDocs(absReadFile), ...resolvedDocs()])
@@ -255,17 +252,12 @@ export function renderOnReadDocs(nodeId, readFilePath, seen = new Set()) {
         .filter((doc) => matchesReadEvent(doc, absReadFile, readFrontmatter));
     return renderCandidates(subject, docs, seen);
 }
-/** Surface workspace-wide docs during first-message assembly. `.` is a reserved
- * applies-to target meaning “when this project store is mounted by cwd/profile”. */
-export function renderWorkspaceOpenDocs(nodeId) {
-    let subject;
+/** Workspace boot docs using the snapshot's cwd/profile instead of a canvas
+ * lookup. */
+export function renderWorkspaceOpenDocsForSubject(subject, cwd, profileId) {
     let docs;
     try {
-        subject = assembleNodeSubject(nodeId);
-        const node = getNode(nodeId);
-        if (subject === null || node === null)
-            return '';
-        docs = listProjectMemoryDocs(node.cwd, node.profile_id ?? null)
+        docs = listProjectMemoryDocs(cwd, profileId)
             .map(parseSubstrateDoc)
             .filter((doc) => doc !== null);
     }

package/dist/core/termrender/termrender.js

@@ -1,8 +1,9 @@
 import { execFileSync, spawnSync } from 'node:child_process';
-import { existsSync, readFileSync, writeFileSync, statSync, mkdirSync, openSync, closeSync, unlinkSync, renameSync, accessSync, realpathSync, constants, } from 'node:fs';
+import { existsSync, readFileSync, writeFileSync, statSync, mkdirSync, unlinkSync, renameSync, accessSync, realpathSync, constants, } from 'node:fs';
 import { homedir } from 'node:os';
 import { join, resolve } from 'node:path';
 import stringWidth from 'string-width';
+import { withExclusiveDirectoryLock } from '../exclusive-lock.js';
 import { TERMRENDER_VERSION } from './version.js';
 // ── The sole org-wide termrender binding ─────────────────────────────────────
 //
@@ -31,15 +32,11 @@ const VENV_STAMP = join(VENV_DIR, '.crtr-termrender-stamp.json');
 // in a read-only runtime image, and serializes venv mutation + stamp publication
 // across processes: a stamp can never certify a concurrently-changing venv.
 const VENV_LOCK = join(RENDERER_CACHE_DIR, '.crtr-termrender.lock');
-// A lock older than this is from a crashed process and may be stolen. Set
-// comfortably above the worst-case held path (uv probe 5s + venv 60s + install
-// 120s + re-verify ~10s ≈ 195s) so a slow-but-alive holder is never judged
-// stale while it still holds.
-const LOCK_STALE_MS = 300_000;
 // Absolute cap on how long a waiter spins before giving up to plaintext for
 // this session (the next launch retries) — a safety valve so a wedged holder
-// can never hang a process, WITHOUT ever stealing a lock we can't prove stale.
-const LOCK_GIVE_UP_MS = LOCK_STALE_MS + 60_000;
+// can never hang a process. Set comfortably above the worst-case held path
+// (uv probe 5s + venv 60s + install 120s + re-verify ~10s ≈ 195s).
+const LOCK_GIVE_UP_MS = 360_000;
 let rendererState = 'unchecked';
 function isFp(x) {
     const e = x;
@@ -167,46 +164,12 @@ function stampValid() {
     }
     return true;
 }
-function sleepSync(ms) {
-    Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, ms);
-}
-function lockIsStale() {
-    try {
-        const at = JSON.parse(readFileSync(VENV_LOCK, 'utf8')).at;
-        if (typeof at === 'number')
-            return Date.now() - at > LOCK_STALE_MS;
-    }
-    catch {
-        // Unreadable/malformed lock — fall through to mtime.
-    }
-    try {
-        return Date.now() - statSync(VENV_LOCK).mtimeMs > LOCK_STALE_MS;
-    }
-    catch {
-        return true; // vanished — the retry loop re-acquires
-    }
-}
-// Run `provision` while holding the exclusive provisioning lock. If another
-// live process holds it, wait for that process to publish (re-checking the
-// stamp) rather than mutating the venv concurrently. Stale locks are stolen.
-// Steal a lock judged stale by renaming it to a unique name first: rename is
-// atomic, so if two waiters race only the one whose rename succeeds owns (and
-// deletes) it — the loser gets ENOENT and re-loops. This can never delete a
-// lock a peer has freshly re-acquired (that peer holds a DIFFERENT inode at the
-// same path; our rename of the old name either already happened or fails).
-function stealStaleLock() {
-    const tmp = `${VENV_LOCK}.steal.${process.pid}.${Date.now()}`;
-    try {
-        renameSync(VENV_LOCK, tmp);
-    }
-    catch {
-        return; // lost the steal race or already gone — caller re-loops
-    }
-    try {
-        unlinkSync(tmp);
-    }
-    catch { /* best effort */ }
-}
+// Run `provision` holding the exclusive provisioning lock, so no two processes
+// mutate the venv (or certify it) at once. A crashed holder is reclaimed at
+// once; a live one is waited on, and if it outlasts the give-up window this
+// process falls back to plaintext for the session rather than break mutual
+// exclusion. `provision` re-checks the stamp first, so a waiter that finally
+// acquires adopts the peer's published result instead of reinstalling.
 function withProvisionLock(provision) {
     try {
         mkdirSync(RENDERER_CACHE_DIR, { recursive: true });
@@ -216,54 +179,11 @@ function withProvisionLock(provision) {
         process.stderr.write(`[crtr] termrender unavailable — renderer cache cannot be created (${err instanceof Error ? err.message : String(err)}); using plaintext fallback\n`);
         return;
     }
-    const giveUpAt = Date.now() + LOCK_GIVE_UP_MS;
-    for (;;) {
-        let fd;
-        try {
-            fd = openSync(VENV_LOCK, 'wx'); // O_CREAT | O_EXCL — atomic acquire
-        }
-        catch (err) {
-            if (err.code !== 'EEXIST') {
-                rendererState = 'unavailable';
-                process.stderr.write(`[crtr] termrender unavailable — renderer cache cannot be locked (${err instanceof Error ? err.message : String(err)}); using plaintext fallback\n`);
-                return;
-            }
-            if (lockIsStale()) {
-                stealStaleLock();
-                continue;
-            }
-            // A live process is provisioning — give it a chance, then adopt its result.
-            // Never steal a lock we can't prove stale; if we wait too long, give up to
-            // plaintext this session rather than break mutual exclusion.
-            if (Date.now() > giveUpAt) {
-                rendererState = 'unavailable';
-                return;
-            }
-            sleepSync(200);
-            if (stampValid()) {
-                rendererState = 'ready';
-                return;
-            }
-            continue;
-        }
-        try {
-            writeFileSync(fd, JSON.stringify({ pid: process.pid, at: Date.now() }));
-        }
-        catch { /* lock held regardless of whether the marker body wrote */ }
-        try {
-            provision();
-        }
-        finally {
-            try {
-                closeSync(fd);
-            }
-            catch { /* already closed */ }
-            try {
-                unlinkSync(VENV_LOCK);
-            }
-            catch { /* stolen as stale by another process */ }
-        }
-        return;
+    try {
+        withExclusiveDirectoryLock(VENV_LOCK, provision, { timeoutMs: LOCK_GIVE_UP_MS });
+    }
+    catch {
+        rendererState = 'unavailable';
     }
 }
 function binaryOk() {

package/dist/core/worktree.js

@@ -1,10 +1,11 @@
-import { existsSync, linkSync, mkdirSync, readFileSync, realpathSync, rmSync, rmdirSync, statSync, unlinkSync, writeFileSync } from 'node:fs';
-import { createHash, randomUUID } from 'node:crypto';
+import { existsSync, mkdirSync, readFileSync, realpathSync, rmSync, rmdirSync, writeFileSync } from 'node:fs';
+import { createHash } from 'node:crypto';
 import { dirname, join, resolve } from 'node:path';
 import { gitSync } from './git.js';
 import { crtrHome } from './canvas/paths.js';
 import { getNode, updateNode } from './canvas/index.js';
 import { CONFIG_FILE, CRTR_DIR_NAME, STATE_FILE } from '../types.js';
+import { withExclusiveDirectoryLock } from './exclusive-lock.js';
 export class WorktreeError extends Error {
     code;
     next;
@@ -67,113 +68,23 @@ function checkoutPathForBranch(repoRoot, branch) {
     return null;
 }
 const WORKTREE_LOCK_WAIT_MS = 30_000;
-const WORKTREE_LOCK_POLL_MS = 20;
 const WORKTREE_CLEANUP_TIMEOUT_MS = 5_000;
-function sleepSync(ms) {
-    Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, ms);
-}
-/** Serialize worktree mutation for one repository across crtr processes. Git's
- * own worktree metadata lock is intentionally short-lived and rejects a second
- * add instead of waiting, so callers take this transaction lock first. */
 function commonGitDir(repoRoot) {
     const commonDir = runGit(repoRoot, ['rev-parse', '--git-common-dir'], 'git_common_dir_failed', 'Inspect the repository git metadata, then retry.');
     return realpathSync(resolve(repoRoot, commonDir));
 }
-function ownerIsAlive(owner) {
-    const pid = Number(owner.split(':', 1)[0]);
-    if (!Number.isSafeInteger(pid) || pid <= 0)
-        return false;
-    try {
-        process.kill(pid, 0);
-        return true;
-    }
-    catch (err) {
-        return err.code !== 'ESRCH';
-    }
-}
-function reclaimDeadLock(lockPath, incumbent) {
-    // A hard-link claim elects exactly one reclaimer without moving lockPath.
-    // Its inode remains the stale lock even if a new owner appears later.
-    const claimPath = `${lockPath}.reclaim`;
-    try {
-        linkSync(lockPath, claimPath);
-    }
-    catch {
-        // A crashed reclaimer can leave its claim behind. Removing that claim is
-        // safe: it names only the already-dead incumbent, and any live reclaimer
-        // then loses authority because its inode check below fails.
-        try {
-            unlinkSync(claimPath);
-        }
-        catch { /* claimant is still resolving it */ }
-        return;
-    }
-    try {
-        const lock = statSync(lockPath);
-        const claim = statSync(claimPath);
-        if (lock.ino === claim.ino && readFileSync(claimPath, 'utf8') === incumbent && !ownerIsAlive(incumbent)) {
-            unlinkSync(lockPath);
-        }
-    }
-    catch { /* owner or another reclaimer changed state; leave it alone */ }
-    finally {
-        try {
-            unlinkSync(claimPath);
-        }
-        catch { /* a later reclaimer will clear this stale claim */ }
-    }
-}
+/** Serialize worktree mutation for one repository across crtr processes. Git's
+ * own worktree metadata lock is intentionally short-lived and rejects a second
+ * add instead of waiting, so callers take this transaction lock first. */
 function withRepositoryWorktreeLock(repoRoot, action) {
     const commonDir = commonGitDir(repoRoot);
     const lockRoot = `${crtrHome()}/worktree-locks`;
-    const lockName = createHash('sha256').update(commonDir).digest('hex');
-    const lockPath = `${lockRoot}/${lockName}`;
-    const owner = `${process.pid}:${randomUUID()}`;
-    const tempPath = `${lockPath}.${owner}.tmp`;
     mkdirSync(lockRoot, { recursive: true });
-    const deadline = Date.now() + WORKTREE_LOCK_WAIT_MS;
-    for (;;) {
-        // Write the owner before atomically linking it into the contention name;
-        // a killed creator leaves only an ignored temp file, never a partial lock.
-        writeFileSync(tempPath, owner, { flag: 'wx' });
-        try {
-            linkSync(tempPath, lockPath);
-            unlinkSync(tempPath);
-            break;
-        }
-        catch (err) {
-            try {
-                unlinkSync(tempPath);
-            }
-            catch { /* process crash leaves harmless temp */ }
-            if (err.code !== 'EEXIST')
-                throw err;
-            let incumbent;
-            try {
-                incumbent = readFileSync(lockPath, 'utf8');
-            }
-            catch {
-                continue;
-            }
-            if (!ownerIsAlive(incumbent))
-                reclaimDeadLock(lockPath, incumbent);
-            if (Date.now() >= deadline) {
-                throw new WorktreeError('worktree_lock_timeout', `timed out waiting to create a managed worktree in ${commonDir}`, 'Wait for the other managed-worktree operation to finish, then retry.');
-            }
-            sleepSync(WORKTREE_LOCK_POLL_MS);
-        }
-    }
-    try {
-        return action();
-    }
-    finally {
-        // Token-checking release cannot unlock a replacement owner's lock.
-        try {
-            if (readFileSync(lockPath, 'utf8') === owner)
-                unlinkSync(lockPath);
-        }
-        catch { /* already reclaimed after a process-level failure */ }
-    }
+    const lockPath = `${lockRoot}/${createHash('sha256').update(commonDir).digest('hex')}`;
+    return withExclusiveDirectoryLock(lockPath, action, {
+        timeoutMs: WORKTREE_LOCK_WAIT_MS,
+        timeoutError: () => new WorktreeError('worktree_lock_timeout', `timed out waiting to create a managed worktree in ${commonDir}`, 'Wait for the other managed-worktree operation to finish, then retry.'),
+    });
 }
 function registeredWorktree(repoRoot, path, branch) {
     const list = gitSync(['worktree', 'list', '--porcelain'], repoRoot);

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

@@ -7,6 +7,7 @@
 //
 // `{id}` is the target node.
 import { readdirSync } from 'node:fs';
+import { resolve } from 'node:path';
 import { appendSituationalContext, closeNode, getNode, listNodes, nowIso, reviveNode, } from '../../../index.js';
 import { assertLaunchModelRegistered, forkNode, resolveProfileId, spawnChild } from '../../../core/runtime/spawn.js';
 import { childrenOf, subscribersOf, subscriptionsOf, setMessageWait, updateNode } from '../../../core/canvas/canvas.js';
@@ -29,6 +30,7 @@ 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 { profileHome } from '../../../core/profiles/manifest.js';
 import { fullName } from '../../../core/canvas/labels.js';
 import { getCron } from '../../../core/canvas/crons.js';
 import { cronWakeOrigin } from '../../../core/runtime/bearings.js';
@@ -85,11 +87,31 @@ function parseCreateBody(body) {
     }
     return b;
 }
+/** The directory a new node is pinned to. An explicit `pin_cwd` wins; else a
+ *  managed child inherits its spawner's cwd (which is what keeps a worktree
+ *  node's whole subtree inside that worktree); else the node runs in its
+ *  profile's home. The request's own `cwd` — the caller's directory — is only
+ *  the last resort, for a profile that has no home (notably root).
+ *
+ *  This is the profile→cwd direction: `cwd` selected the profile a moment ago,
+ *  and the profile now supplies where the node runs. Collapsing every create
+ *  under a profile onto one directory is also what keeps the warm pool to one
+ *  spare per profile instead of one per directory anyone happened to spawn from. */
+function resolveNodeCwd(req, parent, profileId, contextCwd) {
+    if (req.pin_cwd !== undefined && req.pin_cwd !== '')
+        return resolve(req.pin_cwd);
+    if (parent != null) {
+        const spawner = getNode(parent);
+        if (spawner !== null)
+            return spawner.cwd;
+    }
+    return profileHome(profileId) ?? contextCwd;
+}
 /** Build the immediate spawn recipe. */
-function buildRecipe(req, parent) {
+function buildRecipe(req, parent, cwd) {
     const recipe = {
         kind: req.kind,
-        cwd: req.cwd ?? process.cwd(),
+        cwd,
         prompt: req.prompt ?? '',
     };
     if (req.mode !== undefined)
@@ -122,7 +144,7 @@ function buildRecipe(req, parent) {
  *  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) {
+function warmRequestFor(req, cwd, profileId) {
     if (!warmPoolEnabled())
         return null;
     if (req.prefer_warm !== true)
@@ -136,8 +158,8 @@ function warmRequestFor(req) {
     return {
         kind: req.kind,
         mode: (req.mode ?? 'base'),
-        cwd: req.cwd ?? process.cwd(),
-        profile: req.profile,
+        cwd,
+        profileId,
         model: req.model ?? null,
         situationalContext: req.situational_context ?? null,
         name: req.name ?? null,
@@ -184,8 +206,9 @@ export async function handleCreate(ctx, deps = {}) {
     // Resolve and validate the exact launch recipe before the warm pool can claim
     // a spare (or the cold path can create a worktree/node). The registry belongs
     // to this daemon, never to the possibly-remote CLI caller.
-    const cwd = req.cwd ?? process.cwd();
-    const profileId = await resolveProfileId(req.profile, parent ?? null, cwd);
+    const contextCwd = req.cwd ?? process.cwd();
+    const profileId = await resolveProfileId(req.profile, parent ?? null, contextCwd);
+    const cwd = resolveNodeCwd(req, parent, profileId, contextCwd);
     const launch = buildLaunchSpec(req.kind, (req.mode ?? 'base'), {
         lifecycle: req.root === true ? 'resident' : 'terminal',
         hasManager: req.root !== true,
@@ -197,7 +220,7 @@ export async function handleCreate(ctx, deps = {}) {
     // --- 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);
+    const warm = warmRequestFor(req, cwd, profileId);
     if (warm !== null) {
         const claimed = await claimWarmNode(warm);
         refillWarmPool(warm);
@@ -207,7 +230,7 @@ export async function handleCreate(ctx, deps = {}) {
             return { status: 201, body: detailOf(claimed) };
         }
     }
-    const recipe = buildRecipe(req, parent);
+    const recipe = buildRecipe(req, parent, cwd);
     recipe.readiness = req.root === true ? 'await' : 'launch';
     const result = await spawnChild(recipe);
     if (schema !== null)

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

@@ -2,45 +2,23 @@
 // input and derive authorship; review/comment state remains in the review
 // services and comment delivery remains a post-commit best effort.
 import { randomUUID } from 'node:crypto';
-import { ApiError } from '../../../api/index.js';
 import { getNode } from '../../../core/canvas/canvas.js';
 import { isSafeNodeId } from '../../../core/canvas/paths.js';
 import { createComment, deleteComment, editComment, getComment, listCommentEvents, listComments, listReviewEvents, reopenComment, resolveComment, } from '../../../core/review/comments.js';
 import { withCanvasWrite } from '../../../core/canvas/db.js';
 import { captureAnchorText, requireCurrentDocumentLocked } from '../../../core/review/document.js';
 import { applyRangeBatch } from '../../../core/review/remap.js';
-import { getReview, getReviewByCompanion } from '../../../core/review/store.js';
+import { getReviewByCompanion, requireVisibleReview } from '../../../core/review/store.js';
 import { ReviewOperationError } from '../../../core/review/types.js';
 import { notifyComment } from '../../review/comment-notify.js';
 import { toReviewCommentDTO, toReviewCommentEventDTO } from '../map.js';
+import { invalidRequest as rejectRequest, isRecord, objectBody, requireParam, requiredString, } from './validate.js';
 const COMMENT_ID = /^[a-f0-9]{32}$/;
 const SHA256 = /^[a-f0-9]{64}$/;
 const COMMENT_STATUSES = new Set(['open', 'resolved', 'deleted', 'all']);
 const DELIVER_MODES = new Set(['wake', 'quiet']);
 function invalidRequest(violations) {
-    throw new ApiError(400, 'invalid_request', 'review comment request is invalid', { violations });
-}
-function isRecord(value) {
-    return typeof value === 'object' && value !== null && !Array.isArray(value);
-}
-function objectBody(body, allowed, violations) {
-    if (!isRecord(body)) {
-        violations.push({ field: 'body', problem: 'must be an object', received: body });
-        return {};
-    }
-    for (const key of Object.keys(body)) {
-        if (!allowed.includes(key))
-            violations.push({ field: key, problem: 'is not allowed', received: body[key] });
-    }
-    return body;
-}
-function requiredString(body, field, violations) {
-    const value = body[field];
-    if (typeof value !== 'string' || value.trim() === '') {
-        violations.push({ field, problem: 'must be a non-empty string', ...(value === undefined ? {} : { received: value }) });
-        return undefined;
-    }
-    return value;
+    rejectRequest('review comment request', violations);
 }
 function optionalSha256(body, field, violations) {
     const value = body[field];
@@ -135,27 +113,10 @@ function anchorFrom(value, field, violations) {
     };
 }
 function requireReviewId(ctx, violations) {
-    const reviewId = ctx.params['review_id'];
-    if (reviewId === undefined || !isSafeNodeId(reviewId)) {
-        violations.push({ field: 'review_id', problem: 'must be a safe review id', ...(reviewId === undefined ? {} : { received: reviewId }) });
-        return undefined;
-    }
-    return reviewId;
+    return requireParam(ctx, 'review_id', 'must be a safe review id', isSafeNodeId, violations);
 }
 function requireCommentId(ctx, violations) {
-    const commentId = ctx.params['comment_id'];
-    if (commentId === undefined || !COMMENT_ID.test(commentId)) {
-        violations.push({ field: 'comment_id', problem: 'must be a 32-character lowercase hexadecimal id', ...(commentId === undefined ? {} : { received: commentId }) });
-        return undefined;
-    }
-    return commentId;
-}
-function requireVisibleReview(reviewId) {
-    const review = getReview(reviewId);
-    if (review === null || review.state === 'binding') {
-        throw new ReviewOperationError('unknown_review', 'review was not found', { received: reviewId });
-    }
-    return review;
+    return requireParam(ctx, 'comment_id', 'must be a 32-character lowercase hexadecimal id', (v) => COMMENT_ID.test(v), violations);
 }
 function requireOpenReview(reviewId) {
     const review = requireVisibleReview(reviewId);