@north-light/crouter 0.3.218 → 0.3.220

package/dist/core/runtime/warm-pool.js

@@ -62,7 +62,7 @@ import { claimWarmSpare, deleteNode, getNode, listNodes, listWarmSpares, registe
 import { recordedPidLiveness } from '../canvas/pid.js';
 import { nowIso } from '../fs-utils.js';
 import { spawnChildPrepared } from './spawn.js';
-import { buildLaunchSpec } from './launch.js';
+import { buildLaunchSpecAsync } from './launch.js';
 import { setModelLive } from './model-swap.js';
 import { setSituationalContextLive } from './situational-live.js';
 import { deliverBearingsLive } from './deliver-live.js';
@@ -100,8 +100,8 @@ function warmRecipeKey(cwd, profileId, launch) {
 }
 /** Resolve a request's frozen half. Both cwd and profile arrive already
  *  resolved from the create handler, so this is pure launch-spec construction. */
-function resolveRecipe(request) {
-    const { launch } = buildLaunchSpec(request.kind, request.mode, {
+async function resolveRecipe(request) {
+    const { launch } = await buildLaunchSpecAsync(request.kind, request.mode, {
         lifecycle: 'resident',
         hasManager: false,
         ...(request.model !== null ? { model: request.model } : {}),
@@ -114,7 +114,7 @@ function resolveRecipe(request) {
  *  pool cannot serve it. The caller falls back to a cold spawn; a claim never
  *  fails the create. */
 export async function claimWarmNode(request) {
-    const recipe = resolveRecipe(request);
+    const recipe = await resolveRecipe(request);
     const created = nowIso();
     // The row's stamp moves inside the claim transaction; meta.json (the identity
     // source of truth `rebuildIndex` re-derives the row from) follows with the
@@ -261,7 +261,9 @@ export function refillWarmPool(request) {
         // Mint at the kind's DEFAULT model and with NO situational context: both
         // are claim-time properties, so baking either in would only narrow who the
         // spare can serve.
-        mint(resolveRecipe({ ...request, model: null, situationalContext: null }));
+        void resolveRecipe({ ...request, model: null, situationalContext: null })
+            .then(mint)
+            .catch((err) => console.error(`[warm-pool] recipe resolution failed: ${err.message}`));
     }
     catch (err) {
         console.error(`[warm-pool] recipe resolution failed: ${err.message}`);
@@ -349,7 +351,7 @@ export function prewarmRecentRecipes() {
             // `general`/`base` is only the shape the spare BOOTS as — the key it is
             // filed under excludes everything a claim can reshape, so any kind can
             // claim it.
-            mint(resolveRecipe({
+            void resolveRecipe({
                 kind: 'general',
                 mode: 'base',
                 cwd: candidate.cwd,
@@ -357,7 +359,7 @@ export function prewarmRecentRecipes() {
                 model: null,
                 situationalContext: null,
                 name: null,
-            }));
+            }).then(mint).catch((err) => console.error(`[warm-pool] prewarm failed for ${candidate.cwd}: ${err.message}`));
         }
         catch (err) {
             console.error(`[warm-pool] prewarm failed for ${candidate.cwd}: ${err.message}`);

package/dist/daemon/api/__tests__/bridge-heartbeat.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/daemon/api/__tests__/bridge-heartbeat.test.js

@@ -0,0 +1,30 @@
+import assert from 'node:assert/strict';
+import { EventEmitter } from 'node:events';
+import test from 'node:test';
+import { startRemoteAttachHeartbeat } from '../bridge.js';
+class FakeSocket extends EventEmitter {
+    pings = 0;
+    terminated = 0;
+    ping() { this.pings += 1; }
+    terminate() { this.terminated += 1; }
+}
+function sleep(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+}
+test('remote attach heartbeat pings an idle viewer and keeps a ponging observer alive', async () => {
+    const ws = new FakeSocket();
+    const stop = startRemoteAttachHeartbeat(ws, 20);
+    await sleep(25);
+    assert.equal(ws.pings, 1, 'an idle attach receives a WebSocket ping before proxy idle timeout');
+    ws.emit('pong');
+    await sleep(10);
+    assert.equal(ws.terminated, 0, 'a pong renews the heartbeat without terminating the observer');
+    stop();
+});
+test('remote attach heartbeat drops only an unresponsive observer socket', async () => {
+    const ws = new FakeSocket();
+    const stop = startRemoteAttachHeartbeat(ws, 5);
+    await sleep(16);
+    assert.equal(ws.terminated, 1, 'two missed heartbeat intervals terminate the detached viewer');
+    stop();
+});

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

@@ -169,6 +169,36 @@ test('A4a: WS attach welcome.snapshot is byte-identical to a direct ViewSocketCl
     assert.equal(JSON.stringify(wsWelcome.snapshot), JSON.stringify(direct.welcome.snapshot), 'WS welcome.snapshot is byte-identical to the direct ViewSocketClient snapshot');
     direct.close();
 });
+test('A4a regression: reconnecting an observer keeps the live broker instance', async () => {
+    const root = h.spawnRoot('a4 reconnect root');
+    const id = (await client.createNode({ kind: 'developer', parent: root, prompt: 'a4 reconnect worker' })).node_id;
+    await h.awaitBoot(id);
+    const pid = h.node(id)?.pi_pid;
+    const boots = h.bootCount(id);
+    const attachOnce = () => new Promise((resolveAttach, rejectAttach) => {
+        const ws = new WebSocket(`ws+unix://${sockPath}:/v1/nodes/${id}/attach`);
+        const timer = setTimeout(() => {
+            ws.terminate();
+            rejectAttach(new Error('timed out waiting for observer welcome'));
+        }, 15_000);
+        ws.on('open', () => ws.send(JSON.stringify({ type: 'hello', role: 'observer', client_id: `a4-reconnect-${Math.random()}` })));
+        ws.on('message', (data) => {
+            if (JSON.parse(data.toString('utf8'))['type'] !== 'welcome')
+                return;
+            clearTimeout(timer);
+            ws.close();
+            resolveAttach();
+        });
+        ws.on('error', (error) => {
+            clearTimeout(timer);
+            rejectAttach(error);
+        });
+    });
+    await attachOnce();
+    await attachOnce();
+    assert.equal(h.bootCount(id), boots, 'observer reconnect did not relaunch the broker');
+    assert.equal(h.node(id)?.pi_pid, pid, 'the in-flight broker instance was retained');
+});
 test('A4b: ?revive=0 on a dormant node refuses 409 without launching a broker', async () => {
     const root = h.spawnRoot('a4b root');
     // A dormant row: no live broker, no pi_pid, view.sock absent.

package/dist/daemon/api/bridge.d.ts

@@ -1,5 +1,11 @@
 import type { IncomingMessage } from 'node:http';
 import type { Duplex } from 'node:stream';
+import { type WebSocket } from 'ws';
+/** Keep an otherwise quiet observer connection alive through common 60s proxy
+ * idle limits. A viewer only observes a broker, so a missed heartbeat may close
+ * this socket but must never affect the broker or its in-flight work. */
+export declare const REMOTE_ATTACH_HEARTBEAT_MS = 25000;
+export declare function startRemoteAttachHeartbeat(ws: WebSocket, intervalMs?: number): () => void;
 /** Handle the HTTP upgrade for `GET /v1/nodes/{id}/attach`. A-9 matches the
  *  route, extracts `{id}`, and calls this with the raw upgrade triplet; this
  *  owns the WS handshake (its own noServer `wss` above) AND the spec §5.3

package/dist/daemon/api/bridge.js

@@ -33,6 +33,40 @@ import { probeViewSocket, waitForBrokerViewSocket } from '../../core/runtime/vie
  *  client cap) so a remote peer cannot buffer 256MiB before the broker's 24MiB
  *  decoder rejects the message. */
 const wss = new WebSocketServer({ noServer: true, maxPayload: BROKER_READ_CAPS.maxLineBytes });
+/** Keep an otherwise quiet observer connection alive through common 60s proxy
+ * idle limits. A viewer only observes a broker, so a missed heartbeat may close
+ * this socket but must never affect the broker or its in-flight work. */
+export const REMOTE_ATTACH_HEARTBEAT_MS = 25_000;
+export function startRemoteAttachHeartbeat(ws, intervalMs = REMOTE_ATTACH_HEARTBEAT_MS) {
+    let alive = true;
+    let stopped = false;
+    const acknowledge = () => { alive = true; };
+    const stop = () => {
+        if (stopped)
+            return;
+        stopped = true;
+        clearInterval(timer);
+        ws.off('pong', acknowledge);
+    };
+    ws.on('pong', acknowledge);
+    const timer = setInterval(() => {
+        if (!alive) {
+            stop();
+            ws.terminate();
+            return;
+        }
+        alive = false;
+        try {
+            ws.ping();
+        }
+        catch {
+            stop();
+            ws.terminate();
+        }
+    }, intervalMs);
+    timer.unref();
+    return stop;
+}
 /** A WS close reason is capped at 123 UTF-8 bytes by the protocol. */
 function clampReason(reason) {
     const buf = Buffer.from(reason, 'utf8');
@@ -106,6 +140,7 @@ function bridgeConnection(ws, nodeId) {
     const decoder = new FrameDecoder(CLIENT_READ_CAPS);
     let closed = false;
     let viewerFaultRecorded = false;
+    let stopHeartbeat;
     socket.on('connect', () => {
         clearFault(nodeId, { link: 'relay↔broker' });
     });
@@ -113,6 +148,7 @@ function bridgeConnection(ws, nodeId) {
         if (closed)
             return;
         closed = true;
+        stopHeartbeat?.();
         if (!socket.destroyed) {
             try {
                 socket.destroy();
@@ -128,6 +164,7 @@ function bridgeConnection(ws, nodeId) {
             /* ignore */
         }
     };
+    stopHeartbeat = startRemoteAttachHeartbeat(ws);
     // socket → WS: bounded decode, one WS text message per complete frame.
     socket.on('data', (chunk) => {
         let frames;
@@ -183,7 +220,7 @@ function bridgeConnection(ws, nodeId) {
                 link: 'viewer↔crtrd',
                 op: 'remote attach websocket',
                 kind: classification.kind,
-                retry: { disposition: 'manual' },
+                retry: { disposition: 'auto' },
                 message: reasonText || `remote attach closed (${code})`,
             });
         }
@@ -197,7 +234,7 @@ function bridgeConnection(ws, nodeId) {
                 link: 'viewer↔crtrd',
                 op: 'remote attach websocket',
                 kind: classification.kind,
-                retry: { disposition: 'manual' },
+                retry: { disposition: 'auto' },
                 message: 'remote attach websocket error',
             });
         }

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

@@ -19,15 +19,14 @@ import { nodeArtifacts } from '../../../core/canvas/history.js';
 import { readNodeMessagesPage, readNodeSession, readNodeSnapshot, transcriptMarkdown } from '../../../core/runtime/node-read.js';
 import { assembleNodeSubject } from '../../../core/substrate/subject.js';
 import { reviveAll } from '../../../core/runtime/revive-all.js';
-import { promote, requestYield, reshapeNode } from '../../../core/runtime/promote.js';
+import { promoteAsync, requestYieldAsync, reshapeNodeAsync } from '../../../core/runtime/promote.js';
 import { recycleNode } from '../../../core/runtime/recycle.js';
 import { relaunchRoot } from '../../../core/runtime/reset.js';
 import { assertReopenGate } from '../../../core/runtime/reopen.js';
 import { writeYieldMessage, readGoal } from '../../../core/runtime/kickoff.js';
 import { hasRoadmap, seedRoadmap } from '../../../core/runtime/roadmap.js';
 import { renameWindow } from '../../../core/runtime/placement.js';
-import { readMergedLaunchConfig } from '../../../core/config.js';
-import { buildLaunchSpec, isProviderPinnedModelToken, normalizeModel } from '../../../core/runtime/launch.js';
+import { buildLaunchSpecAsync, isProviderPinnedModelToken, normalizeModel, readMergedLaunchConfigAsync } from '../../../core/runtime/launch.js';
 import { modelRequestFromConfig } from '../../../core/model-routes.js';
 import { BrokerUnreachableError } from '../../../core/runtime/broker-request.js';
 import { isBrokerLive, persistDormantModel, setModelLive } from '../../../core/runtime/model-swap.js';
@@ -196,13 +195,13 @@ function requestFromLaunch(launch) {
     return modelRequestFromConfig(launch.model, intent, launch.modelExact === true);
 }
 async function assertNodeModelChangeRegistered(meta, target, registry) {
-    const launch = buildLaunchSpec(target.kind, target.mode, {
+    const launch = (await buildLaunchSpecAsync(target.kind, target.mode, {
         lifecycle: target.lifecycle,
         hasManager: meta.parent !== null,
         model: target.model,
         cwd: meta.cwd,
         profileId: meta.profile_id ?? null,
-    }).launch;
+    })).launch;
     await assertLaunchModelRegistered(requestFromLaunch(launch), { cwd: meta.cwd, profileId: meta.profile_id ?? null }, registry);
 }
 export async function handleCreate(ctx, deps = {}) {
@@ -234,16 +233,16 @@ export async function handleCreate(ctx, deps = {}) {
     const profileId = await resolveProfileId(req.profile, parent ?? null, contextCwd);
     const profile = assertProfileActive(profileId);
     const kind = resolveCreateKind(req.kind, profile);
-    assertKindServer(kind);
     const resolvedReq = { ...req, kind };
     const cwd = resolveNodeCwd(resolvedReq, parent, profileId, contextCwd);
-    const launch = buildLaunchSpec(kind, (resolvedReq.mode ?? 'base'), {
+    await assertKindServer(kind, cwd, profileId);
+    const launch = (await buildLaunchSpecAsync(kind, (resolvedReq.mode ?? 'base'), {
         lifecycle: req.root === true ? (req.root_lifecycle ?? 'resident') : 'terminal',
         hasManager: req.root !== true,
         ...(req.model !== undefined ? { model: req.model } : {}),
         cwd,
         profileId,
-    }).launch;
+    })).launch;
     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
@@ -555,12 +554,12 @@ async function handleRecycle(ctx) {
         },
     };
 }
-function handleDemote(ctx) {
+async function handleDemote(ctx) {
     const id = ctx.params['id'];
     requireMeta(id);
     // Use the canonical reshape primitive to ensure modelExact, provider
     // pin/intent, and default-name migration are all preserved.
-    reshapeNode(id, { lifecycle: 'terminal' });
+    await reshapeNodeAsync(id, { lifecycle: 'terminal' });
     return { status: 200, body: detailOf(id) };
 }
 export async function handlePromote(ctx, deps = {}) {
@@ -575,7 +574,7 @@ export async function handlePromote(ctx, deps = {}) {
             model: req.model,
         }, deps.modelRegistry);
     }
-    const result = promote(id, {
+    const result = await promoteAsync(id, {
         ...(req.kind !== undefined ? { kind: req.kind } : {}),
         ...(req.resident === true ? { resident: true } : {}),
         ...(req.model !== undefined ? { model: req.model } : {}),
@@ -602,7 +601,7 @@ export async function handleYield(ctx, deps = {}) {
     }
     const note = req.note ?? 'Refresh: continue against your roadmap or goal.';
     writeYieldMessage(id, note);
-    const result = requestYield(id, {
+    const result = await requestYieldAsync(id, {
         ...(req.promote === true ? { promote: true } : {}),
         ...(req.kind !== undefined ? { kind: req.kind } : {}),
         ...(req.model !== undefined ? { model: req.model } : {}),
@@ -645,7 +644,7 @@ export async function handleConfig(ctx, deps = {}) {
     }
     if (patch.model !== undefined) {
         const pinned = isProviderPinnedModelToken(patch.model);
-        const ladders = readMergedLaunchConfig(meta.cwd, meta.profile_id ?? null).modelLadders;
+        const ladders = (await readMergedLaunchConfigAsync(meta.cwd, meta.profile_id ?? null)).modelLadders;
         const spec = normalizeModel(patch.model, ladders);
         await assertLaunchModelRegistered({ kind: 'concrete', spec }, { cwd: meta.cwd, profileId: meta.profile_id ?? null }, deps.modelRegistry);
         const persistDormant = () => {
@@ -681,7 +680,7 @@ export async function handleConfig(ctx, deps = {}) {
     // --- kind / mode / lifecycle: reshape via canonical primitive (CLI parity). ---
     if (patch.kind !== undefined || patch.mode !== undefined || patch.lifecycle !== undefined) {
         if (patch.kind !== undefined)
-            assertKindServer(patch.kind);
+            await assertKindServer(patch.kind, meta.cwd, meta.profile_id ?? null);
         const newKind = patch.kind ?? meta.kind;
         const newMode = (patch.mode ?? meta.mode);
         const newLifecycle = patch.lifecycle ?? meta.lifecycle;
@@ -697,7 +696,7 @@ export async function handleConfig(ctx, deps = {}) {
         }
         // Use canonical reshape primitive to preserve modelExact, provider pin/intent,
         // and default-name migration.
-        meta = reshapeNode(id, {
+        meta = await reshapeNodeAsync(id, {
             ...(patch.kind !== undefined ? { kind: newKind } : {}),
             ...(patch.mode !== undefined ? { mode: newMode } : {}),
             ...(patch.lifecycle !== undefined ? { lifecycle: newLifecycle } : {}),
@@ -715,8 +714,8 @@ export async function handleConfig(ctx, deps = {}) {
 }
 /** Validate a `--kind` against the installed personas server-side (crtrd reads
  *  the merged launch config). Mirrors the CLI's assertKind. */
-function assertKindServer(kind) {
-    const kinds = Object.keys(readMergedLaunchConfig().kinds);
+async function assertKindServer(kind, cwd, profileId) {
+    const kinds = Object.keys((await readMergedLaunchConfigAsync(cwd, profileId)).kinds);
     if (!kinds.includes(kind)) {
         throw usage(`unknown kind: ${kind}`, { received: kind, next: `Valid kinds: ${kinds.sort().join(', ')}.` });
     }

package/dist/types.js

@@ -77,7 +77,11 @@ export function defaultScopeConfig() {
         auto_update: { crtr: 'notify', content: 'notify', interval_hours: 24 },
         max_panes_per_window: DEFAULT_MAX_PANES_PER_WINDOW,
         auto_open_child_viewers: true,
-        brokerThresholds: { warning: 128, automaticReviveCap: 256 },
+        // Every live broker is a whole pi engine. 256 of them is not a bound any
+        // real host survives — an 8 GB guest dies around a few dozen — so these are
+        // sized as a backstop that actually engages before the machine does.
+        // Override per host with CRTR_MAX_LIVE_BROKERS / CRTR_WARN_LIVE_BROKERS.
+        brokerThresholds: { warning: 16, automaticReviveCap: 32 },
         completion_bell: true,
         working_gerunds: [...DEFAULT_WORKING_GERUNDS],
         whip_mode: false,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@north-light/crouter",
-  "version": "0.3.218",
+  "version": "0.3.220",
   "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.218",
+  "version": "0.3.220",
   "lockfileVersion": 3,
   "requires": true,
   "packages": {
     "": {
       "name": "@north-light/crouter",
-      "version": "0.3.218",
+      "version": "0.3.220",
       "hasInstallScript": true,
       "license": "MIT",
       "dependencies": {