@north-light/crouter 0.3.311 → 0.3.312

package/dist/daemon/api/__tests__/profile-launch-gates.test.js

@@ -99,11 +99,11 @@ test('revive refuses a paused profile before launching a broker', async () => {
 // (fork, cron spawn, warm-pool mint, `/new` relaunch, recycle) actually hits,
 // because they all reach the canvas through spawnNode and none of them call
 // handleCreate.
-test('the birth gate refuses a paused profile for a daemon-side spawn', () => {
+test('the birth gate refuses a paused profile for a daemon-side spawn', async () => {
     const profile = createProfile('paused spawn', [{ path: cwd, memory: 'content' }]);
     pauseProfile(profile.profileId);
     const beforeRows = listNodes().length;
-    assert.throws(() => spawnNode({ kind: 'general', cwd, parent: null, profile_id: profile.profileId }), (error) => {
+    await assert.rejects(() => spawnNode({ kind: 'general', cwd, parent: null, profile_id: profile.profileId }), (error) => {
         assert.ok(error instanceof CrtrError);
         assert.equal(error.code, 'usage');
         assert.match(error.details?.['next'], new RegExp(`crtr profile resume ${profile.profileId}`));

package/dist/daemon/api/__tests__/seam/profile-delete.test.js

@@ -247,13 +247,13 @@ test('forced profile deletion owns the complete daemon lifecycle', { timeout: 90
     assert.equal(readFileSync(hardReview.sourceFile, 'utf8'), 'source\n', 'the reviewed source document is never removed');
     assert.equal(getDefaultProfileId(hardPin), null);
     await assert.rejects(client.getProfile(hardProfile.id), (error) => error instanceof ApiError && error.status === 404);
-    assert.throws(() => spawnNode({
+    await assert.rejects(() => spawnNode({
         kind: 'developer',
         cwd: process.cwd(),
         parent: null,
         profile_id: hardProfile.id,
         nodeId: 'hard-stale-birth-deadbeef',
-    }), /profile not found/, 'the final synchronous birth gate rejects a profile resolved before a completed hard deletion');
+    }), /profile not found/, 'the final birth gate rejects a profile resolved before a completed hard deletion');
     assert.equal(h.node('hard-stale-birth-deadbeef'), null);
     // Detach preserves nodes, topology, ticket/review state, and conversations;
     // matching brokers restart with no profile identity and matching crons become

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

@@ -10,6 +10,7 @@ import { readTicketResult, validatePageTicketResponses } from '../../../core/hum
 import { getReviewByBridge } from '../../../core/review/store.js';
 import { ReviewOperationError } from '../../../core/review/types.js';
 import { spawnNode } from '../../../core/runtime/nodes.js';
+import { CrtrError } from '../../../core/errors.js';
 import { cancelHumanTicket, resolvePageTicket } from '../../human/finish.js';
 import { cancelReview } from '../../review/finish.js';
 function requireInteractionTicketId(ctx) {
@@ -20,7 +21,7 @@ function requireInteractionTicketId(ctx) {
     return ticketId;
 }
 // POST /v1/human/bridge — create a terminal bridge without a broker
-function handleCreateBridge(ctx) {
+async function handleCreateBridge(ctx) {
     const req = ctx.body;
     if (req === undefined || typeof req !== 'object') {
         throw new ApiError(400, 'invalid_request', 'bridge body is required');
@@ -37,10 +38,12 @@ function handleCreateBridge(ctx) {
         throw new ApiError(400, 'invalid_request', 'bridge `parent` must be a node id or null');
     }
     try {
-        const node = spawnNode({ kind: 'human', parent, creator: parent, cwd, name, lifecycle: 'terminal' });
+        const node = await spawnNode({ kind: 'human', parent, creator: parent, cwd, name, lifecycle: 'terminal' });
         return { status: 200, body: { node_id: node.node_id, name: node.name } };
     }
     catch (error) {
+        if (error instanceof CrtrError && error.code === 'node_create_refused')
+            throw error;
         throw new ApiError(400, 'invalid_request', String(error));
     }
 }

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

@@ -6,6 +6,7 @@ interface NodeHandlerDeps {
 export { resolveCreateKind } from '../../../core/runtime/launch-target.js';
 export declare function handleCreate(ctx: RequestContext, deps?: NodeHandlerDeps): Promise<HandlerResult>;
 export declare function handleList(ctx: RequestContext): HandlerResult;
+export declare function handleFork(ctx: RequestContext): Promise<HandlerResult>;
 export declare function handlePromote(ctx: RequestContext, deps?: NodeHandlerDeps): Promise<HandlerResult>;
 export declare function handleYield(ctx: RequestContext, deps?: NodeHandlerDeps): Promise<HandlerResult>;
 export declare function handleConfig(ctx: RequestContext, deps?: NodeHandlerDeps): Promise<HandlerResult>;

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

@@ -13,7 +13,7 @@ import { appendSituationalContext, formatSituationalProse } from '../../../core/
 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 { assertLaunchModelRegistered, forkNode, spawnChildPrepared } from '../../../core/runtime/spawn.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';
@@ -298,32 +298,39 @@ export async function handleCreate(ctx, deps = {}) {
     const resolvedReq = { ...req, kind };
     const resolvedOutcomeDelivery = outcomeDelivery === undefined ? undefined : resolveOutcomeDelivery(outcomeDelivery, cwd);
     await assertLaunchModelRegistered(requestFromLaunch(launch), { cwd, profileId }, deps.modelRegistry);
-    // --- 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(resolvedReq, cwd, profileId);
-    if (warm !== null) {
-        const claimed = await claimWarmNode(warm, {
-            ...(deadline === undefined ? {} : { deadlineAt: deadline }),
-            ...(resolvedOutcomeDelivery === undefined ? {} : { outcomeDelivery: resolvedOutcomeDelivery }),
-        });
-        refillWarmPool(warm);
-        if (claimed !== null) {
-            if (schema !== null)
-                writeOutputSchema(claimed, 'terminal', schema);
-            return { status: 201, body: detailOf(claimed) };
+    let warmRefill = null;
+    {
+        // --- 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(resolvedReq, cwd, profileId);
+        if (warm !== null) {
+            const claimed = await claimWarmNode(warm, {
+                ...(deadline === undefined ? {} : { deadlineAt: deadline }),
+                ...(resolvedOutcomeDelivery === undefined ? {} : { outcomeDelivery: resolvedOutcomeDelivery }),
+            });
+            if (claimed !== null) {
+                refillWarmPool(warm);
+                if (schema !== null)
+                    writeOutputSchema(claimed, 'terminal', schema);
+                return { status: 201, body: detailOf(claimed) };
+            }
+            warmRefill = warm;
         }
+        const recipe = buildRecipe(resolvedReq, parent, cwd);
+        if (deadline !== undefined)
+            recipe.deadlineAt = deadline;
+        if (resolvedOutcomeDelivery !== undefined)
+            recipe.outcomeDelivery = resolvedOutcomeDelivery;
+        recipe.readiness = req.root === true ? 'await' : 'launch';
+        const result = await spawnChildPrepared(recipe, undefined, () => {
+            if (warmRefill !== null)
+                refillWarmPool(warmRefill);
+        });
+        if (schema !== null)
+            writeOutputSchema(result.node.node_id, 'terminal', schema);
+        return { status: 201, body: detailOf(result.node.node_id) };
     }
-    const recipe = buildRecipe(resolvedReq, parent, cwd);
-    if (deadline !== undefined)
-        recipe.deadlineAt = deadline;
-    if (resolvedOutcomeDelivery !== undefined)
-        recipe.outcomeDelivery = resolvedOutcomeDelivery;
-    recipe.readiness = req.root === true ? 'await' : 'launch';
-    const result = await spawnChild(recipe);
-    if (schema !== null)
-        writeOutputSchema(result.node.node_id, 'terminal', schema);
-    return { status: 201, body: detailOf(result.node.node_id) };
 }
 // GET /v1/nodes — list (filters) ; GET /v1/nodes/{id} — detail
 function singleQueryValue(ctx, name) {
@@ -557,10 +564,8 @@ function handleArtifacts(ctx) {
     return { status: 200, body };
 }
 // Lifecycle verbs
-async function handleFork(ctx) {
-    const id = ctx.params['id'];
-    requireMeta(id);
-    const result = await forkNode(id);
+export async function handleFork(ctx) {
+    const result = await forkNode(ctx.params['id']);
     return { status: 201, body: detailOf(result.node.node_id) };
 }
 async function handleRevive(ctx) {

package/dist/hook-authoring.d.ts

@@ -23,6 +23,32 @@ export interface LifecycleHookRuntime {
     canvasHome: string;
     profile: string | null;
 }
+/** `node:create` runs before every node birth, immediately before a cold row is written or a warm spare is claimed. Return `ok:false` to refuse the birth. There is no node payload because no node exists yet. */
+export interface NodeCreateHookRequest {
+    protocolVersion: 1;
+    op: string;
+    event: 'node:create';
+    phase: 'before';
+    operationId: string;
+    create: {
+        kind: string;
+        mode: string;
+        cwd: string;
+        profile: string | null;
+        root: boolean;
+        parentId: string | null;
+        requestingNodeId: string | null;
+        lifecycle: 'resident' | 'terminal';
+        replaces: string | null;
+    };
+    runtime: {
+        canvasHome: string;
+        profile: string | null;
+    };
+    context: {
+        cwd: string;
+    };
+}
 interface HookRequestBase {
     protocolVersion: 1;
     op: string;
@@ -43,7 +69,7 @@ export interface AfterHookRequest extends HookRequestBase {
 export interface ReplaceHookRequest extends HookRequestBase {
     phase: 'replace';
 }
-/** Lifecycle handlers run on every matching event. `node:start` handlers must be idempotent because they fire for birth and every revive. */
+/** `node:start` handlers run for birth and every revive, so they must be idempotent. `node:close` runs after close. */
 export interface LifecycleHookRequest {
     protocolVersion: 1;
     op: string;
@@ -56,7 +82,7 @@ export interface LifecycleHookRequest {
         cwd: string;
     };
 }
-export type HookRequest = BeforeHookRequest | AfterHookRequest | ReplaceHookRequest | LifecycleHookRequest;
+export type HookRequest = BeforeHookRequest | AfterHookRequest | ReplaceHookRequest | NodeCreateHookRequest | LifecycleHookRequest;
 export interface HookSuccess {
     protocolVersion: 1;
     ok: true;

package/dist/hook-authoring.js

@@ -246,6 +246,28 @@ function validateRequest(value) {
     if (typeof value['operationId'] !== 'string' || !/^[0-9a-f]{32}$/.test(value['operationId'])) {
         return invalid('operationId must be a 32-character lowercase hexadecimal string');
     }
+    if (value['event'] === 'node:create') {
+        if (!hasOnlyKeys(value, ['protocolVersion', 'op', 'event', 'phase', 'operationId', 'create', 'runtime', 'context']))
+            return invalid('node:create request contains unknown fields');
+        if (value['phase'] !== 'before')
+            return invalid('node:create phase must be before');
+        if (!isNodeCreate(value['create']))
+            return invalid('node:create request create contains invalid fields');
+        if (!isCreateRuntime(value['runtime']))
+            return invalid('node:create request runtime contains invalid fields');
+        if (!isLifecycleContext(value['context']))
+            return invalid('node:create request context must contain cwd');
+        return valid({
+            protocolVersion: 1,
+            op: value['op'],
+            event: 'node:create',
+            phase: 'before',
+            operationId: value['operationId'],
+            create: value['create'],
+            runtime: value['runtime'],
+            context: value['context'],
+        });
+    }
     if (value['phase'] === 'on') {
         if (!hasOnlyKeys(value, ['protocolVersion', 'op', 'event', 'phase', 'operationId', 'node', 'runtime', 'context']))
             return invalid('lifecycle request contains unknown fields');
@@ -295,10 +317,21 @@ function validateRequest(value) {
         return invalid('phase must be before, after, or replace');
     if (Object.hasOwn(value, 'result'))
         return invalid('only after requests may contain result');
+    if (value['phase'] === 'before') {
+        return valid({
+            protocolVersion: 1,
+            op: value['op'],
+            phase: 'before',
+            command: value['command'],
+            operationId: value['operationId'],
+            input: value['input'],
+            context: value['context'],
+        });
+    }
     return valid({
         protocolVersion: 1,
         op: value['op'],
-        phase: value['phase'],
+        phase: 'replace',
         command: value['command'],
         operationId: value['operationId'],
         input: value['input'],
@@ -342,6 +375,25 @@ function isContext(value) {
 function isLifecycleContext(value) {
     return isRecord(value) && hasOnlyKeys(value, ['cwd']) && typeof value['cwd'] === 'string';
 }
+function isNodeCreate(value) {
+    return isRecord(value)
+        && hasOnlyKeys(value, ['kind', 'mode', 'cwd', 'profile', 'root', 'parentId', 'requestingNodeId', 'lifecycle', 'replaces'])
+        && typeof value['kind'] === 'string'
+        && typeof value['mode'] === 'string'
+        && typeof value['cwd'] === 'string'
+        && (typeof value['profile'] === 'string' || value['profile'] === null)
+        && typeof value['root'] === 'boolean'
+        && (typeof value['parentId'] === 'string' || value['parentId'] === null)
+        && (typeof value['requestingNodeId'] === 'string' || value['requestingNodeId'] === null)
+        && (value['lifecycle'] === 'resident' || value['lifecycle'] === 'terminal')
+        && (typeof value['replaces'] === 'string' || value['replaces'] === null);
+}
+function isCreateRuntime(value) {
+    return isRecord(value)
+        && hasOnlyKeys(value, ['canvasHome', 'profile'])
+        && typeof value['canvasHome'] === 'string'
+        && (typeof value['profile'] === 'string' || value['profile'] === null);
+}
 function isLifecycleNode(value) {
     return isRecord(value)
         && hasOnlyKeys(value, ['id', 'name', 'kind', 'mode', 'lifecycle', 'cwd', 'nodeDir', 'contextDir', 'jobDir', 'reportsDir'])

package/dist/index.d.ts

@@ -23,7 +23,7 @@ export { nowIso } from './core/fs-utils.js';
 export { validateOperationId, buildEnvelope, operationIdContext, errorClassCodes, serializeEventRecord, errorClassFromError, } from './core/events/index.js';
 export type { BuildEnvelopeInput, ErrorClass, ErrorClassCode, ErrorClassHints, EventComponent, EventEnvelope, EventError, EventField, EventLevel, EventOutcome, OperationId, OperationIdContext, RetryDisposition, } from './core/events/index.js';
 export { forwardHook, hookError, runHookExecutable, runLocalHookProcess } from './hook-authoring.js';
-export type { AfterHookRequest, BeforeHookRequest, ForwardHookOptions, HookContext, HookError, HookFailure, HookHandler, HookHandlers, HookJson, HookPhase, HookRequest, HookResponse, HookSuccess, LocalHookProcessOptions, LocalHookProcessResult, LocalHookProcessSuccess, ReplaceHookRequest, RunHookExecutableOptions, } from './hook-authoring.js';
+export type { AfterHookRequest, BeforeHookRequest, ForwardHookOptions, HookContext, HookError, HookFailure, HookHandler, HookHandlers, HookJson, HookPhase, HookRequest, HookResponse, HookSuccess, LocalHookProcessOptions, LocalHookProcessResult, LocalHookProcessSuccess, LifecycleHookNode, LifecycleHookRequest, LifecycleHookRuntime, NodeCreateHookRequest, ReplaceHookRequest, RunHookExecutableOptions, } from './hook-authoring.js';
 export { validateCommandManifest } from './core/command-manifests/manifest.js';
 export type { CommandManifestValidation, ValidatedCommandManifest } from './core/command-manifests/manifest.js';
 export type { CommandManifestIssue, TransportKind } from './core/command-manifests/schema.js';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@north-light/crouter",
-  "version": "0.3.311",
+  "version": "0.3.312",
   "description": "crtr — agent runtime with memory, plugins, and marketplaces",
   "type": "module",
   "main": "dist/index.js",

package/runtime.lock.json

@@ -1,12 +1,12 @@
 {
   "name": "@north-light/crouter",
-  "version": "0.3.311",
+  "version": "0.3.312",
   "lockfileVersion": 3,
   "requires": true,
   "packages": {
     "": {
       "name": "@north-light/crouter",
-      "version": "0.3.311",
+      "version": "0.3.312",
       "hasInstallScript": true,
       "license": "MIT",
       "workspaces": [
@@ -5206,17 +5206,17 @@
     },
     "packages/crouter-api": {
       "name": "@north-light/crouter-api",
-      "version": "0.3.311",
+      "version": "0.3.312",
       "license": "UNLICENSED"
     },
     "packages/crouter-env-docker": {
       "name": "@north-light/crouter-env-docker",
-      "version": "0.3.311",
+      "version": "0.3.312",
       "license": "UNLICENSED"
     },
     "packages/crouter-sdk": {
       "name": "@north-light/crouter-sdk",
-      "version": "0.3.311",
+      "version": "0.3.312",
       "license": "UNLICENSED",
       "dependencies": {
         "@north-light/crouter-api": "^0.3.295"