pilotswarm-sdk 0.3.1 → 0.3.3

package/dist/orchestration/turn.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"turn.d.ts","sourceRoot":"","sources":["../../src/orchestration/turn.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAsB,UAAU,EAAE,MAAM,aAAa,CAAC;AA8BlE,OAAO,EAKH,KAAK,qBAAqB,EAC7B,MAAM,YAAY,CAAC;AAkKpB,wBAAiB,aAAa,CAC1B,OAAO,EAAE,qBAAqB,EAC9B,UAAU,EAAE,MAAM,EAClB,WAAW,EAAE,OAAO,EACpB,YAAY,CAAC,EAAE,MAAM,EACrB,gBAAgB,CAAC,EAAE,MAAM,EAAE,EAC3B,WAAW,CAAC,EAAE,MAAM,GAAG,SAAS,GACjC,SAAS,CAAC,GAAG,EAAE,IAAI,EAAE,GAAG,CAAC,CA8J3B;AAmDD,wBAAiB,gBAAgB,CAC7B,OAAO,EAAE,qBAAqB,EAC9B,MAAM,EAAE,UAAU,EAClB,YAAY,EAAE,MAAM,EACpB,WAAW,CAAC,EAAE,MAAM,GAAG,SAAS,GACjC,SAAS,CAAC,GAAG,EAAE,IAAI,EAAE,GAAG,CAAC,CAya3B;AAID,wBAAiB,YAAY,CACzB,OAAO,EAAE,qBAAqB,EAC9B,SAAS,EAAE,GAAG,GACf,SAAS,CAAC,GAAG,EAAE,IAAI,EAAE,GAAG,CAAC,CA8L3B"}
+{"version":3,"file":"turn.d.ts","sourceRoot":"","sources":["../../src/orchestration/turn.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAsB,UAAU,EAAE,MAAM,aAAa,CAAC;AA+BlE,OAAO,EAKH,KAAK,qBAAqB,EAC7B,MAAM,YAAY,CAAC;AAkCpB;;;;;;GAMG;AACH,wBAAgB,uBAAuB,CAAC,MAAM,EAAE,KAAK,CAAC;IAAE,SAAS,CAAC,EAAE,MAAM,CAAC;IAAC,IAAI,CAAC,EAAE,GAAG,CAAA;CAAE,CAAC,GAAG,SAAS,GAAG,MAAM,GAAG,IAAI,CAYpH;AAiJD,wBAAiB,aAAa,CAC1B,OAAO,EAAE,qBAAqB,EAC9B,UAAU,EAAE,MAAM,EAClB,WAAW,EAAE,OAAO,EACpB,YAAY,CAAC,EAAE,MAAM,EACrB,gBAAgB,CAAC,EAAE,MAAM,EAAE,EAC3B,WAAW,CAAC,EAAE,MAAM,GAAG,SAAS,GACjC,SAAS,CAAC,GAAG,EAAE,IAAI,EAAE,GAAG,CAAC,CAkM3B;AAID;;;;;GAKG;AACH,wBAAgB,uBAAuB,CAAC,KAAK,EAAE,GAAG,GAAG;IAAE,IAAI,EAAE,QAAQ,CAAC;IAAC,MAAM,EAAE,GAAG,CAAA;CAAE,GAAG;IAAE,IAAI,EAAE,OAAO,CAAC;IAAC,OAAO,EAAE,MAAM,CAAA;CAAE,CAaxH;AA+TD,wBAAiB,gBAAgB,CAC7B,OAAO,EAAE,qBAAqB,EAC9B,MAAM,EAAE,UAAU,EAClB,YAAY,EAAE,MAAM,EACpB,WAAW,CAAC,EAAE,MAAM,GAAG,SAAS,GACjC,SAAS,CAAC,GAAG,EAAE,IAAI,EAAE,GAAG,CAAC,CA0R3B;AAID,wBAAiB,YAAY,CACzB,OAAO,EAAE,qBAAqB,EAC9B,SAAS,EAAE,GAAG,GACf,SAAS,CAAC,GAAG,EAAE,IAAI,EAAE,GAAG,CAAC,CAgM3B"}

package/dist/orchestration/turn.js

@@ -1,12 +1,49 @@
-import { SESSION_STATE_MISSING_PREFIX } from "../types.js";
+import { SESSION_STATE_MISSING_PREFIX, stopTurnQueueName } from "../types.js";
 import { createSessionProxy } from "../session-proxy.js";
 import { planWaitHandling } from "../wait-affinity.js";
 import { buildShutdownWaitReason, failPendingShutdown, getStillRunningAgentIds, handleSubAgentAction, isSubAgentTerminalStatus, maybeResolveAgentWaitCompletion, refreshTrackedSubAgents, } from "./agents.js";
-import { applyCronAtAction, applyCronAction, continueInput, continueInputWithPrompt, dehydrateForNextTurn, drainLeadingQueuedScheduleActions, ensureTaskContext, maybeCheckpoint, maybeSummarize, publishStatus, versionedContinueAsNew, wrapWithResumeContext, writeLatestResponse, } from "./lifecycle.js";
+import { applyCronAtAction, applyCronAction, continueInput, continueInputWithPrompt, dehydrateForNextTurn, drainLeadingQueuedScheduleActions, ensureTaskContext, maybeCheckpoint, maybeSummarize, publishStatus, versionedContinueAsNew, wrapWithResumeContext, writeCommandResponse, writeLatestResponse, } from "./lifecycle.js";
 import { describeCronAt } from "../cron-at.js";
 import { shouldWakeParentForChildUpdate } from "../child-notifications.js";
 import { INTERNAL_SYSTEM_TURN_PROMPT, MAX_RETRIES, SHUTDOWN_POLL_INTERVAL_MS, SHUTDOWN_TIMEOUT_MS, } from "./state.js";
 import { AUTH_FAILURE_USER_HINT, COPILOT_CONNECTION_CLOSED_MAX_RETRIES, COPILOT_CONNECTION_CLOSED_RETRY_DELAY_SECONDS, appendSystemContext, buildConnectionClosedRetryDetail, buildLossyHandoffRehydrationMessage, buildLossyHandoffSummary, extractPromptSystemContext, isAuthFailureError, isCopilotConnectionClosedError, mergePrompt, updateContextUsageFromEvents, } from "./utils.js";
+function currentModelLabel(runtime) {
+    const model = runtime.state.config.model || "(default)";
+    const effort = runtime.state.config.reasoningEffort;
+    return effort ? `${model}:${effort}` : model;
+}
+/**
+ * Scan a finished turn's captured events for a failed `set_session_model` tool
+ * call. The inline control tool returns its outcome as a plain string (see
+ * session-proxy `setSessionModel`), so `tool.execution_complete.data.result`
+ * is usually a string; some transports wrap it as `{ content }`. We match the
+ * `set_session_model failed` marker across both shapes. Exported for unit tests.
+ */
+export function detectFailedModelSwitch(events) {
+    if (!Array.isArray(events))
+        return null;
+    for (const event of events) {
+        if (event?.eventType !== "tool.execution_complete")
+            continue;
+        const data = event.data || {};
+        const result = data.result ?? data.output;
+        const content = typeof result === "string"
+            ? result
+            : String(result?.content ?? result?.detailedContent ?? data.content ?? "");
+        if (/set_session_model (?:failed|is unavailable|rejected)/i.test(content))
+            return content.trim();
+    }
+    return null;
+}
+function captureFailedModelSwitchNotice(runtime, result) {
+    const failure = detectFailedModelSwitch(result?.events);
+    if (!failure)
+        return null;
+    const modelLabel = currentModelLabel(runtime);
+    runtime.state.runtimeModelNotice = `Previous model switch failed; current runtime model is ${modelLabel}. If asked what model you are using, answer this value.`;
+    runtime.ctx.traceInfo(`[orch] queued failed model-switch correction: ${failure.slice(0, 160)}`);
+    return `Continue on ${modelLabel}; the requested model switch failed.`;
+}
 function* handleConnectionClosedRetry(runtime, errorMessage, rc) {
     const { state } = runtime;
     if (state.retryCount <= COPILOT_CONNECTION_CLOSED_MAX_RETRIES) {
@@ -140,6 +177,10 @@ export function* processPrompt(runtime, promptText, isBootstrap, requiredTool, c
     const extractedPrompt = extractPromptSystemContext(prompt);
     prompt = extractedPrompt.prompt ?? "";
     turnSystemPrompt = mergePrompt(turnSystemPrompt, extractedPrompt.systemPrompt);
+    if (prompt && state.runtimeModelNotice) {
+        turnSystemPrompt = mergePrompt(turnSystemPrompt, state.runtimeModelNotice);
+        state.runtimeModelNotice = undefined;
+    }
     const systemOnlyTurn = !prompt && !!turnSystemPrompt;
     if (systemOnlyTurn) {
         prompt = INTERNAL_SYSTEM_TURN_PROMPT;
@@ -203,7 +244,15 @@ export function* processPrompt(runtime, promptText, isBootstrap, requiredTool, c
     let turnResult;
     try {
         state.lastLiveSessionAction = "session-activity";
-        turnResult = yield runtime.session.runTurn(prompt, promptIsBootstrap, state.iteration, {
+        // Stop-turn race: the in-flight runTurn activity vs a dequeue on the
+        // TURN-SCOPED stop queue (stopTurn.<iteration>). Scoping the queue to
+        // the turn index makes stale stop events structurally unable to kill a
+        // later turn — a race loser is dropped and cannot be un-dropped.
+        // When the stop wins, duroxide cancel-requests the dropped runTurn
+        // work item (lock-steal → isCancelled poll → SDK abort) as the
+        // guaranteed backstop; handleTurnStopped layers the fast-path
+        // same-affinity abortTurn on top.
+        const turnTask = runtime.session.runTurn(prompt, promptIsBootstrap, state.iteration, {
             ...(runtime.options.parentSessionId ? { parentSessionId: runtime.options.parentSessionId } : {}),
             nestingLevel: runtime.options.nestingLevel,
             ...(requiredTool ? { requiredTool } : {}),
@@ -211,6 +260,21 @@ export function* processPrompt(runtime, promptText, isBootstrap, requiredTool, c
             retryCount: state.retryCount,
             ...(clientMessageIds && clientMessageIds.length > 0 ? { clientMessageIds } : {}),
         });
+        const stopTask = ctx.dequeueEvent(stopTurnQueueName(state.iteration));
+        const race = yield ctx.race(turnTask, stopTask);
+        if (race.index === 1) {
+            yield* handleTurnStopped(runtime, race.value);
+            return;
+        }
+        // The select bridge flattens activity failures into their raw error
+        // string (duroxide-node make_select_future) instead of throwing, so a
+        // failed runTurn must be re-thrown here to reach the existing retry
+        // machinery in the catch below.
+        const raced = normalizeRacedTurnValue(race.value);
+        if (raced.kind === "error") {
+            throw new Error(raced.message);
+        }
+        turnResult = raced.result;
     }
     catch (err) {
         state.config.turnSystemPrompt = undefined;
@@ -253,9 +317,16 @@ export function* processPrompt(runtime, promptText, isBootstrap, requiredTool, c
     }
     state.config.turnSystemPrompt = undefined;
     state.retryCount = 0;
-    const result = typeof turnResult === "string" ? JSON.parse(turnResult) : turnResult;
+    let result = typeof turnResult === "string" ? JSON.parse(turnResult) : turnResult;
     const observedAt = yield ctx.utcNow();
     state.contextUsage = updateContextUsageFromEvents(state.contextUsage, result?.events, observedAt);
+    const failedModelSwitchContinuePrompt = captureFailedModelSwitchNotice(runtime, result);
+    if (failedModelSwitchContinuePrompt && result.type === "completed") {
+        result = {
+            ...result,
+            forceContinuePrompt: failedModelSwitchContinuePrompt,
+        };
+    }
     state.iteration++;
     yield* maybeSummarize(runtime);
     yield* refreshTrackedSubAgents(runtime);
@@ -266,6 +337,276 @@ export function* processPrompt(runtime, promptText, isBootstrap, requiredTool, c
     yield* drainLeadingQueuedScheduleActions(runtime, prompt);
     yield* handleTurnResult(runtime, result, prompt, cycleOrigin);
 }
+// ─── Stop-turn race support ─────────────────────────────────
+/**
+ * Normalize a raced runTurn branch value. The duroxide-node select bridge
+ * flattens activity failures into their raw error string (make_select_future:
+ * `Ok(v) => v, Err(e) => e`) instead of throwing into the generator, so the
+ * caller must distinguish a TurnResult payload from an error message.
+ */
+export function normalizeRacedTurnValue(value) {
+    let v = value;
+    if (typeof v === "string") {
+        try {
+            v = JSON.parse(v);
+        }
+        catch {
+            return { kind: "error", message: value };
+        }
+    }
+    if (v && typeof v === "object" && typeof v.type === "string") {
+        return { kind: "result", result: v };
+    }
+    return { kind: "error", message: typeof value === "string" ? value : JSON.stringify(value ?? null) };
+}
+/**
+ * Stop won the race against the in-flight runTurn activity.
+ *
+ * The dropped runTurn future is already cancel-requested by duroxide (the
+ * guaranteed backstop: lock-steal → isCancelled poll → SDK abort, ~2-7s).
+ * This path layers the fast-path interrupt on top and owns the authoritative
+ * durable bookkeeping — the aborted activity's own writeback is best-effort
+ * (it is skipped entirely when the backstop delivered the abort).
+ */
+function* handleTurnStopped(runtime, stopEventRaw) {
+    const { ctx, state } = runtime;
+    let stopEvent = stopEventRaw;
+    if (typeof stopEvent === "string") {
+        try {
+            stopEvent = JSON.parse(stopEvent);
+        }
+        catch {
+            stopEvent = {};
+        }
+    }
+    if (!stopEvent || typeof stopEvent !== "object")
+        stopEvent = {};
+    const reason = typeof stopEvent.reason === "string" && stopEvent.reason ? stopEvent.reason : "Stopped by user";
+    const stoppedIteration = state.iteration;
+    ctx.traceInfo(`[orch] stop_turn won the race for turn ${stoppedIteration}; aborting in-flight turn`);
+    state.config.turnSystemPrompt = undefined;
+    state.retryCount = 0;
+    // Fast-path interrupt: same-affinity abortTurn lands on the worker owning
+    // the warm session and aborts the SDK request immediately (concurrent
+    // dispatch requires stable workerNodeId + a free slot; otherwise the
+    // backstop still stops the turn, just slower). Awaiting it also
+    // guarantees the per-session run-turn lock is free again before this
+    // loop can dispatch the next prompt.
+    let abortOutcome = null;
+    try {
+        const raw = yield runtime.session.abortTurn(reason, stoppedIteration);
+        abortOutcome = typeof raw === "string" ? JSON.parse(raw) : raw;
+    }
+    catch (err) {
+        ctx.traceInfo(`[orch] abortTurn activity failed (backstop cancellation still applies): ${err?.message ?? err}`);
+        abortOutcome = { outcome: "no_active_turn", detail: `abortTurn failed: ${err?.message ?? err}` };
+    }
+    // The race already decided the turn's fate: even when abortTurn reports
+    // no_active_turn (the backstop got there first, or the turn had just
+    // ended), the user's stop is the durable outcome. Record turn_stopped
+    // unconditionally and annotate how the interrupt was delivered.
+    yield runtime.manager.recordSessionEvent(runtime.input.sessionId, [
+        {
+            eventType: "session.turn_stopped",
+            data: {
+                reason,
+                turnIndex: stoppedIteration,
+                interrupt: abortOutcome?.outcome ?? "unknown",
+                ...(abortOutcome?.detail ? { detail: abortOutcome.detail } : {}),
+            },
+        },
+        { eventType: "system.message", data: { content: "Turn stopped by user." } },
+    ]);
+    // Authoritative CMS transition — also clears active_turn_index (migration
+    // 0024 clears it on any state transition away from "running").
+    yield runtime.manager.updateCmsState(runtime.input.sessionId, "idle");
+    // The turn ran and consumed context even though its result was discarded.
+    state.iteration++;
+    if (typeof stopEvent.id === "string" && stopEvent.id) {
+        yield* writeCommandResponse(runtime, {
+            id: stopEvent.id,
+            cmd: "stop_turn",
+            result: {
+                outcome: abortOutcome?.outcome === "stop_forced" ? "stop_forced" : "stopped",
+                turnIndex: stoppedIteration,
+                ...(abortOutcome?.detail ? { detail: abortOutcome.detail } : {}),
+            },
+        });
+    }
+    // Same scheduling semantics as a completed turn: resume interrupted
+    // timers, re-arm cron schedules, else idle (skips: writeLatestResponse,
+    // parent CHILD_UPDATE notify, forgotten-timer nudge).
+    yield* schedulePostTurnContinuation(runtime);
+}
+// ─── Post-turn continuation: resume timers / re-arm schedules / go idle ───
+//
+// Extracted verbatim from the tail of the `completed` turn-result case so the
+// stop-turn path shares identical scheduling semantics: stopping a turn must
+// not silently kill a recurring session's cron loop or a resumable wait
+// (stop-turn plan, edge E9).
+function* schedulePostTurnContinuation(runtime) {
+    const { ctx, state, options } = runtime;
+    if (state.interruptedWaitTimer && state.interruptedWaitTimer.remainingSec > 0) {
+        const saved = state.interruptedWaitTimer;
+        state.interruptedWaitTimer = null;
+        ctx.traceInfo(`[orch] auto-resuming interrupted wait: ${saved.remainingSec}s (${saved.reason})`);
+        if (saved.shouldRehydrate) {
+            yield* dehydrateForNextTurn(runtime, "timer", saved.waitPlan?.resetAffinityOnDehydrate ?? true);
+        }
+        const resumeNow = yield ctx.utcNow();
+        publishStatus(runtime, "waiting", {
+            waitSeconds: saved.remainingSec,
+            waitReason: saved.reason,
+            waitStartedAt: resumeNow,
+        });
+        if (!saved.shouldRehydrate)
+            yield* maybeCheckpoint(runtime);
+        state.activeTimer = {
+            deadlineMs: resumeNow + saved.remainingSec * 1000,
+            originalDurationMs: saved.remainingSec * 1000,
+            reason: saved.reason,
+            type: "wait",
+            shouldRehydrate: saved.shouldRehydrate,
+            waitPlan: saved.waitPlan,
+        };
+        return;
+    }
+    if (state.interruptedCronTimer && state.interruptedCronTimer.remainingMs > 0) {
+        const saved = state.interruptedCronTimer;
+        state.interruptedCronTimer = null;
+        const remainingMs = Math.max(0, saved.remainingMs);
+        const remainingSec = Math.max(1, Math.round(remainingMs / 1000));
+        ctx.traceInfo(`[orch] auto-resuming interrupted cron: ${remainingSec}s remain (${saved.reason})`);
+        const cronResumePlan = planWaitHandling({
+            blobEnabled: state.blobEnabled,
+            seconds: remainingSec,
+            dehydrateThreshold: options.dehydrateThreshold,
+        });
+        if (cronResumePlan.shouldDehydrate) {
+            yield* dehydrateForNextTurn(runtime, "cron", cronResumePlan.resetAffinityOnDehydrate);
+        }
+        const resumeNow = yield ctx.utcNow();
+        publishStatus(runtime, "waiting", {
+            waitSeconds: remainingSec,
+            waitReason: saved.reason,
+            waitStartedAt: resumeNow,
+        });
+        if (!cronResumePlan.shouldDehydrate)
+            yield* maybeCheckpoint(runtime);
+        state.activeTimer = {
+            deadlineMs: resumeNow + remainingMs,
+            originalDurationMs: remainingMs,
+            reason: saved.reason,
+            type: "cron",
+            shouldRehydrate: cronResumePlan.shouldDehydrate,
+        };
+        return;
+    }
+    if (state.cronSchedule) {
+        const activeCron = { ...state.cronSchedule };
+        const cronPlan = planWaitHandling({
+            blobEnabled: state.blobEnabled,
+            seconds: activeCron.intervalSeconds,
+            dehydrateThreshold: options.dehydrateThreshold,
+        });
+        if (cronPlan.shouldDehydrate) {
+            yield* dehydrateForNextTurn(runtime, "cron", cronPlan.resetAffinityOnDehydrate);
+        }
+        yield runtime.manager.recordSessionEvent(runtime.input.sessionId, [{
+                eventType: "session.cron_started",
+                data: { intervalSeconds: activeCron.intervalSeconds, reason: activeCron.reason },
+            }]);
+        const cronStartedAt = yield ctx.utcNow();
+        ctx.traceInfo(`[orch] cron timer: ${activeCron.intervalSeconds}s (${activeCron.reason})`);
+        publishStatus(runtime, "waiting", {
+            waitSeconds: activeCron.intervalSeconds,
+            waitReason: activeCron.reason,
+            waitStartedAt: cronStartedAt,
+        });
+        if (!cronPlan.shouldDehydrate)
+            yield* maybeCheckpoint(runtime);
+        state.activeTimer = {
+            deadlineMs: cronStartedAt + activeCron.intervalSeconds * 1000,
+            originalDurationMs: activeCron.intervalSeconds * 1000,
+            reason: activeCron.reason,
+            type: "cron",
+            shouldRehydrate: cronPlan.shouldDehydrate,
+        };
+        return;
+    }
+    if (state.cronAtSchedule) {
+        const activeCronAt = { ...state.cronAtSchedule };
+        if (activeCronAt.maxFires !== undefined && activeCronAt.firesCompleted >= activeCronAt.maxFires) {
+            state.cronAtSchedule = undefined;
+            yield runtime.manager.recordSessionEvent(runtime.input.sessionId, [{
+                    eventType: "session.cron_at_completed",
+                    data: { reason: activeCronAt.reason, firesCompleted: activeCronAt.firesCompleted, maxFires: activeCronAt.maxFires },
+                }]);
+            return;
+        }
+        const nowMs = yield ctx.utcNow();
+        let nextFireAtMs = activeCronAt.nextFireAtMs;
+        let nextOccurrenceKey = activeCronAt.nextOccurrenceKey;
+        if (!nextFireAtMs || !nextOccurrenceKey) {
+            const nextFire = yield runtime.manager.computeCronAtNextFire(activeCronAt, nowMs, activeCronAt.lastOccurrenceKey);
+            nextFireAtMs = nextFire.nextFireAtMs;
+            nextOccurrenceKey = nextFire.occurrenceKey;
+            state.cronAtSchedule = {
+                ...activeCronAt,
+                nextFireAtMs,
+                nextOccurrenceKey,
+            };
+        }
+        if (nextFireAtMs === undefined || !nextOccurrenceKey) {
+            throw new Error("cron_at next-fire computation did not return a fire time");
+        }
+        const waitMs = Math.max(0, nextFireAtMs - nowMs);
+        const waitSeconds = Math.max(0, Math.ceil(waitMs / 1000));
+        const cronAtPlan = planWaitHandling({
+            blobEnabled: state.blobEnabled,
+            seconds: waitSeconds,
+            dehydrateThreshold: options.dehydrateThreshold,
+        });
+        if (cronAtPlan.shouldDehydrate) {
+            yield* dehydrateForNextTurn(runtime, "cron_at", cronAtPlan.resetAffinityOnDehydrate);
+        }
+        yield runtime.manager.recordSessionEvent(runtime.input.sessionId, [{
+                eventType: "session.cron_at_started",
+                data: {
+                    ...state.cronAtSchedule,
+                    nextFireAt: new Date(nextFireAtMs).toISOString(),
+                },
+            }]);
+        publishStatus(runtime, "waiting", {
+            waitSeconds,
+            waitReason: activeCronAt.reason,
+            waitStartedAt: nowMs,
+        });
+        if (!cronAtPlan.shouldDehydrate)
+            yield* maybeCheckpoint(runtime);
+        state.activeTimer = {
+            deadlineMs: nowMs + waitMs,
+            originalDurationMs: waitMs,
+            reason: activeCronAt.reason,
+            type: "cron_at",
+            shouldRehydrate: cronAtPlan.shouldDehydrate,
+        };
+        return;
+    }
+    if (!state.blobEnabled || options.idleTimeout < 0) {
+        yield* maybeCheckpoint(runtime);
+        return;
+    }
+    publishStatus(runtime, "idle");
+    yield* maybeCheckpoint(runtime);
+    const idleNow = yield ctx.utcNow();
+    state.activeTimer = {
+        deadlineMs: idleNow + options.idleTimeout * 1000,
+        originalDurationMs: options.idleTimeout * 1000,
+        reason: "idle timeout",
+        type: "idle",
+    };
+}
 // ─── handleTurnResult: dispatch on TurnResult variant ───────
 function coerceChildQuestionToWait(runtime, result) {
     if (result.type === "completed"
@@ -315,6 +656,13 @@ export function* handleTurnResult(runtime, result, sourcePrompt, cycleOrigin) {
                 content: result.content,
                 model: result.model,
             });
+            if (result.forceContinuePrompt) {
+                ctx.traceInfo(`[orch] continuing after terminal model switch failure`);
+                yield* versionedContinueAsNew(runtime, continueInputWithPrompt(runtime, result.forceContinuePrompt, {
+                    bootstrapPrompt: true,
+                }));
+                return;
+            }
             if (options.parentSessionId) {
                 const cycleReport = result.cycleReport;
                 const cycleMaterial = cycleReport?.status === "material" || cycleReport?.status === "blocked"
@@ -372,166 +720,7 @@ export function* handleTurnResult(runtime, result, sourcePrompt, cycleOrigin) {
                     return;
                 }
             }
-            if (state.interruptedWaitTimer && state.interruptedWaitTimer.remainingSec > 0) {
-                const saved = state.interruptedWaitTimer;
-                state.interruptedWaitTimer = null;
-                ctx.traceInfo(`[orch] auto-resuming interrupted wait: ${saved.remainingSec}s (${saved.reason})`);
-                if (saved.shouldRehydrate) {
-                    yield* dehydrateForNextTurn(runtime, "timer", saved.waitPlan?.resetAffinityOnDehydrate ?? true);
-                }
-                const resumeNow = yield ctx.utcNow();
-                publishStatus(runtime, "waiting", {
-                    waitSeconds: saved.remainingSec,
-                    waitReason: saved.reason,
-                    waitStartedAt: resumeNow,
-                });
-                if (!saved.shouldRehydrate)
-                    yield* maybeCheckpoint(runtime);
-                state.activeTimer = {
-                    deadlineMs: resumeNow + saved.remainingSec * 1000,
-                    originalDurationMs: saved.remainingSec * 1000,
-                    reason: saved.reason,
-                    type: "wait",
-                    shouldRehydrate: saved.shouldRehydrate,
-                    waitPlan: saved.waitPlan,
-                };
-                return;
-            }
-            if (state.interruptedCronTimer && state.interruptedCronTimer.remainingMs > 0) {
-                const saved = state.interruptedCronTimer;
-                state.interruptedCronTimer = null;
-                const remainingMs = Math.max(0, saved.remainingMs);
-                const remainingSec = Math.max(1, Math.round(remainingMs / 1000));
-                ctx.traceInfo(`[orch] auto-resuming interrupted cron: ${remainingSec}s remain (${saved.reason})`);
-                const cronResumePlan = planWaitHandling({
-                    blobEnabled: state.blobEnabled,
-                    seconds: remainingSec,
-                    dehydrateThreshold: options.dehydrateThreshold,
-                });
-                if (cronResumePlan.shouldDehydrate) {
-                    yield* dehydrateForNextTurn(runtime, "cron", cronResumePlan.resetAffinityOnDehydrate);
-                }
-                const resumeNow = yield ctx.utcNow();
-                publishStatus(runtime, "waiting", {
-                    waitSeconds: remainingSec,
-                    waitReason: saved.reason,
-                    waitStartedAt: resumeNow,
-                });
-                if (!cronResumePlan.shouldDehydrate)
-                    yield* maybeCheckpoint(runtime);
-                state.activeTimer = {
-                    deadlineMs: resumeNow + remainingMs,
-                    originalDurationMs: remainingMs,
-                    reason: saved.reason,
-                    type: "cron",
-                    shouldRehydrate: cronResumePlan.shouldDehydrate,
-                };
-                return;
-            }
-            if (state.cronSchedule) {
-                const activeCron = { ...state.cronSchedule };
-                const cronPlan = planWaitHandling({
-                    blobEnabled: state.blobEnabled,
-                    seconds: activeCron.intervalSeconds,
-                    dehydrateThreshold: options.dehydrateThreshold,
-                });
-                if (cronPlan.shouldDehydrate) {
-                    yield* dehydrateForNextTurn(runtime, "cron", cronPlan.resetAffinityOnDehydrate);
-                }
-                yield runtime.manager.recordSessionEvent(runtime.input.sessionId, [{
-                        eventType: "session.cron_started",
-                        data: { intervalSeconds: activeCron.intervalSeconds, reason: activeCron.reason },
-                    }]);
-                const cronStartedAt = yield ctx.utcNow();
-                ctx.traceInfo(`[orch] cron timer: ${activeCron.intervalSeconds}s (${activeCron.reason})`);
-                publishStatus(runtime, "waiting", {
-                    waitSeconds: activeCron.intervalSeconds,
-                    waitReason: activeCron.reason,
-                    waitStartedAt: cronStartedAt,
-                });
-                if (!cronPlan.shouldDehydrate)
-                    yield* maybeCheckpoint(runtime);
-                state.activeTimer = {
-                    deadlineMs: cronStartedAt + activeCron.intervalSeconds * 1000,
-                    originalDurationMs: activeCron.intervalSeconds * 1000,
-                    reason: activeCron.reason,
-                    type: "cron",
-                    shouldRehydrate: cronPlan.shouldDehydrate,
-                };
-                return;
-            }
-            if (state.cronAtSchedule) {
-                const activeCronAt = { ...state.cronAtSchedule };
-                if (activeCronAt.maxFires !== undefined && activeCronAt.firesCompleted >= activeCronAt.maxFires) {
-                    state.cronAtSchedule = undefined;
-                    yield runtime.manager.recordSessionEvent(runtime.input.sessionId, [{
-                            eventType: "session.cron_at_completed",
-                            data: { reason: activeCronAt.reason, firesCompleted: activeCronAt.firesCompleted, maxFires: activeCronAt.maxFires },
-                        }]);
-                    return;
-                }
-                const nowMs = yield ctx.utcNow();
-                let nextFireAtMs = activeCronAt.nextFireAtMs;
-                let nextOccurrenceKey = activeCronAt.nextOccurrenceKey;
-                if (!nextFireAtMs || !nextOccurrenceKey) {
-                    const nextFire = yield runtime.manager.computeCronAtNextFire(activeCronAt, nowMs, activeCronAt.lastOccurrenceKey);
-                    nextFireAtMs = nextFire.nextFireAtMs;
-                    nextOccurrenceKey = nextFire.occurrenceKey;
-                    state.cronAtSchedule = {
-                        ...activeCronAt,
-                        nextFireAtMs,
-                        nextOccurrenceKey,
-                    };
-                }
-                if (nextFireAtMs === undefined || !nextOccurrenceKey) {
-                    throw new Error("cron_at next-fire computation did not return a fire time");
-                }
-                const waitMs = Math.max(0, nextFireAtMs - nowMs);
-                const waitSeconds = Math.max(0, Math.ceil(waitMs / 1000));
-                const cronAtPlan = planWaitHandling({
-                    blobEnabled: state.blobEnabled,
-                    seconds: waitSeconds,
-                    dehydrateThreshold: options.dehydrateThreshold,
-                });
-                if (cronAtPlan.shouldDehydrate) {
-                    yield* dehydrateForNextTurn(runtime, "cron_at", cronAtPlan.resetAffinityOnDehydrate);
-                }
-                yield runtime.manager.recordSessionEvent(runtime.input.sessionId, [{
-                        eventType: "session.cron_at_started",
-                        data: {
-                            ...state.cronAtSchedule,
-                            nextFireAt: new Date(nextFireAtMs).toISOString(),
-                        },
-                    }]);
-                publishStatus(runtime, "waiting", {
-                    waitSeconds,
-                    waitReason: activeCronAt.reason,
-                    waitStartedAt: nowMs,
-                });
-                if (!cronAtPlan.shouldDehydrate)
-                    yield* maybeCheckpoint(runtime);
-                state.activeTimer = {
-                    deadlineMs: nowMs + waitMs,
-                    originalDurationMs: waitMs,
-                    reason: activeCronAt.reason,
-                    type: "cron_at",
-                    shouldRehydrate: cronAtPlan.shouldDehydrate,
-                };
-                return;
-            }
-            if (!state.blobEnabled || options.idleTimeout < 0) {
-                yield* maybeCheckpoint(runtime);
-                return;
-            }
-            publishStatus(runtime, "idle");
-            yield* maybeCheckpoint(runtime);
-            const idleNow = yield ctx.utcNow();
-            state.activeTimer = {
-                deadlineMs: idleNow + options.idleTimeout * 1000,
-                originalDurationMs: options.idleTimeout * 1000,
-                reason: "idle timeout",
-                type: "idle",
-            };
+            yield* schedulePostTurnContinuation(runtime);
             return;
         }
         case "cron":
@@ -651,6 +840,26 @@ export function* handleTurnResult(runtime, result, sourcePrompt, cycleOrigin) {
         case "cancelled":
             ctx.traceInfo("[session] turn cancelled");
             return;
+        case "stopped": {
+            // Defensive: a turn only classifies "stopped" when the stop marker
+            // was set, which normally means handleTurnStopped already ran via
+            // the race. Handle it anyway so a marker-set turn that somehow
+            // returns through the normal path still lands idle with the event
+            // trail (processPrompt already incremented state.iteration).
+            ctx.traceInfo("[session] turn reported stopped");
+            state.retryCount = 0;
+            yield runtime.manager.recordSessionEvent(runtime.input.sessionId, [{
+                    eventType: "session.turn_stopped",
+                    data: {
+                        reason: result.reason ?? "Stopped by user",
+                        turnIndex: state.iteration - 1,
+                        interrupt: "turn-result",
+                    },
+                }]);
+            yield runtime.manager.updateCmsState(runtime.input.sessionId, "idle");
+            yield* schedulePostTurnContinuation(runtime);
+            return;
+        }
         case "spawn_agent":
         case "message_agent":
         case "check_agents":
@@ -715,7 +924,7 @@ export function* processTimer(runtime, timerItem) {
                     data: {},
                 }]);
             const activeCron = state.cronSchedule;
-            const cycleReportGuidance = "If this cycle finds material changes or blockers that should wake your parent, call report_cycle(status='material' or status='blocked', summary='...') before finishing. If nothing material changed, omit report_cycle or call report_cycle(status='quiet').";
+            const cycleReportGuidance = "If this cycle finds material changes or blockers that should wake your parent, call report_cycle(status='material' or status='blocked', summary='...') before finishing. If nothing material changed, do NOT call report_cycle at all — just end the turn silently. Do not emit report_cycle(status='quiet') on an uneventful cycle, and never write a tool call as text.";
             const cronPrompt = `[SYSTEM: Scheduled cron wake-up for: "${activeCron.reason}". Resume your recurring task. ${cycleReportGuidance}]`;
             if (timer.shouldRehydrate) {
                 yield* processPrompt(runtime, wrapWithResumeContext(runtime, "Resume your recurring task.", `Scheduled cron wake-up for: "${activeCron.reason}". ${cycleReportGuidance}`), true, undefined, undefined, "cron");
@@ -766,12 +975,14 @@ export function* processTimer(runtime, timerItem) {
                 `Schedule: ${description}. Scheduled fire: ${new Date(scheduledAtMs).toISOString()}. ` +
                 `Resume your recurring task now. ` +
                 `If this cycle finds material changes or blockers that should wake your parent, call report_cycle(status='material' or status='blocked', summary='...') before finishing. ` +
-                `If nothing material changed, omit report_cycle or call report_cycle(status='quiet').]`;
+                `If nothing material changed, do NOT call report_cycle at all — just end the turn silently. ` +
+                `Do not emit report_cycle(status='quiet') on an uneventful cycle, and never write a tool call as text.]`;
             if (timer.shouldRehydrate) {
                 yield* processPrompt(runtime, wrapWithResumeContext(runtime, "Resume your recurring task.", `Scheduled wall-clock cron wake-up for "${activeCronAt.reason}". ` +
                     `Schedule: ${description}. Scheduled fire: ${new Date(scheduledAtMs).toISOString()}. ` +
                     `If this cycle finds material changes or blockers that should wake your parent, call report_cycle(status='material' or status='blocked', summary='...') before finishing. ` +
-                    `If nothing material changed, omit report_cycle or call report_cycle(status='quiet').`), true, undefined, undefined, "cron_at");
+                    `If nothing material changed, do NOT call report_cycle at all — just end the turn silently. ` +
+                    `Do not emit report_cycle(status='quiet') on an uneventful cycle, and never write a tool call as text.`), true, undefined, undefined, "cron_at");
             }
             else {
                 yield* processPrompt(runtime, cronAtPrompt, true, undefined, undefined, "cron_at");