@north-light/crouter 0.3.249 → 0.3.250

package/dist/core/runtime/broker/engine-drive.js

@@ -3,7 +3,7 @@ import { operationIdContext } from '../../events/operation-id.js';
 import { promptWithAdvertisedCommandInvocation } from '../advertised-command-invocation.js';
 import { chooseGuidanceDeliveryMode, promptWithNextTurnGuidance, resolveEngineRoute, resolveSteerCall, } from './engine-routing.js';
 export function createEngineDriver(deps) {
-    const { registry, replies, session, dispatches, memoryRefs, authReloadGate, rebind, projection, toolGroups, } = deps;
+    const { registry, replies, session, dispatches, memoryRefs, authReloadGate, rebind, projection, toolGroups, turnAdmission, } = deps;
     const { ackTo, engineErrorTo } = replies;
     const errorRelay = (client) => {
         let failure;
@@ -39,7 +39,10 @@ export function createEngineDriver(deps) {
         // before the caught promise resolves, so reading it after the chain is
         // the call's verdict.
         const settle = (p) => p.then(() => errors.failure());
-        const dispatch = () => {
+        const dispatch = () => turnAdmission.admit((release) => {
+            // A prior prompt can be in asynchronous preflight while isStreaming is
+            // false. Admission waits for that preflight, then routes against the
+            // state it actually established instead of its stale snapshot.
             const route = resolveEngineRoute(frame, session().isStreaming);
             const guidance = memoryRefs.guidanceFor(frame.text);
             if (guidance === null) {
@@ -48,9 +51,10 @@ export function createEngineDriver(deps) {
                     // escalated by m-C — so it gets a fresh operation id. A true
                     // (mid-stream) followUp rides the current turn's operation, like
                     // steer.
-                    return settle(dispatches.track(operationIdContext.fresh(() => promptWithAdvertisedCommandInvocation(session(), frame.text, () => session().prompt(frame.text, route.options)).catch(relayError))));
+                    return settle(dispatches.track(operationIdContext.fresh(() => promptWithAdvertisedCommandInvocation(session(), frame.text, () => session().prompt(frame.text, { ...route.options, preflightResult: release })).catch(relayError))));
                 }
                 // C1: pi's followUp() takes images as a POSITIONAL 2nd arg (`followUp(text, images?)`).
+                release();
                 return settle(session().followUp(frame.text, frame.images).catch(relayError));
             }
             const deliverAs = chooseGuidanceDeliveryMode(frame.type, route.call, session().isStreaming);
@@ -63,19 +67,20 @@ export function createEngineDriver(deps) {
                     // ATOMICALLY clears its own pending entry if prompt() settles
                     // without ever reaching that drain (an early throw/return leaves
                     // nothing stranded to leak into a later, unrelated turn).
-                    return settle(dispatches.track(promptWithNextTurnGuidance(session(), guidance, () => operationIdContext.fresh(() => promptWithAdvertisedCommandInvocation(session(), frame.text, () => session().prompt(frame.text, route.options)))).catch(relayError)));
+                    return settle(dispatches.track(promptWithNextTurnGuidance(session(), guidance, () => operationIdContext.fresh(() => promptWithAdvertisedCommandInvocation(session(), frame.text, () => session().prompt(frame.text, { ...route.options, preflightResult: release })))).catch(relayError)));
                 }
-                return settle(dispatches.track(operationIdContext.fresh(() => promptWithAdvertisedCommandInvocation(session(), frame.text, () => session().prompt(frame.text, route.options))
+                return settle(dispatches.track(operationIdContext.fresh(() => promptWithAdvertisedCommandInvocation(session(), frame.text, () => session().prompt(frame.text, { ...route.options, preflightResult: release }))
                     .catch(relayError)
                     .then(() => sendGuidance(guidance, deliverAs)))));
             }
             // deliverAs is always 'followUp' here per chooseGuidanceDeliveryMode's
             // contract (a followUp routeCall never yields 'nextTurn').
+            release();
             return settle(session()
                 .followUp(frame.text, frame.images)
                 .catch(relayError)
                 .then(() => sendGuidance(guidance, deliverAs)));
-        };
+        });
         // /login acknowledges before its asynchronous local refresh completes.
         // An idle turn must not overtake that refresh and launch on the stale
         // route; true mid-stream follow-ups keep their immediate queue behavior.
@@ -130,23 +135,23 @@ export function createEngineDriver(deps) {
      */
     const driveSteer = (frame, errors) => {
         const relayError = errors.relay;
-        if (resolveSteerCall(frame.text, session()) === 'prompt') {
-            void promptWithAdvertisedCommandInvocation(session(), frame.text, () => session().prompt(frame.text, {
-                images: frame.images,
-                streamingBehavior: 'steer',
-            })).catch(relayError);
-            return;
-        }
-        const guidance = memoryRefs.guidanceFor(frame.text);
-        // C1: pi's steer() takes images as a POSITIONAL 2nd arg (`steer(text, images?)`).
-        if (guidance === null) {
-            void session().steer(frame.text, frame.images).catch(relayError);
-            return;
-        }
-        void session()
-            .steer(frame.text, frame.images)
-            .catch(relayError)
-            .then(() => sendGuidance(guidance, 'steer'));
+        void turnAdmission.admit((release) => {
+            if (resolveSteerCall(frame.text, session()) === 'prompt') {
+                return promptWithAdvertisedCommandInvocation(session(), frame.text, () => session().prompt(frame.text, {
+                    images: frame.images,
+                    streamingBehavior: 'steer',
+                    preflightResult: release,
+                }));
+            }
+            release();
+            const guidance = memoryRefs.guidanceFor(frame.text);
+            // C1: pi's steer() takes images as a POSITIONAL 2nd arg (`steer(text, images?)`).
+            if (guidance === null)
+                return session().steer(frame.text, frame.images);
+            return session()
+                .steer(frame.text, frame.images)
+                .then(() => sendGuidance(guidance, 'steer'));
+        }).catch(relayError);
     };
     /**
      * esc/abort cancels whatever is live: a running `!` command (abortBash)

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

@@ -21,6 +21,7 @@ export declare class EventProjection {
     private pendingUpdateTimer;
     private workingActivity;
     private readonly streamWatchdog;
+    private readonly toolExecutionWatchdog;
     private readonly streamWatchdogMs;
     private pendingBroadcast;
     private broadcastGeneration;
@@ -30,8 +31,11 @@ export declare class EventProjection {
     flush(): void;
     reset(): void;
     dispose(): void;
+    /** Arms the applicable watchdog floor after a streaming event or rebind. */
+    rearmIfStreaming(generation: SubscriptionGeneration): void;
     knownStreamWait(deadlineMs: number): () => void;
     relayEvent(event: BrokerToClient, generation: SubscriptionGeneration): void;
+    private abortStalledStream;
     private clearPendingUpdate;
     private flushPendingUpdate;
     private invalidatePendingBroadcasts;

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

@@ -6,6 +6,9 @@ import { withoutYieldAbort } from '../session-cycles.js';
 import { DEFAULT_WORKING_ACTIVITY, randomWorkingActivity } from '../../../shared/working-activity.js';
 import { hydrateLiveAdvertisedCommandMessage, prepareAdvertisedCommandPersistence, } from '../advertised-command-invocation.js';
 const MESSAGE_UPDATE_COALESCE_MS = 75;
+// Match the daemon's wedge grace: a tool may legitimately be silent longer than
+// a provider stream, but it cannot leave the broker unguarded indefinitely.
+const TOOL_EXECUTION_WATCHDOG_MS = 20 * 60_000;
 /** Projects one live engine event stream to broker viewers and owns its relay timers. */
 export class EventProjection {
     deps;
@@ -13,25 +16,18 @@ export class EventProjection {
     pendingUpdateTimer = null;
     workingActivity = DEFAULT_WORKING_ACTIVITY;
     streamWatchdog;
+    toolExecutionWatchdog;
     streamWatchdogMs = envStreamWatchdogMs();
     pendingBroadcast = null;
     broadcastGeneration = 0;
     constructor(deps) {
         this.deps = deps;
         this.streamWatchdog = new StreamWatchdog((armedGeneration) => {
-            const generation = this.deps.installedGeneration();
-            if (generation === undefined || armedGeneration !== generation.id)
-                return;
-            emitEvent({
-                level: 'debug',
-                event: 'broker.runtime.diagnostic',
-                fields: { message: `stream watchdog: no engine event for ${this.streamWatchdogMs}ms while streaming — aborting stalled provider stream` },
-            });
-            generation.stagedWatchdogAbort = true;
-            void generation.session.abort().catch((err) => {
-                emitEvent({ level: 'debug', event: 'broker.runtime.diagnostic', fields: { message: `stream watchdog abort failed: ${String(err)}` } });
-            });
+            this.abortStalledStream(armedGeneration, this.streamWatchdogMs, 'while streaming — aborting stalled provider stream');
         }, this.streamWatchdogMs);
+        this.toolExecutionWatchdog = new StreamWatchdog((armedGeneration) => {
+            this.abortStalledStream(armedGeneration, TOOL_EXECUTION_WATCHDOG_MS, 'while a tool is executing — aborting stalled tool execution');
+        }, TOOL_EXECUTION_WATCHDOG_MS);
     }
     currentWorkingActivity() {
         return this.workingActivity;
@@ -46,11 +42,25 @@ export class EventProjection {
         this.clearPendingUpdate();
         this.invalidatePendingBroadcasts();
         this.streamWatchdog.reset();
+        this.toolExecutionWatchdog.reset();
     }
     dispose() {
         this.clearPendingUpdate();
         this.invalidatePendingBroadcasts();
         this.streamWatchdog.reset();
+        this.toolExecutionWatchdog.reset();
+    }
+    /** Arms the applicable watchdog floor after a streaming event or rebind. */
+    rearmIfStreaming(generation) {
+        if (!generation.session.isStreaming)
+            return;
+        if (generation.executingTools.size > 0) {
+            this.streamWatchdog.clear();
+            this.toolExecutionWatchdog.poke(generation.id);
+            return;
+        }
+        this.toolExecutionWatchdog.clear();
+        this.streamWatchdog.poke(generation.id);
     }
     knownStreamWait(deadlineMs) {
         if (!Number.isFinite(deadlineMs) || deadlineMs <= Date.now())
@@ -99,18 +109,14 @@ export class EventProjection {
         if (type === 'agent_end') {
             generation.executingTools.clear();
             this.streamWatchdog.reset();
+            this.toolExecutionWatchdog.reset();
         }
-        else if (type === 'tool_execution_start') {
-            generation.executingTools.add(event.toolCallId ?? '');
-            this.streamWatchdog.clear();
-        }
-        else if (type === 'tool_execution_end') {
-            generation.executingTools.delete(event.toolCallId ?? '');
-            if (generation.executingTools.size === 0 && generation.session.isStreaming)
-                this.streamWatchdog.poke(generation.id);
-        }
-        else if (generation.session.isStreaming && generation.executingTools.size === 0) {
-            this.streamWatchdog.poke(generation.id);
+        else {
+            if (type === 'tool_execution_start')
+                generation.executingTools.add(event.toolCallId ?? '');
+            else if (type === 'tool_execution_end')
+                generation.executingTools.delete(event.toolCallId ?? '');
+            this.rearmIfStreaming(generation);
         }
         if (type === 'message_update') {
             this.pendingUpdate = event;
@@ -128,6 +134,20 @@ export class EventProjection {
         }
         this.broadcast(event);
     }
+    abortStalledStream(armedGeneration, timeoutMs, context) {
+        const generation = this.deps.installedGeneration();
+        if (generation === undefined || armedGeneration !== generation.id)
+            return;
+        emitEvent({
+            level: 'debug',
+            event: 'broker.runtime.diagnostic',
+            fields: { message: `stream watchdog: no engine event for ${timeoutMs}ms ${context}` },
+        });
+        generation.stagedWatchdogAbort = true;
+        void generation.session.abort().catch((err) => {
+            emitEvent({ level: 'debug', event: 'broker.runtime.diagnostic', fields: { message: `stream watchdog abort failed: ${String(err)}` } });
+        });
+    }
     clearPendingUpdate() {
         if (this.pendingUpdateTimer !== null) {
             clearTimeout(this.pendingUpdateTimer);

package/dist/core/runtime/broker/fault-retry.d.ts

@@ -4,6 +4,7 @@ import type { BrokerSdkConfig } from '../launch.js';
 import type { BrokerToClient } from '../broker-protocol.js';
 import type { BrokerSession } from './read-ops.js';
 import type { SubscriptionGeneration } from './rebind.js';
+import type { TurnAdmissionGate } from './turn-admission.js';
 type FaultRetryDeps = {
     nodeId: string;
     cfg: BrokerSdkConfig;
@@ -14,6 +15,7 @@ type FaultRetryDeps = {
     registryOf: (services: AgentSessionServices) => ModelRegistry;
     formatModelSpec: (model: BrokerSession['model'], thinkingLevel?: string) => string | null;
     broadcastModelChanged: (persist?: boolean) => Promise<void>;
+    turnAdmission: TurnAdmissionGate;
 };
 /** Owns provider fallback and daemon-driven fault retry state for one broker session. */
 export declare class FaultRetry {
@@ -29,9 +31,16 @@ export declare class FaultRetry {
     onEvent(event: BrokerToClient): void;
     isActiveAutoFault(fault: ReturnType<typeof readFault>): fault is NonNullable<ReturnType<typeof readFault>>;
     publishSettledProviderFault(generation: SubscriptionGeneration): void;
+    /** Startup re-drive reads only a durable pending episode. Revive deliberately
+     * clears the ordinary fault marker before this boundary, so the episode is
+     * the recovery authority and admitted/invalidated records remain inert. */
+    recoverPendingOnStartup(): void;
     schedule(): void;
     private maybeSwitchProviderForRetry;
     private maybeFallbackOnUnusableModel;
+    private recordPendingProviderFault;
+    private sessionFile;
+    private pendingEpisodeMatches;
     private faultRetryDelayMs;
     private clearAndArmFaultRetry;
     private runFaultRetry;

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

@@ -1,7 +1,8 @@
+import { realpathSync } from 'node:fs';
 import { envModelIntent, envNodeCwd, envProfileId } from '../../../shared/env.js';
 import { isContextOverflow } from '@earendil-works/pi-ai';
 import { classify } from '../../fault-classifier.js';
-import { clearFault, isModelNotFoundError, isProviderUnconfiguredError, readFault, recordFault } from '../fault.js';
+import { admitProviderRetryEpisode, clearFault, clearProviderRetryEpisode, invalidateProviderRetryEpisode, isModelNotFoundError, isProviderUnconfiguredError, readFault, readProviderRetryEpisode, recordFault, recordPendingProviderRetryFault, } from '../fault.js';
 import { extractCoolingDeadline } from '../managed-provider-cooling.js';
 import { expandModelCandidates, modelRequestFromConfig, probeRouteAvailability } from '../../model-routes.js';
 import { operationIdContext } from '../../events/operation-id.js';
@@ -77,7 +78,7 @@ export class FaultRetry {
             return;
         }
         if (watchdogAbort && last?.stopReason === 'aborted') {
-            recordFault(this.deps.nodeId, {
+            this.recordPendingProviderFault(settledSession, {
                 link: 'pi→provider', op: 'generation turn', kind: 'connection',
                 retry: { disposition: 'auto', by: 'daemon', ...(episode?.attempt !== undefined ? { attempt: episode.attempt } : {}) },
                 message: typeof last.errorMessage === 'string' ? last.errorMessage : 'engine error (no errorMessage recorded)',
@@ -101,7 +102,7 @@ export class FaultRetry {
         const coolingDeadline = extractCoolingDeadline(last);
         if (uncompactedOverflow)
             clearFault(this.deps.nodeId, { link: 'pi→provider' });
-        recordFault(this.deps.nodeId, {
+        const faultInput = {
             link: 'pi→provider', op: 'generation turn', kind: uncompactedOverflow ? 'context-overflow' : classified.kind,
             retry: uncompactedOverflow
                 ? { disposition: 'fatal' }
@@ -117,7 +118,35 @@ export class FaultRetry {
             anchorEntryId: !uncompactedOverflow && classified.disposition === 'auto' && episode?.anchorEntryId !== undefined
                 ? episode.anchorEntryId
                 : settledSession.sessionManager.getLeafId?.() ?? undefined,
-        });
+        };
+        if (faultInput.retry.disposition === 'auto')
+            this.recordPendingProviderFault(settledSession, faultInput);
+        else
+            recordFault(this.deps.nodeId, faultInput);
+    }
+    /** Startup re-drive reads only a durable pending episode. Revive deliberately
+     * clears the ordinary fault marker before this boundary, so the episode is
+     * the recovery authority and admitted/invalidated records remain inert. */
+    recoverPendingOnStartup() {
+        const generation = this.deps.installedGeneration();
+        if (generation === undefined)
+            return;
+        const episode = readProviderRetryEpisode(this.deps.nodeId);
+        const sessionFile = this.sessionFile(generation.session);
+        // A new-cycle launch deliberately roots a new transcript branch even though
+        // it reuses the same .jsonl. Its old anchor is no longer a valid recovery
+        // coordinate, so mark the episode invalid rather than inferring that from
+        // the shared path or letting startup re-drive into the fresh cycle.
+        if (this.deps.cfg.newCycle === true) {
+            if (episode !== null && sessionFile !== null && episode.sessionFile === sessionFile) {
+                invalidateProviderRetryEpisode(this.deps.nodeId, sessionFile);
+            }
+            return;
+        }
+        if (episode === null || sessionFile === null || episode.state !== 'pending' || episode.sessionFile !== sessionFile)
+            return;
+        recordFault(this.deps.nodeId, episode.fault);
+        this.schedule();
     }
     schedule() {
         const generation = this.deps.installedGeneration();
@@ -125,7 +154,11 @@ export class FaultRetry {
         if (generation === undefined || session.isStreaming || this.timer !== null)
             return;
         const fault = readFault(this.deps.nodeId);
-        if (!this.isActiveAutoFault(fault)) {
+        // A live session without a durable transcript path still owns its ordinary
+        // in-process timer; it simply cannot survive broker death. Once a path
+        // exists, require its pending episode so admitted/invalidated retries stay
+        // inert even before a replacement broker starts.
+        if (!this.isActiveAutoFault(fault) || (this.sessionFile(session) !== null && !this.pendingEpisodeMatches(session, fault))) {
             this.clearTimer();
             return;
         }
@@ -215,7 +248,7 @@ export class FaultRetry {
                 return;
             if (unconfigured)
                 clearFault(this.deps.nodeId, { link: 'pi→provider' });
-            await operationIdContext.fresh(() => candidateSession.prompt(formatCard('recovery', {}, formatModelFallbackRecovery(currentSpec, resolved, unconfigured ? 'credential' : 'not-found'))));
+            await this.deps.turnAdmission.admit((release) => operationIdContext.fresh(() => candidateSession.prompt(formatCard('recovery', {}, formatModelFallbackRecovery(currentSpec, resolved, unconfigured ? 'credential' : 'not-found')), { preflightResult: release })));
         })().catch((err) => {
             emitEvent({ level: 'debug', event: 'broker.runtime.diagnostic', fields: { message: `${unconfigured ? 'unconfigured-provider' : 'not_found'} fallback failed: ${err instanceof Error ? err.message : String(err)}` } });
         }).finally(() => {
@@ -224,6 +257,36 @@ export class FaultRetry {
         });
         this.notFoundFallbackInFlight = fallbackPromise;
     }
+    recordPendingProviderFault(session, input) {
+        const sessionFile = this.sessionFile(session);
+        // A pathless session cannot be crash-recovered, but its live broker still
+        // owns the ordinary auto-retry timer.
+        if (sessionFile === null) {
+            recordFault(this.deps.nodeId, input);
+            return;
+        }
+        recordPendingProviderRetryFault(this.deps.nodeId, sessionFile, input);
+    }
+    sessionFile(session) {
+        if (typeof session.sessionFile !== 'string' || session.sessionFile === '')
+            return null;
+        try {
+            return realpathSync(session.sessionFile);
+        }
+        catch {
+            return session.sessionFile;
+        }
+    }
+    pendingEpisodeMatches(session, fault) {
+        const sessionFile = this.sessionFile(session);
+        const episode = readProviderRetryEpisode(this.deps.nodeId);
+        return sessionFile !== null &&
+            episode !== null &&
+            episode.state === 'pending' &&
+            episode.sessionFile === sessionFile &&
+            episode.fault.since === fault.since &&
+            episode.anchorEntryId === (fault.anchorEntryId ?? null);
+    }
     faultRetryDelayMs(fault, now) {
         if (fault.retry.nextAt !== undefined) {
             const ms = Date.parse(fault.retry.nextAt) - now;
@@ -280,11 +343,13 @@ export class FaultRetry {
         const policy = policyFor(fault.kind);
         if (attempt >= policy.max) {
             recordFault(this.deps.nodeId, markFatalOnExhaust(fault));
+            clearProviderRetryEpisode(this.deps.nodeId);
             return;
         }
         const plan = nextFaultRetry(fault, Date.now());
         if (plan === null) {
             recordFault(this.deps.nodeId, markFatalOnExhaust(fault));
+            clearProviderRetryEpisode(this.deps.nodeId);
             return;
         }
         if (fault.anchorEntryId !== undefined) {
@@ -301,7 +366,28 @@ export class FaultRetry {
         }
         if (this.deps.installedGeneration() !== generation || this.deps.currentSession() !== candidateSession)
             return;
-        recordFault(this.deps.nodeId, plan.fault);
-        await operationIdContext.fresh(() => candidateSession.prompt(formatCard('recovery', {}, fault.kind === 'connection' ? CONNECTION_FAULT_RECOVERY_BODY : PROVIDER_FAULT_RECOVERY_BODY)));
+        await this.deps.turnAdmission.admit((release) => {
+            const current = readFault(this.deps.nodeId);
+            if (this.deps.installedGeneration() !== generation ||
+                this.deps.currentSession() !== candidateSession ||
+                candidateSession.isStreaming ||
+                !this.isActiveAutoFault(current) ||
+                current.since !== fault.since) {
+                release();
+                return Promise.resolve();
+            }
+            // This is the admission point: all generation/session/streaming/fault
+            // revalidation above has passed, and only now may the durable episode
+            // become admitted. Writing it before prompt() fails closed across a broker
+            // death in the narrow handoff to the SDK — replaying there could duplicate
+            // an already accepted recovery turn.
+            const sessionFile = this.sessionFile(candidateSession);
+            if (sessionFile !== null && !admitProviderRetryEpisode(this.deps.nodeId, sessionFile, plan.fault)) {
+                release();
+                return Promise.resolve();
+            }
+            recordFault(this.deps.nodeId, plan.fault);
+            return operationIdContext.fresh(() => candidateSession.prompt(formatCard('recovery', {}, fault.kind === 'connection' ? CONNECTION_FAULT_RECOVERY_BODY : PROVIDER_FAULT_RECOVERY_BODY), { preflightResult: release }));
+        });
     }
 }

package/dist/core/runtime/broker/frame-dispatch.d.ts

@@ -5,6 +5,7 @@ import type { BrokerClient, BrokerClientRegistry } from './client-registry.js';
 import type { BrokerSession } from './read-ops.js';
 import { type DriveFrame } from './engine-drive.js';
 import { type PendingDialog } from './frame-client.js';
+import type { TurnAdmissionGate } from './turn-admission.js';
 import type { ToolGroupTracker } from './tool-groups.js';
 import type { EventProjection } from './event-projection.js';
 import type { RebindDriver } from './rebind.js';
@@ -28,6 +29,7 @@ export type FrameDispatchDeps = {
     registryOf: (services: AgentSessionServices) => ModelRegistry;
     formatModelSpec: (model: BrokerSession['model'], thinkingLevel?: string) => string | null;
     formatExactModelSpec: (model: BrokerSession['model'], thinkingLevel?: string) => string | null;
+    turnAdmission: TurnAdmissionGate;
     resolveLaunchModel: (services: AgentSessionServices, cfg: BrokerSdkConfig) => Promise<{
         model: NonNullable<ReturnType<ModelRegistry['find']>>;
         thinkingLevel: string | undefined;

package/dist/core/runtime/broker/frame-dispatch.js

@@ -9,7 +9,7 @@ import { createSessionHandler } from './frame-session.js';
 import { createKickoffDriver, createPromptDispatchTracker, createTurnAcceptanceGate, } from './turn-ignition.js';
 /** Owns frame-local input state while dispatching through explicit broker collaborators. */
 export function createFrameDispatchContext(deps) {
-    const { nodeId, cfg, registry, toolGroups, projection, rebind, boundaryReviewId, pendingDialogs, sendWelcome, replayExtraPendingDialogsTo, reWelcomeAll, disposeAndExit, persistModelChoice, broadcastModelChanged, registryOf, formatModelSpec, formatExactModelSpec, resolveLaunchModel, } = deps;
+    const { nodeId, cfg, registry, toolGroups, projection, rebind, boundaryReviewId, pendingDialogs, sendWelcome, replayExtraPendingDialogsTo, reWelcomeAll, disposeAndExit, persistModelChoice, broadcastModelChanged, registryOf, formatModelSpec, formatExactModelSpec, turnAdmission, resolveLaunchModel, } = deps;
     const currentSession = () => rebind.session();
     const currentServices = () => rebind.services();
     // The reply vocabulary every handler below answers a client with.
@@ -21,6 +21,7 @@ export function createFrameDispatchContext(deps) {
     const kickoffDriver = createKickoffDriver({
         session: currentSession,
         dispatches,
+        turnAdmission,
     });
     const authReloadGate = createAuthReloadGate({
         nodeId,
@@ -33,6 +34,7 @@ export function createFrameDispatchContext(deps) {
         formatModelSpec,
         resolveLaunchModel,
         driveKickoff: kickoffDriver.drivePending,
+        turnAdmission,
     });
     const driveEngine = createEngineDriver({
         registry,
@@ -44,6 +46,7 @@ export function createFrameDispatchContext(deps) {
         rebind,
         projection,
         toolGroups,
+        turnAdmission,
     });
     const handleDriveFrame = (client, frame) => {
         if (notWritable(client, 'drive the engine'))

package/dist/core/runtime/broker/inbox.js

@@ -3,6 +3,7 @@
 import { existsSync, readFileSync } from 'node:fs';
 import { inboxPath, nodeDir } from '../../canvas/paths.js';
 import { formatInboxCard } from '../../../shared/generated-context.js';
+import { renderBirthAnnouncementBody } from '../../../shared/birth-announcement.js';
 const ENTRY_ID = /^(?!0{32}$)[0-9a-f]{32}$/;
 const BODY_MAX_LINES = 12;
 const BODY_MAX_CHARS = 1000;
@@ -140,6 +141,9 @@ function inlineReport(entry, reportNodes) {
 /** One entry's card body: an inlined short report, a bounded inline message
  *  body, or the label when the entry carries neither. */
 function entryBody(entry, reportNodes) {
+    const birth = renderBirthAnnouncementBody(entry.data, entry.ts);
+    if (birth !== null)
+        return birth;
     const report = inlineReport(entry, reportNodes);
     if (report !== null)
         return report.trimEnd();

package/dist/core/runtime/broker/rebind.js

@@ -5,6 +5,7 @@ import { emitEvent } from '../../events/emit.js';
 import { operationIdContext } from '../../events/operation-id.js';
 import { installPersonaTransitionGate } from '../broker-persona-guidance.js';
 import { abortSessionFromExtension } from './extension-abort.js';
+import { clearFault, invalidateProviderRetryEpisode, readFault } from '../fault.js';
 const MAX_ADMITTED_REPLACEMENTS = 2;
 const REPLACEMENT_DEADLINE_MS = 30_000;
 const REPLACEMENT_DEADLINE_EXCEEDED = Symbol('replacement-deadline-exceeded');
@@ -95,6 +96,22 @@ export class RebindDriver {
         const task = this.rebindTail.then(async () => {
             if (ticket !== this.latestRebindRequest)
                 return;
+            // A replacement changes the conversation coordinate. The initial bind has
+            // no prior generation and must retain a crash-surviving pending episode;
+            // every later rebind explicitly marks the old session's episode invalid.
+            if (this.installed !== undefined) {
+                if (typeof this.sessionValue.sessionFile === 'string' && this.sessionValue.sessionFile !== '') {
+                    invalidateProviderRetryEpisode(this.deps.nodeId, this.sessionValue.sessionFile);
+                }
+                // A daemon-owned auto marker belongs to the outgoing session whether
+                // that session has a durable path or not. Retaining it lets the
+                // replacement inherit an old anchor, attempts, and backoff; fatal and
+                // manual markers stay visible.
+                const fault = readFault(this.deps.nodeId);
+                if (fault?.link === 'pi→provider' && fault.retry.disposition === 'auto' && fault.retry.by === 'daemon') {
+                    clearFault(this.deps.nodeId, { link: 'pi→provider', preserveProviderRetryEpisode: true });
+                }
+            }
             this.installed?.executingTools.clear();
             this.removeInstalledSubscription();
             this.deps.setActiveSession(candidateSession);
@@ -192,6 +209,7 @@ export class RebindDriver {
                 this.executeSubscriptionCallback(generation, event);
             });
             this.installed = generation;
+            this.deps.projection().rearmIfStreaming(generation);
             this.captureSystemPrompt(candidateSession);
         });
         this.rebindTail = task.catch(() => undefined);

package/dist/core/runtime/broker/turn-admission.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Serializes entry into AgentSession.prompt() until its preflight has decided
+ * whether it will start (or join) a run. AgentSession.isStreaming stays false
+ * through asynchronous preflight, so checking it before entering prompt() lets
+ * two calls reach the SDK's active-run ownership race. Each waiter therefore
+ * re-reads live state only after the preceding prompt has reported preflight.
+ */
+export type TurnAdmissionGate = {
+    admit<T>(start: (release: () => void) => Promise<T>): Promise<T>;
+};
+export declare function createTurnAdmissionGate(): TurnAdmissionGate;

package/dist/core/runtime/broker/turn-admission.js

@@ -0,0 +1,31 @@
+export function createTurnAdmissionGate() {
+    let tail = Promise.resolve();
+    return {
+        admit(start) {
+            const previous = tail;
+            let resolveAdmission;
+            const admitted = new Promise((resolve) => {
+                resolveAdmission = resolve;
+            });
+            tail = previous.then(() => admitted);
+            return previous.then(() => {
+                let released = false;
+                const release = () => {
+                    if (released)
+                        return;
+                    released = true;
+                    resolveAdmission();
+                };
+                try {
+                    const attempt = start(release);
+                    void attempt.then(release, release);
+                    return attempt;
+                }
+                catch (error) {
+                    release();
+                    throw error;
+                }
+            });
+        },
+    };
+}

package/dist/core/runtime/broker/turn-ignition.d.ts

@@ -1,4 +1,5 @@
 import type { BrokerSession } from './read-ops.js';
+import type { TurnAdmissionGate } from './turn-admission.js';
 /**
  * Prompt dispatches whose promise has not yet settled. `session.prompt()` does
  * async setup (input transforms, model/auth validation, compaction) BEFORE
@@ -39,4 +40,5 @@ export type KickoffDriver = {
 export declare function createKickoffDriver(deps: {
     session: () => BrokerSession;
     dispatches: PromptDispatchTracker;
+    turnAdmission: TurnAdmissionGate;
 }): KickoffDriver;

package/dist/core/runtime/broker/turn-ignition.js

@@ -41,28 +41,38 @@ export function createTurnAcceptanceGate() {
     };
 }
 export function createKickoffDriver(deps) {
-    const { session, dispatches } = deps;
+    const { session, dispatches, turnAdmission } = deps;
     let pendingPrompt;
     let inFlight = false;
     const sessionHasNoModel = () => session().model === undefined || isUnknownModel(session().model);
     const drivePending = () => {
         if (pendingPrompt === undefined || inFlight || sessionHasNoModel())
             return;
-        const prompt = pendingPrompt;
-        pendingPrompt = undefined;
         inFlight = true;
-        dispatches.track(operationIdContext.fresh(() => session()
-            .prompt(prompt)
-            .catch((err) => {
-            emitEvent({
-                level: 'error',
-                event: 'broker.prompt.first_failed',
-                error: err,
-            });
-        })
-            .finally(() => {
-            inFlight = false;
-        })));
+        void turnAdmission.admit((release) => {
+            const prompt = pendingPrompt;
+            if (prompt === undefined || sessionHasNoModel()) {
+                release();
+                inFlight = false;
+                return Promise.resolve();
+            }
+            pendingPrompt = undefined;
+            return dispatches.track(operationIdContext.fresh(() => session()
+                .prompt(prompt, {
+                preflightResult: release,
+                ...(session().isStreaming ? { streamingBehavior: 'steer' } : {}),
+            })
+                .catch((err) => {
+                emitEvent({
+                    level: 'error',
+                    event: 'broker.prompt.first_failed',
+                    error: err,
+                });
+            })
+                .finally(() => {
+                inFlight = false;
+            })));
+        });
     };
     return {
         kickoff(prompt) {