@north-light/crouter 0.3.311 → 0.3.313

package/dist/core/runtime/nodes.js

@@ -21,6 +21,7 @@ import { resolveInstallId } from '../canvas/install-id.js';
 import { canvasDbPath } from '../canvas/paths.js';
 import { usage } from '../errors.js';
 import { assertProfileAvailableForBirth } from '../profiles/deletion-reservation.js';
+import { admitNodeCreate } from '../command-hooks/lifecycle-create.js';
 import { fanDoctrineWake } from './close.js';
 import { BIRTH_ANNOUNCEMENT_MARKER, birthAnnouncementBody } from '../../shared/birth-announcement.js';
 // crtrd sets this once at boot (setInstallId) and it wins unconditionally —
@@ -131,14 +132,9 @@ export function preflightNodeId(nodeId) {
  *  satisfy the format unconditionally and are never a duplicate (they embed a
  *  fresh timestamp+random suffix), so this is only ever exercised by an
  *  explicit `opts.nodeId` from a real caller (`--node-id` / API `node_id`).
- *
- *  RACE SAFETY: this function and the `createNode()` call that follows it in
- *  `spawnNode` run with no `await` between them, and `spawnNode` itself is a
- *  synchronous function — so on the single-threaded daemon process, the
- *  existence-check-then-create is atomic relative to any other concurrent
- *  request. Two concurrent creates at the same id resolve to exactly one
- *  winner (whichever's synchronous `spawnNode()` call runs first) and one
- *  `NodeIdConflictError` for the loser. */
+ *  It runs inside the create critical section immediately before `createNode`,
+ *  so concurrent explicit-id births resolve to one winner and one
+ *  `NodeIdConflictError`. */
 function validatedExplicitNodeId(nodeId) {
     validateNodeIdFormat(nodeId);
     if (getNode(nodeId) !== null)
@@ -225,8 +221,8 @@ export function nodeEnv(meta) {
  *  For a child (parent given): the parent auto-subscribes ACTIVE to the child
  *  (so it's woken when the child finishes), and a spawned_by audit edge is
  *  recorded. For a root (no parent): no edges, resident by default. */
-export function spawnNode(opts) {
-    const nodeId = opts.nodeId !== undefined ? validatedExplicitNodeId(opts.nodeId) : newNodeId();
+export async function spawnNode(opts) {
+    const nodeId = opts.nodeId !== undefined ? (validateNodeIdFormat(opts.nodeId), opts.nodeId) : newNodeId();
     const parent = opts.parent ?? null;
     const isRoot = parent === null;
     // Provenance is independent of the spine: a root has no parent but still
@@ -279,7 +275,26 @@ export function spawnNode(opts) {
         throw new Error(`cannot spawn from unknown creator node: ${creator}`);
     }
     assertProfileAvailableForBirth(meta.profile_id ?? null);
-    createNode(meta, opts.outcomeDelivery === undefined ? undefined : { outcomeDelivery: opts.outcomeDelivery });
+    const releaseCreateGate = await admitNodeCreate({
+        kind: meta.kind,
+        mode: meta.mode,
+        cwd: meta.cwd,
+        profile: meta.profile_id ?? null,
+        root: isRoot,
+        parentId: parent,
+        requestingNodeId: creator,
+        lifecycle,
+        replaces: opts.replaces ?? null,
+    });
+    try {
+        if (opts.nodeId !== undefined)
+            validatedExplicitNodeId(opts.nodeId);
+        await opts.beforeCreate?.();
+        createNode(meta, opts.outcomeDelivery === undefined ? undefined : { outcomeDelivery: opts.outcomeDelivery });
+    }
+    finally {
+        releaseCreateGate();
+    }
     // Create the node-local memory directory so substrate docs can be written
     // directly into it without a separate mkdir. Skip for ephemeral human-bridge
     // rows (kind 'human') — they are not agent nodes.

package/dist/core/runtime/placement.js

@@ -24,7 +24,7 @@
 //     tmux half, the bindings owner, and tmux chrome.
 import { envNodeId } from '../../shared/env.js';
 import { getNode, fullName, deleteNode, listNodes, subscribersOf, openFocusRow, closeFocusRow, getFocusByNode, getFocusByPane, getFocusById, listFocuses as listFocusRows, } from '../canvas/index.js';
-import { nodeHasAssistantMessage, isStreaming } from '../canvas/render-source.js';
+import { nodeHasAssistantMessage } from '../canvas/render-source.js';
 import { headlessBrokerHost } from './host.js';
 import { fanDoctrineWake } from './close.js';
 import { paneExists, paneLocation, closePane, currentTmux, switchClient, selectWindow, selectLayout, selectPane, getPaneOption, setPaneOption, respawnPaneSync, windowOfPane, renameWindow, } from './tmux-driver.js';
@@ -331,7 +331,7 @@ function isEmptyNode(nodeId) {
     const m = getNode(nodeId);
     if (m === null)
         return false;
-    if (isStreaming(nodeId, getNode(nodeId)?.pi_pid ?? null))
+    if (m.streaming === true)
         return false;
     return !nodeHasAssistantMessage(m.pi_session_file);
 }

package/dist/core/runtime/recycle.js

@@ -17,7 +17,7 @@
 // message) — falling back to a short note when it never reported.
 import { readdirSync, readFileSync, statSync } from 'node:fs';
 import { join } from 'node:path';
-import { getNode, setPresence, setFocusOccupant, fullName, recordLaunch, recordPid } from '../canvas/index.js';
+import { abortExecution, beginExecution, getNode, setPresence, setFocusOccupant, fullName, recordExecutionPid, recordLaunch } from '../canvas/index.js';
 import { reportsDir } from '../canvas/paths.js';
 import { pushFinal } from '../feed/feed.js';
 import { spawnNode, rootOfSpine } from './nodes.js';
@@ -25,8 +25,10 @@ import { buildLaunchSpecAsync, buildPiArgv } from './launch.js';
 import { focusOf, respawnPaneSync, setPaneOption } from './placement.js';
 import { waitForBrokerViewSocket, viewerSplitEnv } from './placement-tmux.js';
 import { headlessBrokerHost } from './host.js';
+import { boundFleet } from './fleet.js';
 import { transition } from './lifecycle.js';
 import { ensureDaemon } from '../../daemon/manage.js';
+import { invokeBirthLifecycleHooks } from './spawn.js';
 /** The agent's most recent surfaced message: the newest reports/*.md body with
  *  its YAML frontmatter stripped. Empty string when the node never reported. */
 function lastReportBody(nodeId) {
@@ -64,17 +66,6 @@ export async function recycleNode(nodeId, callerPane) {
     if (pane === undefined || pane === '') {
         return { recycled: false, finalized: false, newRoot: null, delivered: [] };
     }
-    // 1. Finalize — fan the agent's last message out as a `final`, mark it done.
-    const body = lastReportBody(nodeId) ||
-        `Closed via recycle — no final summary was authored by ${meta.name}.`;
-    let delivered = [];
-    let finalized = false;
-    try {
-        const res = await pushFinal(nodeId, body);
-        delivered = res.deliveredTo;
-        finalized = true;
-    }
-    catch { /* recycle the pane even if the report failed */ }
     // Capture M's focus viewport (if any) before booting its replacement. The
     // old broker remains live until the new broker proves it can accept a viewer;
     // a failed replacement must not strand this finished conversation without an
@@ -92,17 +83,31 @@ export async function recycleNode(nodeId, callerPane) {
     // person's seat, so profile-scope defaults (e.g. a persisted /model default)
     // must keep applying.
     const { launch } = await buildLaunchSpecAsync('general', 'base', { lifecycle: 'resident', hasManager: false, cwd: meta.cwd, profileId: meta.profile_id });
-    const root = spawnNode({
+    const body = lastReportBody(nodeId) ||
+        `Closed via recycle — no final summary was authored by ${meta.name}.`;
+    let delivered = [];
+    let finalized = false;
+    const root = await spawnNode({
         kind: 'general',
         mode: 'base',
         lifecycle: 'resident',
         cwd: meta.cwd,
         name: 'general',
         parent: null,
+        replaces: nodeId,
         profile_id: meta.profile_id,
         launch,
+        beforeCreate: async () => {
+            try {
+                const res = await pushFinal(nodeId, body);
+                delivered = res.deliveredTo;
+                finalized = true;
+            }
+            catch { /* recycle the pane even if the report failed */ }
+        },
     });
     const fresh = getNode(root.node_id);
+    await invokeBirthLifecycleHooks(fresh);
     const inv = buildPiArgv(fresh);
     // CRTR_SUBTREE groups the fresh root's subtree; FRONT_DOOR is set by the broker
     // host itself, so it is not added here.
@@ -133,17 +138,22 @@ export async function recycleNode(nodeId, callerPane) {
  *  broker. This direct birth path writes the same launch/pid coordinates as
  *  reviveNode, and a failed readiness probe terminalizes and tears it down. */
 async function launchRecycledBroker(fresh, inv) {
+    const executionId = beginExecution(fresh.node_id, { daemonEpoch: boundFleet().epoch() });
+    inv.env = { ...inv.env, CRTR_EXECUTION_ID: executionId };
     let placed;
     try {
         placed = headlessBrokerHost.launch(fresh.node_id, inv, { cwd: fresh.cwd, name: fullName(fresh), resuming: false });
         if (placed.pid === null)
             throw new Error('broker host returned no pid');
         recordLaunch(fresh.node_id, new Date().toISOString());
-        recordPid(fresh.node_id, placed.pid);
+        if (recordExecutionPid(executionId, fresh.node_id, placed.pid) === 'shutdown') {
+            throw new Error('broker execution was superseded');
+        }
         if (await waitForBrokerViewSocket(fresh.node_id, placed.exited))
             return true;
     }
     catch {
+        abortExecution(executionId, { reason: 'launch_failed' });
         // The replacement never became usable; the finished root's broker remains
         // intact and this half-born row cannot remain active without a fleet handle.
     }

package/dist/core/runtime/reset.js

@@ -20,13 +20,15 @@
 // reserved for finish).
 //
 // Best-effort throughout: a tmux/fs failure on one node never aborts the reap.
-import { getNode, updateNode, recordLaunch, recordPid, fullName, closeFocusRow, view, } from '../canvas/index.js';
+import { getNode, beginExecution, recordExecutionPid, abortExecution, bindSession, recordLaunch, fullName, liveExecutionForNode, closeFocusRow, view, } from '../canvas/index.js';
 import { transition } from './lifecycle.js';
 import { headlessBrokerHost, requestBrokerTeardown } from './host.js';
+import { boundFleet } from './fleet.js';
 import { tearDownNode, focusOf, registerViewerFocus, respawnPaneSync, windowOfPane, renameWindow, } from './placement.js';
 import { viewerSplitEnv, waitForBrokerViewSocket } from './placement-tmux.js';
 import { buildLaunchSpecAsync, buildPiArgv } from './launch.js';
 import { spawnNode, rootOfSpine } from './nodes.js';
+import { invokeBirthLifecycleHooks } from './spawn.js';
 // reapDescendants — tear down a root's descendant sub-DAG (shared helper)
 /** Reap the descendant sub-DAG of `rootId`: mark each **canceled** (the user
  *  moved on — a clean teardown, NOT a fault) + clear intent FIRST, then kill its
@@ -95,17 +97,19 @@ export async function relaunchRoot(oldId, deps = {}) {
         cwd: old.cwd,
         profileId: old.profile_id,
     });
-    const newMeta = spawnNode({
+    const newMeta = await spawnNode({
         kind: old.kind,
         mode: 'base',
         lifecycle: 'resident',
         cwd: old.cwd,
         name: old.kind,
         parent: null,
+        replaces: oldId,
         profile_id: old.profile_id,
         launch,
         modelOverride: old.model_override ?? undefined,
     });
+    await invokeBirthLifecycleHooks(newMeta);
     const inv = buildPiArgv(newMeta, {});
     // Mirror bootRoot's subtree routing on inv.env (the broker host merges it; it
     // sets CRTR_FRONT_DOOR itself).
@@ -113,6 +117,8 @@ export async function relaunchRoot(oldId, deps = {}) {
         ...inv.env,
         CRTR_SUBTREE: rootOfSpine(newMeta.node_id),
     };
+    const executionId = beginExecution(newMeta.node_id, { daemonEpoch: boundFleet().epoch() });
+    inv.env = { ...inv.env, CRTR_EXECUTION_ID: executionId };
     let placed;
     try {
         placed = launchBroker(newMeta.node_id, inv, {
@@ -122,10 +128,12 @@ export async function relaunchRoot(oldId, deps = {}) {
         });
     }
     catch (error) {
+        abortExecution(executionId, { reason: 'launch_failed' });
         transition(newMeta.node_id, 'crash');
         throw error;
     }
     if (placed.pid == null) {
+        abortExecution(executionId, { reason: 'launch_failed' });
         // The new broker never started — crash the half-born node and BAIL. The old
         // root is still live and untouched (nothing below this point has run).
         transition(newMeta.node_id, 'crash');
@@ -135,7 +143,15 @@ export async function relaunchRoot(oldId, deps = {}) {
     // real exit, while the row gets the matching launch and pid coordinates before
     // readiness can observe an early exit.
     recordLaunch(newMeta.node_id, new Date().toISOString());
-    recordPid(newMeta.node_id, placed.pid);
+    if (recordExecutionPid(executionId, newMeta.node_id, placed.pid) === 'shutdown') {
+        abortExecution(executionId, { reason: 'superseded' });
+        try {
+            teardownBroker(newMeta.node_id);
+        }
+        catch { /* best-effort */ }
+        transition(newMeta.node_id, 'crash');
+        return null;
+    }
     let ready = false;
     try {
         ready = await waitForViewSocket(newMeta.node_id, placed.exited);
@@ -188,10 +204,13 @@ export function resetRoot(nodeId, newSessionId, newSessionFile) {
     if (meta === null || meta.parent == null)
         return empty; // unknown or a root
     if (newSessionId !== undefined) {
-        updateNode(nodeId, {
-            pi_session_id: newSessionId,
-            ...(newSessionFile !== undefined ? { pi_session_file: newSessionFile } : {}),
-        });
+        const execution = liveExecutionForNode(nodeId);
+        if (execution !== null)
+            bindSession(nodeId, {
+                executionId: execution.executionId,
+                sessionId: newSessionId,
+                transcriptPath: newSessionFile ?? null,
+            });
     }
     return empty;
 }