@crouton-kit/crouter 0.3.32 → 0.3.34

package/dist/core/runtime/connectivity.js

@@ -0,0 +1,73 @@
+// connectivity.ts — "is the network reachable right now" for the daemon.
+//
+// Used by the daemon's connectivity-recovery pass to decide whether a node
+// parked on a CONNECTION error should be nudged to continue. The signal the
+// user thinks in terms of is "my wifi is back" — so this is a coarse internet-
+// reachability probe, NOT a per-provider health check.
+//
+// Implementation: a fast TCP connect to a couple of well-known anycast resolvers
+// on 443. RAW IPs (no DNS lookup) on purpose — DNS itself fails when the network
+// is down, so resolving a hostname would conflate "wifi down" with "DNS down" and
+// add latency; the IPs below are stable anycast addresses. Online = ANY target
+// accepts a TCP connection within the timeout. Never throws.
+//
+// The broker calls this probe for connection-fault retries; tests can stub it
+// directly where the retry loop is exercised, so the network state stays deterministic.
+import { Socket } from 'node:net';
+/** Anycast resolvers reachable from essentially any connected network. A single
+ *  success means the box has working internet; we don't care WHICH target. */
+const PROBE_TARGETS = [
+    { host: '1.1.1.1', port: 443 }, // Cloudflare
+    { host: '8.8.8.8', port: 443 }, // Google
+];
+/** Default per-target connect timeout. Short — a healthy network connects in
+ *  tens of ms; a down network should be declared down quickly so the daemon tick
+ *  isn't held up. */
+export const PROBE_TIMEOUT_MS = 3000;
+/** Resolve true iff a TCP connection to host:port completes within timeoutMs.
+ *  Any error/timeout resolves false (never rejects). The socket is always torn
+ *  down. Exported for unit testing against a local listener. */
+export function tcpReachable(host, port, timeoutMs) {
+    return new Promise((resolve) => {
+        const sock = new Socket();
+        let settled = false;
+        const done = (ok) => {
+            if (settled)
+                return;
+            settled = true;
+            try {
+                sock.destroy();
+            }
+            catch {
+                /* already torn down */
+            }
+            resolve(ok);
+        };
+        sock.setTimeout(timeoutMs);
+        sock.once('connect', () => done(true));
+        sock.once('timeout', () => done(false));
+        sock.once('error', () => done(false));
+        try {
+            sock.connect(port, host);
+        }
+        catch {
+            done(false);
+        }
+    });
+}
+/** True when the box can reach the internet (any PROBE_TARGET accepts a TCP
+ *  connection within the timeout). The broker uses this for connection-fault
+ *  retries. Never throws. */
+export async function probeOnline(timeoutMs = PROBE_TIMEOUT_MS) {
+    try {
+        const results = await Promise.all(PROBE_TARGETS.map((t) => tcpReachable(t.host, t.port, timeoutMs)));
+        return results.some((ok) => ok);
+    }
+    catch {
+        // Promise.all only rejects if a target promise rejects — they never do, but
+        // be defensive: an unexpected throw reads as "can't tell", and "can't tell"
+        // must never claim the network is UP (which would nudge nodes into a retry
+        // that fails again). Treat as offline.
+        return false;
+    }
+}

package/dist/core/runtime/fault-recovery-nudge.d.ts

@@ -0,0 +1,2 @@
+export declare const CONNECTION_FAULT_RECOVERY_BODY = "The network connection is back online. Your previous turn stopped on a connection error (the network was down). Continue from where you left off and retry the work that failed.";
+export declare const PROVIDER_FAULT_RECOVERY_BODY = "Your previous turn stopped on a provider fault. Continue from where you left off and retry the work that failed.";

package/dist/core/runtime/fault-recovery-nudge.js

@@ -0,0 +1,2 @@
+export const CONNECTION_FAULT_RECOVERY_BODY = 'The network connection is back online. Your previous turn stopped on a connection error (the network was down). Continue from where you left off and retry the work that failed.';
+export const PROVIDER_FAULT_RECOVERY_BODY = 'Your previous turn stopped on a provider fault. Continue from where you left off and retry the work that failed.';

package/dist/core/runtime/fault-recovery.d.ts

@@ -0,0 +1,23 @@
+import type { Fault, FaultKind } from '../fault-classifier.js';
+export type FaultRecoveryGate = 'online' | 'time' | 'none';
+export interface FaultRecoveryPolicy {
+    kind: FaultKind;
+    gate: FaultRecoveryGate;
+    max: number;
+    baseDelayMs: number;
+    capDelayMs: number;
+    fatal: boolean;
+}
+export interface FaultRetryPlan {
+    fault: Fault;
+    attempt: number;
+    max: number;
+    nextAt: string;
+    delayMs: number;
+}
+export declare function policyFor(kind: FaultKind): FaultRecoveryPolicy;
+export declare function nextFaultRetry(fault: Fault, now: number, opts?: {
+    retryAfterMs?: number | null;
+    jitterMs?: (fault: Fault, attempt: number) => number;
+}): FaultRetryPlan | null;
+export declare function markFatalOnExhaust(fault: Fault): Fault;

package/dist/core/runtime/fault-recovery.js

@@ -0,0 +1,74 @@
+const POLICIES = {
+    connection: { kind: 'connection', gate: 'online', max: 8, baseDelayMs: 5_000, capDelayMs: 60_000, fatal: false },
+    'rate-limit': { kind: 'rate-limit', gate: 'time', max: 6, baseDelayMs: 30_000, capDelayMs: 5 * 60_000, fatal: false },
+    overloaded: { kind: 'overloaded', gate: 'time', max: 6, baseDelayMs: 10_000, capDelayMs: 2 * 60_000, fatal: false },
+    auth: { kind: 'auth', gate: 'none', max: 0, baseDelayMs: 0, capDelayMs: 0, fatal: true },
+    protocol: { kind: 'protocol', gate: 'none', max: 0, baseDelayMs: 0, capDelayMs: 0, fatal: true },
+    other: { kind: 'other', gate: 'none', max: 0, baseDelayMs: 0, capDelayMs: 0, fatal: true },
+};
+export function policyFor(kind) {
+    return POLICIES[kind];
+}
+function clampDelay(delayMs, capMs) {
+    if (!Number.isFinite(delayMs) || delayMs <= 0)
+        return 0;
+    return Math.min(Math.max(1, Math.round(delayMs)), capMs);
+}
+function defaultOverloadedJitterMs(fault, attempt) {
+    const seed = `${fault.link}|${fault.kind}|${fault.message}|${fault.since}|${attempt}`;
+    let hash = 0;
+    for (let i = 0; i < seed.length; i++) {
+        hash = (hash * 33 + seed.charCodeAt(i)) >>> 0;
+    }
+    return hash % 1_000;
+}
+function retryDelayMs(fault, attempt, opts) {
+    const policy = policyFor(fault.kind);
+    if (policy.fatal)
+        return 0;
+    if (fault.kind === 'rate-limit' && typeof opts?.retryAfterMs === 'number' && Number.isFinite(opts.retryAfterMs)) {
+        return clampDelay(opts.retryAfterMs, policy.capDelayMs);
+    }
+    const delay = policy.baseDelayMs * 2 ** Math.max(0, attempt - 1);
+    const jitter = fault.kind === 'overloaded'
+        ? Math.max(0, Math.round(opts?.jitterMs?.(fault, attempt) ?? defaultOverloadedJitterMs(fault, attempt)))
+        : 0;
+    return clampDelay(delay + jitter, policy.capDelayMs);
+}
+export function nextFaultRetry(fault, now, opts) {
+    const policy = policyFor(fault.kind);
+    if (policy.fatal)
+        return null;
+    const attempt = (fault.retry.attempt ?? 0) + 1;
+    if (attempt > policy.max)
+        return null;
+    const delayMs = retryDelayMs(fault, attempt, opts);
+    return {
+        fault: {
+            ...fault,
+            retry: {
+                ...fault.retry,
+                disposition: 'auto',
+                by: fault.retry.by ?? 'daemon',
+                attempt,
+                max: policy.max,
+                nextAt: new Date(now + delayMs).toISOString(),
+            },
+        },
+        attempt,
+        max: policy.max,
+        nextAt: new Date(now + delayMs).toISOString(),
+        delayMs,
+    };
+}
+export function markFatalOnExhaust(fault) {
+    const retry = {
+        ...fault.retry,
+        disposition: 'fatal',
+        by: fault.retry.by ?? 'daemon',
+        max: policyFor(fault.kind).max,
+        attempt: fault.retry.attempt ?? 0,
+    };
+    delete retry.nextAt;
+    return { ...fault, retry };
+}

package/dist/core/runtime/fault.d.ts

@@ -0,0 +1,25 @@
+import { type Fault, type FaultKind, type FaultLink, type FaultRetry } from '../fault-classifier.js';
+export type { Fault, FaultKind, FaultLink, FaultRetry, FaultRetryDisposition, FaultRetryOwner } from '../fault-classifier.js';
+export declare const FAULT_QUIET_MS: number;
+export interface FaultRecordInput {
+    link: FaultLink;
+    op: string;
+    kind: FaultKind;
+    retry: FaultRetry;
+    message: string;
+    logPath?: string;
+    since?: string;
+    anchorEntryId?: string;
+}
+export declare function recordFault(nodeId: string, input: FaultRecordInput): void;
+export declare function recordFaultForCurrentNode(input: FaultRecordInput): boolean;
+export declare function clearFault(nodeId: string, opts?: {
+    link?: FaultLink;
+}): boolean;
+export declare function clearFaultForCurrentNode(opts?: {
+    link?: FaultLink;
+}): boolean;
+export declare function readFault(nodeId: string): Fault | null;
+export declare function readFaultAsync(nodeId: string): Promise<Fault | null>;
+/** True when a raw engine error is the provider 404 "model missing" signal. */
+export declare function isModelNotFoundError(message: string): boolean;

package/dist/core/runtime/fault.js

@@ -0,0 +1,176 @@
+import { existsSync, mkdirSync, readFileSync, rmSync, writeFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { jobDir } from '../canvas/paths.js';
+import { appendLogLine, formatLogLine } from '../log.js';
+export const FAULT_QUIET_MS = 5 * 60_000;
+const MESSAGE_CAP = 500;
+const DEFAULT_OP = 'generation turn';
+const DEFAULT_LOG_BASENAME = 'fault.log';
+function faultPath(nodeId) {
+    return join(jobDir(nodeId), 'fault');
+}
+function legacyFaultPath(nodeId) {
+    return join(jobDir(nodeId), 'error-stall');
+}
+function defaultLogPath(nodeId) {
+    return join(jobDir(nodeId), DEFAULT_LOG_BASENAME);
+}
+function clampMessage(message) {
+    return message.slice(0, MESSAGE_CAP);
+}
+function faultPriority(fault) {
+    if (fault.link === 'pi→provider' && fault.retry.disposition === 'auto' && fault.retry.by === 'daemon')
+        return 3;
+    if (fault.retry.disposition === 'fatal')
+        return 2;
+    return 1;
+}
+function parseFault(raw, nodeId, legacy = false) {
+    try {
+        const parsed = JSON.parse(raw);
+        const kind = parsed.kind;
+        const message = typeof parsed.message === 'string' ? parsed.message : undefined;
+        const since = typeof parsed.since === 'string' ? parsed.since : undefined;
+        if (kind === undefined || message === undefined || since === undefined)
+            return null;
+        const link = parsed.link ?? (legacy ? 'pi→provider' : undefined);
+        const retryRaw = (parsed.retry ?? {});
+        const retry = {
+            disposition: retryRaw.disposition === 'auto' || retryRaw.disposition === 'manual' || retryRaw.disposition === 'fatal'
+                ? retryRaw.disposition
+                : legacy
+                    ? 'auto'
+                    : 'manual',
+            ...(retryRaw.by === 'sdk' || retryRaw.by === 'daemon' || retryRaw.by === 'client' ? { by: retryRaw.by } : legacy ? { by: 'daemon' } : {}),
+            ...(typeof retryRaw.attempt === 'number' ? { attempt: retryRaw.attempt } : {}),
+            ...(typeof retryRaw.max === 'number' ? { max: retryRaw.max } : {}),
+            ...(typeof retryRaw.nextAt === 'string' ? { nextAt: retryRaw.nextAt } : {}),
+        };
+        return {
+            link: link ?? 'pi→provider',
+            op: typeof parsed.op === 'string' && parsed.op !== '' ? parsed.op : DEFAULT_OP,
+            kind,
+            retry,
+            message,
+            since,
+            logPath: typeof parsed.logPath === 'string' && parsed.logPath !== '' ? parsed.logPath : defaultLogPath(nodeId),
+            ...(typeof parsed.anchorEntryId === 'string' && parsed.anchorEntryId !== '' ? { anchorEntryId: parsed.anchorEntryId } : {}),
+        };
+    }
+    catch {
+        return null;
+    }
+}
+function readFaultFromPath(path, nodeId, legacy = false) {
+    try {
+        return parseFault(readFileSync(path, 'utf8'), nodeId, legacy);
+    }
+    catch {
+        return null;
+    }
+}
+function currentFault(nodeId) {
+    return readFaultFromPath(faultPath(nodeId), nodeId) ?? readFaultFromPath(legacyFaultPath(nodeId), nodeId, true);
+}
+function writeFault(nodeId, fault) {
+    try {
+        mkdirSync(jobDir(nodeId), { recursive: true });
+        writeFileSync(faultPath(nodeId), JSON.stringify(fault));
+        rmSync(legacyFaultPath(nodeId), { force: true });
+    }
+    catch {
+        /* best-effort */
+    }
+}
+function updateMarker(nodeId, fault) {
+    const current = currentFault(nodeId);
+    if (current !== null) {
+        if (current.link === fault.link && current.kind === fault.kind) {
+            const retry = { ...current.retry, ...fault.retry };
+            if (fault.retry.disposition === 'fatal' && !('nextAt' in fault.retry)) {
+                delete retry.nextAt;
+            }
+            fault = { ...fault, since: current.since, anchorEntryId: current.anchorEntryId ?? fault.anchorEntryId, retry };
+        }
+        else if (faultPriority(current) > faultPriority(fault)) {
+            return;
+        }
+    }
+    writeFault(nodeId, fault);
+}
+function appendDurableLog(fault) {
+    const line = formatLogLine(fault.retry.disposition === 'fatal' ? 'warn' : 'info', 'fault', fault.message, {
+        link: fault.link,
+        op: fault.op,
+        kind: fault.kind,
+        retry: fault.retry,
+        since: fault.since,
+        logPath: fault.logPath,
+        anchorEntryId: fault.anchorEntryId,
+    });
+    appendLogLine(fault.logPath, line);
+}
+export function recordFault(nodeId, input) {
+    const fault = {
+        link: input.link,
+        op: input.op,
+        kind: input.kind,
+        retry: input.retry,
+        message: clampMessage(input.message),
+        since: input.since ?? new Date().toISOString(),
+        logPath: input.logPath ?? defaultLogPath(nodeId),
+        ...(typeof input.anchorEntryId === 'string' && input.anchorEntryId !== '' ? { anchorEntryId: input.anchorEntryId } : {}),
+    };
+    appendDurableLog(fault);
+    updateMarker(nodeId, fault);
+}
+export function recordFaultForCurrentNode(input) {
+    const nodeId = process.env['CRTR_NODE_ID'];
+    if (nodeId === undefined || nodeId.trim() === '')
+        return false;
+    if (!existsSync(jobDir(nodeId)))
+        return false;
+    try {
+        recordFault(nodeId, input);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+export function clearFault(nodeId, opts) {
+    try {
+        const current = currentFault(nodeId);
+        if (current !== null && opts?.link !== undefined && current.link !== opts.link)
+            return false;
+        rmSync(faultPath(nodeId), { force: true });
+        rmSync(legacyFaultPath(nodeId), { force: true });
+        return current !== null;
+    }
+    catch {
+        return false;
+    }
+}
+export function clearFaultForCurrentNode(opts) {
+    const nodeId = process.env['CRTR_NODE_ID'];
+    if (nodeId === undefined || nodeId.trim() === '')
+        return false;
+    if (!existsSync(jobDir(nodeId)))
+        return false;
+    return clearFault(nodeId, opts);
+}
+export function readFault(nodeId) {
+    return currentFault(nodeId);
+}
+export async function readFaultAsync(nodeId) {
+    return readFault(nodeId);
+}
+/** True when a raw engine error is the provider 404 "model missing" signal. */
+export function isModelNotFoundError(message) {
+    const m = message ?? '';
+    if (/not_found_error/i.test(m))
+        return true;
+    if (/model[^.]{0,40}(not\s*found|does not exist|is not available|unavailable)|(no such|unknown) model/i.test(m))
+        return true;
+    return /\b404\b/.test(m) && /not\s*found|not available|does not exist/i.test(m);
+}

package/dist/core/runtime/front-door.d.ts

@@ -7,4 +7,4 @@ export declare const FRONT_DOOR_ENV = "CRTR_FRONT_DOOR";
 /** If this invocation is a front-door (root) launch, boot it and never return.
  *  Returns false when it's a recognized subcommand / help / unknown token (let
  *  the dispatcher handle it — for unknown tokens it errors cleanly). */
-export declare function maybeBootRoot(root: RootDef, argv: string[]): boolean;
+export declare function maybeBootRoot(root: RootDef, argv: string[]): Promise<boolean>;

package/dist/core/runtime/front-door.js

@@ -63,7 +63,7 @@ export const FRONT_DOOR_ENV = 'CRTR_FRONT_DOOR';
 /** If this invocation is a front-door (root) launch, boot it and never return.
  *  Returns false when it's a recognized subcommand / help / unknown token (let
  *  the dispatcher handle it — for unknown tokens it errors cleanly). */
-export function maybeBootRoot(root, argv) {
+export async function maybeBootRoot(root, argv) {
     const tokens = argv.slice(2);
     const first = tokens[0];
     // Recursion guard: never boot a root from inside a front-door-booted pi.
@@ -99,6 +99,6 @@ export function maybeBootRoot(root, argv) {
     // Unambiguous front-door launch → boot a resident root inline (exec pi in
     // this terminal). Does not return.
     const args = parseRootArgs(tokens);
-    bootRoot({ ...args });
+    await bootRoot({ ...args });
     return true;
 }

package/dist/core/runtime/host.d.ts

@@ -15,6 +15,12 @@ export interface HostHandle {
      *  detached child reports its pid; the broker re-records pi_pid during its
      *  extension bind, and reviveNode clearPid()s right after launch. */
     pid: number | null;
+    /** Real child-exit signal from the launch handle. Resolves when the detached
+     *  broker exits, so readiness waits can fail fast without pid probes. */
+    exited: Promise<{
+        code: number | null;
+        signal: NodeJS.Signals | null;
+    }>;
 }
 export interface Host {
     /** Bring a node's ENGINE into existence from its launch recipe; return a
@@ -30,4 +36,8 @@ export interface Host {
      *  reaches around the abstraction. */
     signal(nodeId: string, sig: NodeJS.Signals): void;
 }
+/** Validate the broker launch recipe before we detach a child process. This is
+ *  the fast-fail seam for known module/path errors: a bad engine resolve or a
+ *  missing plain session path throws here, before spawn(). */
+export declare function preflightBrokerLaunch(nodeId: string, inv: PiInvocation, cwd: string): void;
 export declare const headlessBrokerHost: Host;

package/dist/core/runtime/host.js

@@ -11,12 +11,12 @@
 // needs no tmux verb at all (it supervises via the broker pid, tears down over
 // the node's unix socket).
 import { spawn } from 'node:child_process';
-import { mkdirSync, writeFileSync, existsSync, unlinkSync, openSync, closeSync } from 'node:fs';
-import { dirname, join } from 'node:path';
+import { mkdirSync, writeFileSync, readFileSync, existsSync, unlinkSync, openSync, closeSync } from 'node:fs';
+import { dirname, join, resolve, isAbsolute } from 'node:path';
 import { fileURLToPath } from 'node:url';
 import { connect } from 'node:net';
 import { getNode } from '../canvas/index.js';
-import { nodeDir, jobDir } from '../canvas/paths.js';
+import { nodeDir, jobDir, viewSocketPath } from '../canvas/paths.js';
 import { encodeFrame } from './broker-protocol.js';
 import { FRONT_DOOR_ENV } from './front-door.js';
 import { hostExecPath } from './branded-host.js';
@@ -34,15 +34,66 @@ function resolveBrokerEntry() {
     const here = dirname(fileURLToPath(import.meta.url));
     return join(here, 'broker-cli.js');
 }
+const DEFAULT_BROKER_ENGINE = '@earendil-works/pi-coding-agent';
+function isPlainLaunchSessionPath(token) {
+    return token.includes('/') || token.endsWith('.jsonl');
+}
+function resolvePlainLaunchPath(token, cwd) {
+    return isAbsolute(token) ? token : resolve(cwd, token);
+}
+function preflightLaunchSessionArg(nodeId, cwd, flag, value) {
+    if (flag === '--session' && !isPlainLaunchSessionPath(value)) {
+        throw new Error(`[broker] refusing to launch ${nodeId}: launch recipe passes bare --session id '${value}' — the broker fatally rejects bare ids; pass the .jsonl path instead.`);
+    }
+    if (!isPlainLaunchSessionPath(value))
+        return;
+    const sessionPath = resolvePlainLaunchPath(value, cwd);
+    if (!existsSync(sessionPath)) {
+        const label = flag === '--session' ? 'session file' : 'fork source';
+        throw new Error(`[broker] refusing to launch ${nodeId}: launch recipe references missing ${label} '${value}' (${sessionPath})`);
+    }
+}
+/** Validate the broker launch recipe before we detach a child process. This is
+ *  the fast-fail seam for known module/path errors: a bad engine resolve or a
+ *  missing plain session path throws here, before spawn(). */
+export function preflightBrokerLaunch(nodeId, inv, cwd) {
+    const dir = nodeDir(nodeId);
+    mkdirSync(dir, { recursive: true });
+    const launchPath = join(dir, 'broker-launch.json');
+    writeFileSync(launchPath, JSON.stringify(inv));
+    const raw = readFileSync(launchPath, 'utf8');
+    const recipe = JSON.parse(raw);
+    if (!Array.isArray(recipe.argv)) {
+        throw new Error(`[broker] refusing to launch ${nodeId}: broker-launch.json is missing the argv array`);
+    }
+    const engineSpec = inv.env['CRTR_BROKER_ENGINE'] ?? process.env['CRTR_BROKER_ENGINE'] ?? DEFAULT_BROKER_ENGINE;
+    try {
+        const resolvedEngine = import.meta.resolve(engineSpec);
+        if (resolvedEngine.startsWith('file:') && !existsSync(fileURLToPath(resolvedEngine))) {
+            throw new Error(`resolved to missing file ${resolvedEngine}`);
+        }
+    }
+    catch (error) {
+        throw new Error(`[broker] refusing to launch ${nodeId}: cannot resolve broker engine '${engineSpec}' from ${resolveBrokerEntry()} — ${error.message}`);
+    }
+    const argv = recipe.argv;
+    for (let i = 0; i < argv.length; i++) {
+        const tok = argv[i];
+        if (tok !== '--session' && tok !== '--fork')
+            continue;
+        const value = argv[++i];
+        if (value === undefined)
+            continue;
+        preflightLaunchSessionArg(nodeId, cwd, tok, value);
+    }
+}
 /** How long teardown waits after sending the graceful `shutdown` frame before
  *  SIGTERMing a broker that connected but never exited (e.g. a hung dispose()). */
 const BROKER_SHUTDOWN_GRACE_MS = 2_000;
 export const headlessBrokerHost = {
     launch(nodeId, inv, opts) {
-        const dir = nodeDir(nodeId);
-        mkdirSync(dir, { recursive: true });
-        // The broker reads this recipe back via runBroker(nodeId) → broker-launch.json.
-        writeFileSync(join(dir, 'broker-launch.json'), JSON.stringify(inv));
+        // Fast-fail known launch errors before we detach a broker process.
+        preflightBrokerLaunch(nodeId, inv, opts.cwd);
         // Redirect the detached broker's stdout+stderr to a per-node log under the
         // node's existing job/ dir (alongside log.jsonl / telemetry.json). Without
         // this (stdio:'ignore') EVERY broker diagnostic — the version-skew warning,
@@ -64,8 +115,19 @@ export const headlessBrokerHost = {
         // The child holds its own dup of the fd; release the parent's copy so the
         // launching process (CLI or daemon) never leaks it.
         closeSync(logFd);
+        const exited = new Promise((resolve) => {
+            let settled = false;
+            const finish = (state) => {
+                if (settled)
+                    return;
+                settled = true;
+                resolve(state);
+            };
+            child.once('exit', (code, signal) => finish({ code, signal }));
+            child.once('error', () => finish({ code: null, signal: null }));
+        });
         child.unref();
-        return { pid: child.pid ?? null };
+        return { pid: child.pid ?? null, exited };
     },
     isAlive(node) {
         return isPidAlive((typeof node === 'string' ? getNode(node) : node)?.pi_pid);
@@ -76,7 +138,7 @@ export const headlessBrokerHost = {
         // flipped done/canceled by the caller (crash-safe ordering), so the daemon
         // won't revive. On connect failure (broker dead/crashed) fall back to a
         // SIGTERM of the broker pid + unlink the stale socket.
-        const sockPath = join(nodeDir(nodeId), 'view.sock');
+        const sockPath = viewSocketPath(nodeId);
         const cleanupSocket = () => {
             try {
                 if (existsSync(sockPath))