@north-light/crouter 0.3.303 → 0.3.305

package/dist/core/bash-jobs.d.ts

@@ -12,6 +12,9 @@ export interface BashJobPaths {
      * Inspector's cancel) — without it on disk, only the agent's own handoff
      * notice knows the group to signal. */
     jobPgid: string;
+    /** Launch-time identity of the detached supervisor, used to refuse a PID that
+     * has since been reused by an unrelated process. */
+    jobPgidIdentity: string;
     /** Human-readable label supplied with the bash call, when any. */
     jobPurpose: string;
     /** Epoch-ms cancel deadline for an AUTO-backgrounded job. Present only when
@@ -33,6 +36,9 @@ export declare function bashJobPaths(contextDir: string, jobId: string): BashJob
 /** The job's supervisor process group, or undefined for a job started before
  * pgid was persisted (or a partially-written dir). */
 export declare function readJobPgid(contextDir: string, jobId: string): number | undefined;
+/** Launch-time identity of the supervisor. Missing for jobs created before
+ * process-identity persistence, which are deliberately not safe to signal. */
+export declare function readJobPgidIdentity(contextDir: string, jobId: string): string | undefined;
 /** The optional human-readable job label. Jobs created before labels existed
  * have no file and deliberately project null. */
 export declare function readJobPurpose(contextDir: string, jobId: string): string | null;
@@ -73,6 +79,12 @@ export declare function clearJobDeadline(paths: BashJobPaths): void;
  *  means the group exists but cannot be signaled by this process; it is still
  *  live for the status surface. */
 export declare function isBashJobProcessGroupAlive(pgid: number): boolean;
+/** Best-effort cancellation for a detached bash supervisor. It snapshots the
+ * observable descendant tree while the supervisor is still alive, signals its
+ * leaves before their parents, then uses the shared identity-guarded KILL
+ * escalation. A descendant that detached and reparented before this snapshot
+ * is outside this guarantee. */
+export declare function cancelBashJobProcessTree(pgid: number, expectedIdentity: string): Promise<boolean>;
 export type StopBackgroundBashJobResult = {
     kind: 'stopped';
     signaled: boolean;
@@ -87,15 +99,15 @@ export type StopBackgroundBashJobResult = {
     kind: 'not-stoppable';
     logPath: string;
 };
-/** Stop one live background job using the same process-group and sentinel
- *  semantics as `crtr node bash kill`. The caller owns the user-facing
- *  notification; this primitive owns only the job control-plane mutation.
+/** Stop one live background job using the same best-effort tree cancellation
+ * semantics as inline abort and timeout. The caller owns the user-facing
+ * notification; this primitive owns only the job control-plane mutation.
  *
- *  Only a job in the live-background state the roster projects (job.bg
- *  present, job.exit absent) may be signaled. Job directories persist after
- *  the supervisor exits, so a retired, still-foreground, or already-stopped
- *  job would otherwise have its recorded pgid signaled long after the OS
- *  could have reused that id for an unrelated process group. */
+ * Only a job in the live-background state the roster projects (job.bg present,
+ * job.exit absent) may be signaled. Job directories persist after the
+ * supervisor exits, so a retired, still-foreground, or already-stopped job
+ * would otherwise have its recorded pgid signaled long after the OS could have
+ * reused that id for an unrelated process group. */
 export declare function stopBackgroundBashJob(contextDir: string, jobId: string): Promise<StopBackgroundBashJobResult>;
 /** Last `count` lines of a job log, cheaply: read at most the trailing 64 KiB
  * rather than the whole file, which for a long-running job can be enormous. */

package/dist/core/bash-jobs.js

@@ -5,6 +5,7 @@
 import { randomBytes } from 'node:crypto';
 import { closeSync, existsSync, mkdirSync, openSync, readdirSync, readFileSync, readSync, renameSync, rmSync, statSync, writeFileSync } from 'node:fs';
 import { join } from 'node:path';
+import { captureTeardownSnapshot, isAnyPidAlive, killProcessTreePids } from './canvas/pid.js';
 const MAX_BASH_JOB_PURPOSE_BYTES = 280;
 /** A purpose is display text, never shell input. Keep the file-backed control
  * plane to one bounded, visible line so old or hand-written job directories
@@ -41,6 +42,7 @@ export function bashJobPaths(contextDir, jobId) {
         jobBg: join(dir, 'job.bg'),
         jobDone: join(dir, 'job.done'),
         jobPgid: join(dir, 'job.pgid'),
+        jobPgidIdentity: join(dir, 'job.pgid-identity'),
         jobPurpose: join(dir, 'purpose'),
         jobDeadline: join(dir, 'job.deadline'),
     };
@@ -56,6 +58,17 @@ export function readJobPgid(contextDir, jobId) {
         return undefined;
     }
 }
+/** Launch-time identity of the supervisor. Missing for jobs created before
+ * process-identity persistence, which are deliberately not safe to signal. */
+export function readJobPgidIdentity(contextDir, jobId) {
+    try {
+        const identity = readFileSync(bashJobPaths(contextDir, jobId).jobPgidIdentity, 'utf8').trim();
+        return identity === '' ? undefined : identity;
+    }
+    catch {
+        return undefined;
+    }
+}
 /** The optional human-readable job label. Jobs created before labels existed
  * have no file and deliberately project null. */
 export function readJobPurpose(contextDir, jobId) {
@@ -143,15 +156,31 @@ export function isBashJobProcessGroupAlive(pgid) {
         return err.code === 'EPERM';
     }
 }
-/** Stop one live background job using the same process-group and sentinel
- *  semantics as `crtr node bash kill`. The caller owns the user-facing
- *  notification; this primitive owns only the job control-plane mutation.
+/** Best-effort cancellation for a detached bash supervisor. It snapshots the
+ * observable descendant tree while the supervisor is still alive, signals its
+ * leaves before their parents, then uses the shared identity-guarded KILL
+ * escalation. A descendant that detached and reparented before this snapshot
+ * is outside this guarantee. */
+export async function cancelBashJobProcessTree(pgid, expectedIdentity) {
+    const snapshot = captureTeardownSnapshot(pgid, expectedIdentity);
+    if (snapshot.reused || snapshot.tree.length === 0)
+        return false;
+    const tree = [...snapshot.tree].reverse();
+    const signaled = isAnyPidAlive(tree);
+    killProcessTreePids(tree, 'SIGTERM', snapshot.identities);
+    await new Promise((resolve) => setTimeout(resolve, 400));
+    killProcessTreePids(tree, 'SIGKILL', snapshot.identities);
+    return signaled;
+}
+/** Stop one live background job using the same best-effort tree cancellation
+ * semantics as inline abort and timeout. The caller owns the user-facing
+ * notification; this primitive owns only the job control-plane mutation.
  *
- *  Only a job in the live-background state the roster projects (job.bg
- *  present, job.exit absent) may be signaled. Job directories persist after
- *  the supervisor exits, so a retired, still-foreground, or already-stopped
- *  job would otherwise have its recorded pgid signaled long after the OS
- *  could have reused that id for an unrelated process group. */
+ * Only a job in the live-background state the roster projects (job.bg present,
+ * job.exit absent) may be signaled. Job directories persist after the
+ * supervisor exits, so a retired, still-foreground, or already-stopped job
+ * would otherwise have its recorded pgid signaled long after the OS could have
+ * reused that id for an unrelated process group. */
 export async function stopBackgroundBashJob(contextDir, jobId) {
     const paths = bashJobPaths(contextDir, jobId);
     if (!existsSync(paths.dir))
@@ -159,7 +188,8 @@ export async function stopBackgroundBashJob(contextDir, jobId) {
     if (!existsSync(paths.jobBg) || existsSync(paths.jobExit))
         return { kind: 'retired', logPath: paths.jobLog };
     const pgid = readJobPgid(contextDir, jobId);
-    if (pgid === undefined)
+    const pgidIdentity = readJobPgidIdentity(contextDir, jobId);
+    if (pgid === undefined || pgidIdentity === undefined)
         return { kind: 'not-stoppable', logPath: paths.jobLog };
     // Claim the stop by creating job.exit exclusively, before signaling. The
     // loser of two concurrent stops — and a stop that races the supervisor's own
@@ -179,18 +209,7 @@ export async function stopBackgroundBashJob(contextDir, jobId) {
             return { kind: 'retired', logPath: paths.jobLog };
         throw err;
     }
-    let signaled = true;
-    try {
-        process.kill(-pgid, 'SIGTERM');
-    }
-    catch {
-        signaled = false;
-    }
-    await new Promise((resolve) => setTimeout(resolve, 400));
-    try {
-        process.kill(-pgid, 'SIGKILL');
-    }
-    catch { /* already gone */ }
+    const signaled = await cancelBashJobProcessTree(pgid, pgidIdentity);
     return { kind: 'stopped', signaled, pgid, logPath: paths.jobLog };
 }
 /** Last `count` lines of a job log, cheaply: read at most the trailing 64 KiB

package/dist/core/canvas/types.d.ts

@@ -76,11 +76,13 @@ export interface LaunchSpec {
     env: Record<string, string>;
 }
 /** The repository fingerprint a refusal was decided against. An examination
- *  that reads the same three values can skip the whole proof cascade: nothing
- *  about the refusal can have changed. */
+ *  that reads the same values can skip the whole proof cascade: nothing about
+ *  the refusal can have changed. */
 export interface ManagedWorktreeObservation {
     /** Tip of `refs/heads/<base_ref>`, or null when it no longer resolves. */
     base: string | null;
+    /** Tip of the base branch's upstream (or `origin/<base_ref>` fallback). */
+    upstream: string | null;
     /** Tip of `refs/heads/<branch>`, or null when the branch is gone. */
     branch: string | null;
     /** `absent`, or a hash of the checkout's HEAD plus `git status --porcelain`. */

package/dist/core/command.js

@@ -403,7 +403,7 @@ export async function parseArgv(params, tokens, options) {
                 continue;
             }
             const rawVal = inlineValue !== undefined ? inlineValue : tokens[++i];
-            if (rawVal === undefined || rawVal.startsWith('--')) {
+            if (rawVal === undefined || (inlineValue === undefined && rawVal.startsWith('--'))) {
                 const focusedNext = flagDef.focusedHelp !== undefined && (options?.leafPath?.length ?? 0) > 0
                     ? `Run \`crtr ${options.leafPath.join(' ')} --${flagName} -h\` and read the focused value contract before retrying.`
                     : undefined;

package/dist/core/fault-classifier.d.ts

@@ -1,5 +1,6 @@
 import type { ErrorClass, OperationId } from './events/types.js';
-export type FaultLink = 'pi→provider' | 'viewer↔broker' | 'relay↔broker' | 'viewer↔crtrd' | 'daemon→node' | 'crtr→pi';
+import { type ProviderFailureDetails } from './provider-failure.js';
+export type FaultLink = 'pi→provider' | 'viewer↔broker' | 'relay↔broker' | 'viewer↔crtrd' | 'broker↔crtrd' | 'daemon→node' | 'crtr→pi';
 export type FaultKind = 'rate-limit' | 'overloaded' | 'connection' | 'auth' | 'protocol' | 'context-overflow' | 'other' | 'wedged' | 'model-not-found';
 export type FaultRetryDisposition = 'auto' | 'manual' | 'fatal';
 export type FaultRetryOwner = 'sdk' | 'daemon' | 'client';
@@ -10,6 +11,10 @@ export interface FaultRetry {
     max?: number;
     nextAt?: string;
 }
+export interface FaultProviderError extends ProviderFailureDetails {
+    provider: string;
+    model: string;
+}
 export interface Fault {
     link: FaultLink;
     op: string;
@@ -19,6 +24,7 @@ export interface Fault {
     since: string;
     operation_id: OperationId;
     anchorEntryId?: string;
+    providerError?: FaultProviderError;
 }
 export interface FaultClassification {
     kind: FaultKind;

package/dist/core/fault-classifier.js

@@ -1,5 +1,6 @@
 import { hasManagedProviderCoolingDiagnostic } from './runtime/managed-provider-cooling.js';
 import { recognizeProviderError } from './provider-error-recognition.js';
+import { extractProviderFailureDetails } from './provider-failure.js';
 import { isRecord } from '../shared/predicates.js';
 const errorClassByFaultKind = {
     'rate-limit': 'rate_limit',
@@ -78,13 +79,17 @@ export function classify(link, raw) {
         return { kind: 'rate-limit', disposition: 'auto' };
     }
     const value = isRecord(raw) ? raw : {};
+    const failure = extractProviderFailureDetails(raw);
+    const nested = failure?.causes ?? [];
     const signal = recognizeProviderError({
-        code: value['code'],
-        errno: value['errno'],
-        status: value['status'],
+        code: value['code'] ?? failure?.code ?? nested.find((cause) => cause.code !== undefined)?.code,
+        errno: value['errno'] ?? failure?.errno ?? nested.find((cause) => cause.errno !== undefined)?.errno,
+        status: value['status'] ?? failure?.status,
         wsCloseCode: value['code'],
         wsCloseReason: value['reason'],
-        message: rawText(raw),
+        message: [rawText(raw), failure?.body, ...nested.flatMap((cause) => [cause.message, cause.body])]
+            .filter((part) => typeof part === 'string' && part !== '')
+            .join(' '),
     });
     const kind = faultKindFromProviderSignal(signal);
     return { kind, disposition: classifyDisposition(link, kind) };

package/dist/core/provider-failure.d.ts

@@ -0,0 +1,30 @@
+export declare const PROVIDER_FAILURE_DIAGNOSTIC = "crtr:provider-failure";
+export interface ProviderFailureCause {
+    message?: string;
+    status?: number;
+    code?: string | number;
+    errno?: string;
+    body?: string;
+}
+export interface ProviderFailureDetails {
+    status?: number;
+    code?: string | number;
+    errno?: string;
+    body?: string;
+    causes?: ProviderFailureCause[];
+}
+export interface NormalizedProviderFailure extends ProviderFailureDetails {
+    message: string;
+}
+/** Converts an arbitrary provider failure into serializable facts before an SDK stream flattens it to `errorMessage`. */
+export declare function normalizeProviderFailure(error: unknown, observed?: {
+    status?: number;
+}): NormalizedProviderFailure;
+/** The stable diagnostic carrier for normalized provider error facts on an assistant error message. */
+export declare function providerFailureDiagnostic(details: ProviderFailureDetails): {
+    type: string;
+    timestamp: number;
+    details: Record<string, unknown>;
+};
+/** Reads provider facts from the assistant-message diagnostic without trusting arbitrary nested error objects. */
+export declare function extractProviderFailureDetails(message: unknown): ProviderFailureDetails | undefined;

package/dist/core/provider-failure.js

@@ -0,0 +1,86 @@
+import { isRecord } from '../shared/predicates.js';
+export const PROVIDER_FAILURE_DIAGNOSTIC = 'crtr:provider-failure';
+const CAUSE_LIMIT = 8;
+function text(value) {
+    return typeof value === 'string' && value.trim() !== '' ? value.trim() : undefined;
+}
+function status(value) {
+    return typeof value === 'number' && Number.isFinite(value) ? value : undefined;
+}
+function code(value) {
+    return typeof value === 'string' || typeof value === 'number' ? value : undefined;
+}
+function record(value) {
+    return isRecord(value) ? value : undefined;
+}
+function failureCause(value) {
+    const message = text(value['errorMessage']) ?? text(value['message']) ?? text(value['reason']) ?? text(value['statusText']);
+    const cause = {
+        ...(message === undefined ? {} : { message }),
+        ...(status(value['status']) === undefined ? {} : { status: status(value['status']) }),
+        ...(code(value['code']) === undefined ? {} : { code: code(value['code']) }),
+        ...(text(value['errno']) === undefined ? {} : { errno: text(value['errno']) }),
+        ...(text(value['body']) === undefined ? {} : { body: text(value['body']) }),
+    };
+    return Object.keys(cause).length === 0 ? undefined : cause;
+}
+/** Converts an arbitrary provider failure into serializable facts before an SDK stream flattens it to `errorMessage`. */
+export function normalizeProviderFailure(error, observed = {}) {
+    const root = record(error);
+    const rootCause = root === undefined ? undefined : failureCause(root);
+    const causes = [];
+    const seen = new Set([error]);
+    let current = root === undefined ? undefined : record(root['cause']);
+    while (current !== undefined && !seen.has(current) && causes.length < CAUSE_LIMIT) {
+        seen.add(current);
+        const cause = failureCause(current);
+        if (cause !== undefined)
+            causes.push(cause);
+        current = record(current['cause']);
+    }
+    const message = rootCause?.message ?? (error instanceof Error ? error.message : undefined) ?? String(error ?? 'Provider request failed');
+    return {
+        message,
+        ...((observed.status ?? rootCause?.status) === undefined ? {} : { status: observed.status ?? rootCause?.status }),
+        ...(rootCause?.code === undefined ? {} : { code: rootCause.code }),
+        ...(rootCause?.errno === undefined ? {} : { errno: rootCause.errno }),
+        ...(rootCause?.body === undefined ? {} : { body: rootCause.body }),
+        ...(causes.length === 0 ? {} : { causes }),
+    };
+}
+/** The stable diagnostic carrier for normalized provider error facts on an assistant error message. */
+export function providerFailureDiagnostic(details) {
+    return { type: PROVIDER_FAILURE_DIAGNOSTIC, timestamp: Date.now(), details: { ...details } };
+}
+function providerFailureDetails(value) {
+    const diagnostics = record(value)?.['diagnostics'];
+    if (!Array.isArray(diagnostics))
+        return undefined;
+    for (const diagnostic of diagnostics) {
+        const diagnosticRecord = record(diagnostic);
+        if (diagnosticRecord?.['type'] !== PROVIDER_FAILURE_DIAGNOSTIC)
+            continue;
+        const details = record(diagnosticRecord['details']);
+        if (details === undefined)
+            continue;
+        const causes = Array.isArray(details['causes'])
+            ? details['causes'].flatMap((item) => {
+                const cause = record(item);
+                const normalized = cause === undefined ? undefined : failureCause(cause);
+                return normalized === undefined ? [] : [normalized];
+            })
+            : undefined;
+        return {
+            ...(status(details['status']) === undefined ? {} : { status: status(details['status']) }),
+            ...(code(details['code']) === undefined ? {} : { code: code(details['code']) }),
+            ...(text(details['errno']) === undefined ? {} : { errno: text(details['errno']) }),
+            ...(text(details['body']) === undefined ? {} : { body: text(details['body']) }),
+            ...(causes === undefined || causes.length === 0 ? {} : { causes }),
+        };
+    }
+    return undefined;
+}
+/** Reads provider facts from the assistant-message diagnostic without trusting arbitrary nested error objects. */
+export function extractProviderFailureDetails(message) {
+    return providerFailureDetails(message);
+}

package/dist/core/runtime/broker/event-projection.d.ts

@@ -11,8 +11,6 @@ type EventProjectionDeps = {
     notifyTurnAccepted: () => void;
     emitStartupMilestone: (event: string, model: string | null) => void;
     formatModelSpec: (model: BrokerSession['model'], thinkingLevel?: string) => string | null;
-    refreshIntent: () => Promise<boolean>;
-    onRefreshIntentError: (error: unknown) => void;
 };
 /** Projects one live engine event stream to broker viewers and owns its relay timers. */
 export declare class EventProjection {
@@ -40,7 +38,6 @@ export declare class EventProjection {
     private flushPendingUpdate;
     private invalidatePendingBroadcasts;
     private broadcast;
-    private broadcastMessageEnd;
     private setPendingBroadcast;
 }
 export {};

package/dist/core/runtime/broker/event-projection.js

@@ -128,8 +128,8 @@ export class EventProjection {
             return;
         }
         this.flushPendingUpdate();
-        if (type === 'message_end') {
-            this.broadcastMessageEnd(event);
+        if (type === 'message_end' && generation.stagedRefreshAbort) {
+            this.broadcast({ ...event, message: withoutYieldAbort(event.message) });
             return;
         }
         this.broadcast(event);
@@ -183,19 +183,6 @@ export class EventProjection {
             this.deps.registry.broadcast(frame);
         }));
     }
-    broadcastMessageEnd(event) {
-        const preceding = this.pendingBroadcast ?? Promise.resolve();
-        const generation = this.broadcastGeneration;
-        this.setPendingBroadcast(preceding.then(async () => {
-            const refresh = await this.deps.refreshIntent();
-            if (this.broadcastGeneration !== generation)
-                return;
-            this.deps.registry.broadcast(refresh ? { ...event, message: withoutYieldAbort(event.message) } : event);
-        }).catch((error) => {
-            if (this.broadcastGeneration === generation)
-                this.deps.onRefreshIntentError(error);
-        }));
-    }
     setPendingBroadcast(work) {
         this.pendingBroadcast = work;
         void work.then(() => {

package/dist/core/runtime/broker/fault-retry.js

@@ -4,6 +4,7 @@ import { isContextOverflow } from '@earendil-works/pi-ai';
 import { classify } from '../../fault-classifier.js';
 import { admitProviderRetryEpisode, clearFault, clearProviderRetryEpisode, invalidateProviderRetryEpisode, isModelNotFoundError, isProviderUnconfiguredError, readFault, readProviderRetryEpisode, recordFault, recordPendingProviderRetryFault, reopenProviderRetryEpisode, } from '../fault.js';
 import { extractCoolingDeadline } from '../managed-provider-cooling.js';
+import { extractProviderFailureDetails } from '../../provider-failure.js';
 import { expandModelCandidates, modelRequestFromConfig, probeRouteAvailability } from '../../model-routes.js';
 import { operationIdContext } from '../../events/operation-id.js';
 import { emitEvent } from '../../events/emit.js';
@@ -71,6 +72,14 @@ export class FaultRetry {
         // admitted retry therefore carries from its durable episode, while an
         // initial provider failure still reads from the ordinary marker.
         const prior = readFault(this.deps.nodeId);
+        // A persona gate runs before Pi contacts a provider. It records a typed
+        // local API transport failure, then Pi represents that thrown error as a
+        // generic provider-looking agent_end. Keep its actual boundary instead of
+        // turning it into a fatal pi→provider `other` fault.
+        if (prior?.link === 'broker↔crtrd' && prior.kind === 'connection') {
+            clearProviderRetryEpisode(this.deps.nodeId);
+            return;
+        }
         const durableEpisode = readProviderRetryEpisode(this.deps.nodeId);
         const episodeFault = this.isActiveAutoFault(prior) && prior.link === 'pi→provider'
             ? prior
@@ -123,6 +132,12 @@ export class FaultRetry {
         const uncompactedOverflow = isContextOverflow(last, settledSession.model?.contextWindow);
         const classified = classify('pi→provider', last);
         const coolingDeadline = extractCoolingDeadline(last);
+        const failure = extractProviderFailureDetails(last);
+        const provider = typeof last.provider === 'string' && last.provider !== '' ? last.provider : settledSession.model?.provider;
+        const model = typeof last.model === 'string' && last.model !== '' ? last.model : settledSession.model?.id;
+        const providerError = failure === undefined || provider === undefined || model === undefined
+            ? undefined
+            : { provider, model, ...failure };
         if (uncompactedOverflow) {
             clearFault(this.deps.nodeId, { link: 'pi→provider' });
             clearProviderRetryEpisode(this.deps.nodeId);
@@ -143,6 +158,7 @@ export class FaultRetry {
             anchorEntryId: !uncompactedOverflow && classified.disposition === 'auto' && episode?.anchorEntryId !== undefined
                 ? episode.anchorEntryId
                 : settledSession.sessionManager.getLeafId?.() ?? undefined,
+            ...(providerError === undefined ? {} : { providerError }),
         };
         if (faultInput.retry.disposition === 'auto')
             this.recordPendingProviderFault(settledSession, faultInput);

package/dist/core/runtime/broker-persona-guidance.js

@@ -1,5 +1,7 @@
 import { contextDir } from '../canvas/paths.js';
+import { isDaemonTransportApiError } from '../../api/errors.js';
 import { emitEvent } from '../events/emit.js';
+import { clearFault, recordFault } from './fault.js';
 import { brokerExtensionState, commitBrokerPersonaAck } from './broker/daemon-ops.js';
 import { readRoadmap, roadmapPath } from './roadmap.js';
 import { buildSubPersonaMenu, renderConfigChangeDelta } from '../substrate/render.js';
@@ -137,9 +139,19 @@ export function installPersonaTransitionGate(nodeId, session) {
                 for (const context of new Set([active, messages, transformed]))
                     context.push(message);
             });
+            clearFault(nodeId, { link: 'broker↔crtrd' });
             return transformed;
         }
         catch (error) {
+            if (isDaemonTransportApiError(error)) {
+                recordFault(nodeId, {
+                    link: 'broker↔crtrd',
+                    op: 'persona transition',
+                    kind: 'connection',
+                    retry: { disposition: 'manual' },
+                    message: error.message,
+                });
+            }
             emitEvent({
                 event: 'broker.daemon.operation.failed',
                 level: 'error',

package/dist/core/runtime/broker.js

@@ -375,11 +375,6 @@ export async function runBroker(nodeId, startupAt = process.hrtime.bigint(), sta
         notifyTurnAccepted: () => notifyTurnAccepted(),
         emitStartupMilestone,
         formatModelSpec,
-        refreshIntent: async () => (await brokerExtensionState(nodeId)).node.intent === 'refresh',
-        onRefreshIntentError: (error) => {
-            emitEvent({ level: 'error', event: 'broker.daemon_state.read_failed', error });
-            disposeAndExit('daemon-state-read-failed', 1);
-        },
     });
     const buildSnapshot = (client) => {
         const liveSession = rebind.session();

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

@@ -1,4 +1,4 @@
-import { type Fault, type FaultKind, type FaultLink, type FaultRetry } from '../fault-classifier.js';
+import { type Fault, type FaultKind, type FaultLink, type FaultProviderError, 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 {
@@ -10,6 +10,7 @@ export interface FaultRecordInput {
     operation_id?: string;
     since?: string;
     anchorEntryId?: string;
+    providerError?: FaultProviderError;
 }
 /** A provider-retry episode outlives its broker-local timer. Its transcript
  * path and anchor are explicit coordinates, so replacement invalidation never

package/dist/core/runtime/fault.js

@@ -1,4 +1,5 @@
 import { envNodeId } from '../../shared/env.js';
+import { isRecord } from '../../shared/predicates.js';
 import { existsSync, mkdirSync, readFileSync, realpathSync, rmSync, writeFileSync } from 'node:fs';
 import { join } from 'node:path';
 import { jobDir } from '../canvas/paths.js';
@@ -31,8 +32,39 @@ function faultPriority(fault) {
         return 2;
     return 1;
 }
-const faultLinks = ['pi→provider', 'viewer↔broker', 'relay↔broker', 'viewer↔crtrd', 'daemon→node', 'crtr→pi'];
+const faultLinks = ['pi→provider', 'viewer↔broker', 'relay↔broker', 'viewer↔crtrd', 'broker↔crtrd', 'daemon→node', 'crtr→pi'];
 const faultKinds = ['rate-limit', 'overloaded', 'connection', 'auth', 'protocol', 'context-overflow', 'other', 'wedged', 'model-not-found'];
+function parseProviderError(value) {
+    if (!isRecord(value) || typeof value.provider !== 'string' || value.provider === '' || typeof value.model !== 'string' || value.model === '')
+        return undefined;
+    const status = typeof value.status === 'number' && Number.isFinite(value.status) ? value.status : undefined;
+    const code = typeof value.code === 'string' || typeof value.code === 'number' ? value.code : undefined;
+    const errno = typeof value.errno === 'string' ? value.errno : undefined;
+    const body = typeof value.body === 'string' ? value.body : undefined;
+    const causes = Array.isArray(value.causes)
+        ? value.causes.flatMap((item) => {
+            if (!isRecord(item))
+                return [];
+            const cause = {
+                ...(typeof item.message === 'string' ? { message: item.message } : {}),
+                ...(typeof item.status === 'number' && Number.isFinite(item.status) ? { status: item.status } : {}),
+                ...(typeof item.code === 'string' || typeof item.code === 'number' ? { code: item.code } : {}),
+                ...(typeof item.errno === 'string' ? { errno: item.errno } : {}),
+                ...(typeof item.body === 'string' ? { body: item.body } : {}),
+            };
+            return Object.keys(cause).length === 0 ? [] : [cause];
+        })
+        : undefined;
+    return {
+        provider: value.provider,
+        model: value.model,
+        ...(status === undefined ? {} : { status }),
+        ...(code === undefined ? {} : { code }),
+        ...(errno === undefined ? {} : { errno }),
+        ...(body === undefined ? {} : { body }),
+        ...(causes === undefined || causes.length === 0 ? {} : { causes }),
+    };
+}
 function parseFault(raw) {
     try {
         const parsed = JSON.parse(raw);
@@ -60,6 +92,9 @@ function parseFault(raw) {
             return null;
         if (parsed.anchorEntryId !== undefined && (typeof parsed.anchorEntryId !== 'string' || parsed.anchorEntryId === ''))
             return null;
+        const providerError = parsed.providerError === undefined ? undefined : parseProviderError(parsed.providerError);
+        if (parsed.providerError !== undefined && providerError === undefined)
+            return null;
         return {
             link: parsed.link,
             op: parsed.op,
@@ -75,6 +110,7 @@ function parseFault(raw) {
             since: parsed.since,
             operation_id: operationId,
             ...(parsed.anchorEntryId === undefined ? {} : { anchorEntryId: parsed.anchorEntryId }),
+            ...(providerError === undefined ? {} : { providerError }),
         };
     }
     catch {
@@ -166,6 +202,7 @@ function storedFault(input) {
         since: input.since ?? new Date().toISOString(),
         operation_id: resolveOperationId(input.operation_id),
         ...(typeof input.anchorEntryId === 'string' && input.anchorEntryId !== '' ? { anchorEntryId: input.anchorEntryId } : {}),
+        ...(input.providerError === undefined ? {} : { providerError: input.providerError }),
     };
 }
 function emitRecordedFault(nodeId, fault) {
@@ -182,6 +219,7 @@ function emitRecordedFault(nodeId, fault) {
             retry: fault.retry,
             message: fault.message,
             ...(fault.anchorEntryId === undefined ? {} : { anchor_entry_id: fault.anchorEntryId }),
+            ...(fault.providerError === undefined ? {} : { provider_error: fault.providerError }),
         },
     });
 }

package/dist/core/runtime/host.js

@@ -319,7 +319,16 @@ export const headlessBrokerHost = {
                     });
                     finish({ code, signal });
                 });
-                spawned.once('error', () => finish({ code: null, signal: null }));
+                spawned.once('error', (error) => {
+                    emitEvent({
+                        level: 'error',
+                        event: 'broker.launch.failed',
+                        node_id: nodeId,
+                        error,
+                        fields: { uptime_ms: Date.now() - launchedAt },
+                    });
+                    finish({ code: null, signal: null });
+                });
             });
             spawned.unref();
             const handle = { pid: spawned.pid ?? null, exited };

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

@@ -26,6 +26,9 @@ export declare function readYieldMessage(nodeId: string): string | null;
 export declare function clearYieldMessage(nodeId: string): void;
 /** List the node's context/ dir (filenames, sorted). Empty when absent. */
 export declare function listContextDir(nodeId: string): string[];
+/** A retained report proves this node has already done work. It must restart
+ * from current context, never by replaying its birth mandate. */
+export declare function hasRetainedReports(nodeId: string): boolean;
 export interface ReviveBearings {
     /** The one-shot yield note left by the prior self, pending boot confirmation. */
     yieldMsg: string | null;