@aexol/spectral 0.9.250 → 0.9.254

package/dist/server/session-stream.js

@@ -40,11 +40,10 @@ import { randomUUID } from "node:crypto";
 import { AgentBridge } from "./agent-bridge.js";
 import { formatAttachmentAnnotation, persistAttachments, attachmentsRootFor, } from "./attachments/persist.js";
 import { sweepAttachments } from "./attachments/cleanup.js";
-import { expandIfPresetReference, expandPresetPrompt, parsePresetReference, PRESET_CHAIN_BUDGET, resolvePresetByName, } from "./preset-chain.js";
+import { expandIfPresetReference, parsePresetReference, PRESET_CHAIN_BUDGET, resolvePresetByName, } from "./preset-chain.js";
 import { InterAgentBroker } from "./inter-agent-broker.js";
 import { setInterAgentBroker } from "../memory/inter-agent-broker-singleton.js";
 import { configureFanout } from "./fanout/fanout-manager.js";
-import { getAutoOlderHistoryContextThresholdTokens } from "../sdk/coding-agent/core/compaction/policy.js";
 import { getMemoryState, rawTokensSinceLastBound, rawTokensSinceLastCompaction, } from "../memory/branch.js";
 import { observationPoolTokens, renderSummary } from "../memory/compaction.js";
 import { loadConfig } from "../memory/config.js";
@@ -58,7 +57,7 @@ import { parseImagesJson } from "./image-attachments.js";
 // unchanged).
 import { formatCompactionTokenStats, isSkippedCompactionResult, } from "./session-stream/compaction-events.js";
 import { getCompactionEndPruneSkipReason, prunePersistedHistoryAfterCompaction, } from "./session-stream/history-prune.js";
-import { applyDcpLiteRuntimeStatus, dcpLiteEventFromServerEvent, defaultMemoryStatus, loadCompactionPolicy, persistObservationalMemorySnapshot, } from "./session-stream/memory.js";
+import { applyDcpLiteRuntimeStatus, dcpLiteEventFromServerEvent, defaultMemoryStatus, persistObservationalMemorySnapshot, } from "./session-stream/memory.js";
 import { selectHistoryForBridge } from "./session-stream/replay-tail.js";
 import { assistantMessageIdsForTurn, extractCreditsFromEventsJsonl, extractMessageMetricsFromEventsJsonl, isReplayable, snapshotTurn, } from "./session-stream/turn-events.js";
 import { resolveTurnSilenceMaxRearm, resolveTurnSilenceTimeoutMs, } from "./session-stream/turn-silence.js";
@@ -69,14 +68,12 @@ export { estimateStoredMessageReplayTokens, selectHistoryForBridge, } from "./se
 export { assistantMessageIdsForTurn, extractCreditsFromEventsJsonl, extractMessageMetricsFromEventsJsonl, isReplayable, snapshotTurn, } from "./session-stream/turn-events.js";
 export { resolveTurnSilenceMaxRearm, resolveTurnSilenceTimeoutMs, } from "./session-stream/turn-silence.js";
 const DEFAULT_BRIDGE_FACTORY = (args) => new AgentBridge(args);
-/** Safety limit for autonomous loop iterations per session. */
-const MAX_LOOP_ITERATIONS = 100;
 // Streaming-meaningful events that reset the silence timer while a turn is
 // active. Mirrors Fix C on the landing side, but EXCLUDES `token_usage`
 // (arrives post-turn) and excludes terminal/control events handled by their
 // own branches (`agent_end`, `error`) and non-streaming side channels
 // (`inter_agent_observation`, `agent_notification`, `queue_changed`,
-// `session_renamed`, `interval_*`, `loop_*`, `compaction_*`).
+// `session_renamed`, `interval_*`, `compaction_*`).
 const STREAMING_MEANINGFUL_EVENT_TYPES = new Set([
     "message_start",
     "text_delta",
@@ -107,8 +104,6 @@ const UI_HISTORY_TAIL_MESSAGE_LIMIT = 60;
  * at most the last `BATCH_FLUSH_INTERVAL` events, not the entire turn.
  */
 const BATCH_FLUSH_INTERVAL = 10;
-/** Marker the agent emits in its response to signal the task is complete. */
-const LOOP_DONE_MARKER = "<LOOP_DONE>";
 export class SessionStreamManager {
     store;
     cwd;
@@ -302,8 +297,6 @@ export class SessionStreamManager {
             intervalMinutes: stream.intervalMinutes,
             intervalNextTickAt: stream.intervalNextTickAt,
             intervalLaunchCount: stream.intervalLaunchCount,
-            intervalHasLoop: stream.intervalConfig?.loop ?? false,
-            intervalGoal: stream.intervalConfig?.loopGoal ?? null,
         };
     }
     /**
@@ -348,7 +341,7 @@ export class SessionStreamManager {
     }
     /**
      * Set of session IDs with active agent work (streaming, retrying,
-     * compacting, looping, or a pending continuation). Superset of
+     * compacting, or a pending continuation). Superset of
      * `getActiveTurnSessionIds`; used by REST list enrichment.
      */
     getBusySessionIds() {
@@ -379,7 +372,7 @@ export class SessionStreamManager {
      * session so enabling/disabling a native extension takes effect without
      * restarting the session or waiting for a new session to be created.
      *
-     * Busy sessions (in-flight turn, compaction, loop, pending continuation,
+     * Busy sessions (in-flight turn, compaction, pending continuation,
      * or a `prompt()` dispatch in progress) are SKIPPED, never queued: the
      * reload swaps the tool registry / extension runner underneath the
      * running turn, so a dispatched tool can resolve against a torn-down
@@ -452,7 +445,7 @@ export class SessionStreamManager {
     /**
      * True when an extension hot-reload must not touch this stream right now:
      * a turn is in flight, a `prompt()` dispatch is in progress (R1), or the
-     * session is otherwise busy (compaction, loop, pending continuation).
+     * session is otherwise busy (compaction, pending continuation).
      */
     isReloadBlocked(stream) {
         return (stream.currentTurn !== null ||
@@ -977,9 +970,11 @@ export class SessionStreamManager {
         // emitted an `error` wire event and we drop the prompt rather than
         // recording a user message we know we won't be able to respond to.
         //
-        // Persistence: only the envelope-supplied value is written back. A
-        // recovery-only application (case b) doesn't update the row — the
-        // value is already there.
+        // Persistence: the model actually applied by the bridge is written
+        // back — normally identical to `effectiveModelId`, but the applied
+        // (fallback) id wins when `setModel()` substituted one for a stale
+        // model. A recovery-only application (case b) rewrites the same value
+        // that is already there.
         const effectiveModelId = modelId ??
             this.store.getSessionModel(sessionId) ??
             stream.bridge.getFirstAvailableModelId?.();
@@ -994,7 +989,11 @@ export class SessionStreamManager {
         }
         if (effectiveModelId) {
             try {
-                this.store.setSessionModel(sessionId, effectiveModelId);
+                // Persist the model actually in effect: when `setModel()` substituted
+                // a fallback for a stale requested modelId, the bridge reports the
+                // applied id and it wins over the requested one.
+                const appliedModelId = stream.bridge.getLastAppliedModelId?.() ?? effectiveModelId;
+                this.store.setSessionModel(sessionId, appliedModelId);
             }
             catch (err) {
                 // Persisting the sticky model is best-effort: the live turn will
@@ -1099,7 +1098,7 @@ export class SessionStreamManager {
         // that ended without a matching `subagent_end`.
         this.resetSubagentTracking(stream);
         // New logical run. This is the only place `busy` transitions
-        // false -> true (loop iterations and auto-dequeue also go through
+        // false -> true (auto-dequeue also goes through
         // `prompt()`). Retries/continuations do NOT bump the generation.
         stream.runState = {
             runId: randomUUID(),
@@ -1110,7 +1109,6 @@ export class SessionStreamManager {
                 streaming: true,
                 retrying: false,
                 compacting: false,
-                looping: false,
                 queued: false,
             },
         };
@@ -1142,7 +1140,6 @@ export class SessionStreamManager {
         this.disposed = true;
         this.unsubscribeDevProcessEvents?.();
         for (const stream of this.streams.values()) {
-            stream.loopActive = false;
             stream.pendingContinue = false;
             this.clearIntervalTimer(stream);
             // Fix E: drop any in-flight safety-net timers on teardown.
@@ -1197,12 +1194,6 @@ export class SessionStreamManager {
         const stream = this.streams.get(sessionId);
         if (!stream)
             return;
-        // Stop any active loop before disposing — if the loop was mid-iteration
-        // the next agent_end would otherwise trigger another prompt.
-        stream.loopActive = false;
-        stream.loopOriginalPrompt = null;
-        stream.loopGoal = null;
-        stream.loopIterationCount = 0;
         this.clearIntervalTimer(stream);
         stream.intervalMinutes = null;
         stream.intervalConfig = null;
@@ -1229,8 +1220,7 @@ export class SessionStreamManager {
         catch {
             // ignore
         }
-        // Set startError so any late `await stream.ready` in the loop path
-        // (if the loop was between iterations when we disposed) rejects cleanly
+        // Set startError so any late `await stream.ready` rejects cleanly
         // instead of hanging. Also prevents the next prompt() from waiting on
         // a dead bridge's ready promise.
         stream.startError = new Error("Turn cancelled");
@@ -1303,7 +1293,6 @@ export class SessionStreamManager {
         const stream = this.streams.get(sessionId);
         if (!stream)
             return;
-        stream.loopActive = false;
         stream.pendingContinue = false;
         this.clearIntervalTimer(stream);
         stream.intervalMinutes = null;
@@ -1346,82 +1335,6 @@ export class SessionStreamManager {
             this.disposeSessionStream(sid);
         }
     }
-    /**
-     * Set the autonomous iterative loop state for a session.
-     *
-     * When `active` is true, the manager replays `originalPrompt` after each
-     * `agent_end` event — the agent sees its own file changes from prior
-     * iterations and iteratively improves its solution (Ralph Wiggum pattern).
-     * The loop stops when the agent emits `<LOOP_DONE>` in its response or the
-     * safety iteration limit is reached.
-     */
-    setLoopActive(sessionId, active, originalPrompt, maxIterations, goal) {
-        const stream = this.streams.get(sessionId);
-        if (!stream)
-            return;
-        // Bump the epoch on EVERY call (arm and disarm alike) so the async
-        // "@preset:" arming tail can detect loop-state changes that happen
-        // while its resolver is awaited (see armLoopWithExpandedPreset).
-        stream.loopGeneration += 1;
-        if (!active) {
-            stream.loopActive = false;
-            stream.loopOriginalPrompt = null;
-            stream.loopIterationCount = 0;
-            stream.loopMaxIterations = MAX_LOOP_ITERATIONS;
-            stream.loopGoal = null;
-            return;
-        }
-        const raw = originalPrompt ?? null;
-        // Expand a leading "@preset:<name>" reference ONCE, at arming time, so
-        // every loop iteration replays the resolved prompt instead of the
-        // literal reference (which would re-expand — and re-chain — each turn).
-        // Non-reference prompts arm synchronously exactly as before; only the
-        // reference path defers through the resolver (raw prompt on failure).
-        if (!raw || !parsePresetReference(raw)) {
-            stream.loopActive = true;
-            stream.loopOriginalPrompt = raw;
-            if (maxIterations !== undefined && maxIterations > 0) {
-                stream.loopMaxIterations = Math.min(maxIterations, MAX_LOOP_ITERATIONS);
-            }
-            stream.loopGoal = goal?.trim() || null;
-            return;
-        }
-        return this.armLoopWithExpandedPreset(sessionId, raw, maxIterations, goal);
-    }
-    /**
-     * Async tail of {@link setLoopActive} for "@preset:<name>" loop prompts:
-     * resolves the preset, then arms the loop with the expanded prompt (raw
-     * content when the resolver fails). The chain budget is NOT consumed by
-     * loop arming — expansion happens once here, not on every iteration.
-     *
-     * Returns the expanded prompt so the caller (dispatcher, interval tick)
-     * can fire the FIRST turn with the resolved content instead of the raw
-     * reference. Resolves to `null` when arming was aborted because loop
-     * state changed while the resolver was awaited (the write is skipped so
-     * newer loop state is never clobbered) or when no stream exists.
-     */
-    async armLoopWithExpandedPreset(sessionId, prompt, maxIterations, goal) {
-        const stream = this.streams.get(sessionId);
-        if (!stream)
-            return null;
-        // Capture the epoch BEFORE the resolver await: any other setLoopActive
-        // call during the await (e.g. a loop stop from a client message) moves
-        // the generation and must win over this arming write.
-        const generation = stream.loopGeneration;
-        const expanded = await expandPresetPrompt(prompt, (name) => this.resolvePresetForSession(sessionId, name));
-        if (stream.loopGeneration !== generation) {
-            console.log(`[session-stream] ${sessionId}: loop arming aborted — ` +
-                `loop state changed while the preset was being resolved`);
-            return null;
-        }
-        stream.loopActive = true;
-        stream.loopOriginalPrompt = expanded;
-        if (maxIterations !== undefined && maxIterations > 0) {
-            stream.loopMaxIterations = Math.min(maxIterations, MAX_LOOP_ITERATIONS);
-        }
-        stream.loopGoal = goal?.trim() || null;
-        return expanded;
-    }
     /**
      * Studio team id used for machine-JWT backend calls (preset resolution):
      * the project's team binding wins over the machine default.
@@ -1451,12 +1364,9 @@ export class SessionStreamManager {
         stream.intervalConfig = config;
         stream.intervalLaunchCount = 0;
         this.scheduleIntervalTick(stream, minutes);
-        const interval = this.getIntervalEventSnapshot(stream);
         this.broadcast(stream, {
             type: "interval_armed",
-            intervalMinutes: interval.intervalMinutes ?? minutes,
-            hasLoop: interval.hasLoop,
-            goal: interval.goal,
+            intervalMinutes: minutes,
         });
     }
     /**
@@ -1501,8 +1411,6 @@ export class SessionStreamManager {
         return {
             intervalMinutes: stream.intervalMinutes,
             nextTickAt: stream.intervalNextTickAt,
-            hasLoop: stream.intervalConfig?.loop ?? false,
-            goal: stream.intervalConfig?.loopGoal ?? null,
             occurrence: stream.intervalLaunchCount,
         };
     }
@@ -1511,7 +1419,7 @@ export class SessionStreamManager {
         stream.intervalNextTickAt = Date.now() + minutes * 60_000;
         stream.intervalTimer = setInterval(() => {
             // intervalTick is async and may reject (e.g. a sync throw from
-            // teamIdForSession inside the loop-arming resolver): without a
+            // prompt()): without a
             // handler a timer callback rejection would be unhandled.
             this.intervalTick(stream).catch((err) => {
                 const msg = err instanceof Error ? err.message : String(err);
@@ -1632,10 +1540,9 @@ export class SessionStreamManager {
     async intervalTick(stream) {
         if (!stream.intervalConfig)
             return;
-        const idle = !stream.loopActive && stream.currentTurn === null &&
+        const idle = stream.currentTurn === null &&
             !stream.compacting && !stream.expandingQueueItem;
         if (!idle) {
-            const interval = this.getIntervalEventSnapshot(stream);
             this.broadcast(stream, {
                 type: "interval_skipped",
                 reason: "busy",
@@ -1649,18 +1556,7 @@ export class SessionStreamManager {
             occurrence: interval.occurrence,
         });
         const cfg = stream.intervalConfig;
-        let launchPrompt = cfg.prompt;
-        if (cfg.loop) {
-            // Await so a "@preset:" prompt is expanded before the turn fires.
-            const expanded = await this.setLoopActive(stream.sessionId, true, cfg.prompt, cfg.loopMaxIterations, cfg.loopGoal);
-            // Same raw-reference fix as the dispatcher path: the first interval
-            // launch must run the expanded prompt, not the literal "@preset:X"
-            // (null = arming aborted → fall back to the raw prompt).
-            if (typeof expanded === "string" && expanded) {
-                launchPrompt = expanded;
-            }
-        }
-        this.prompt(stream.sessionId, launchPrompt, cfg.modelId, cfg.images, cfg.reasoningEffort).catch((err) => {
+        this.prompt(stream.sessionId, cfg.prompt, cfg.modelId, cfg.images, cfg.reasoningEffort).catch((err) => {
             console.error(`[interval] launch failed: ${err instanceof Error ? err.message : String(err)}`);
         });
     }
@@ -1707,55 +1603,6 @@ export class SessionStreamManager {
             });
         });
     }
-    /** Build the next autonomous-loop prompt after optional policy-driven compaction. */
-    buildLoopPrompt(stream) {
-        const parts = [];
-        if (stream.loopGoal) {
-            parts.push(`[GOAL]: ${stream.loopGoal}`);
-        }
-        parts.push(stream.loopOriginalPrompt);
-        parts.push("");
-        parts.push("--- LOOP INSTRUCTIONS ---\n" +
-            "You are running in an iterative loop. Each iteration you see your previous changes\n" +
-            "and can improve them further.\n" +
-            (stream.loopGoal
-                ? "The [GOAL] above defines what you need to achieve.\n"
-                : "\n") +
-            "CRITICAL: After EVERY response you MUST self-evaluate:\n" +
-            "- If the task IS FULLY COMPLETE (nothing meaningful left to do), " +
-            "respond with <LOOP_DONE> as the VERY FIRST text in your reply,\n" +
-            "  followed by a brief summary of what was accomplished.\n" +
-            "- If more work remains, continue working WITHOUT <LOOP_DONE>.\n" +
-            "- <LOOP_DONE> is the ONLY way to stop the loop. If you do not emit it,\n" +
-            "  you WILL be prompted again to keep working.\n" +
-            "Be decisive: if the task is done, stop. Do not keep polishing.");
-        return parts.join("\n");
-    }
-    async sendNextLoopIteration(stream) {
-        const policy = loadCompactionPolicy(stream.cwd);
-        const loopThresholdTokens = getAutoOlderHistoryContextThresholdTokens(policy, stream.contextWindowMax);
-        const contextWindowUsed = stream.contextWindowUsed;
-        const shouldCompact = loopThresholdTokens !== null &&
-            typeof contextWindowUsed === "number" &&
-            contextWindowUsed >= loopThresholdTokens;
-        if (shouldCompact) {
-            console.log(`[loop] compacting context (~${contextWindowUsed.toLocaleString()} tokens >= ` +
-                `${loopThresholdTokens.toLocaleString()} policy threshold)`);
-            const outcome = await this.requestManagerCompaction(stream, {
-                source: "loop",
-            });
-            if (outcome.status === "completed") {
-                console.log("[loop] compaction complete, sending next iteration");
-            }
-            else if (outcome.status === "skipped") {
-                console.log(`[loop] compaction skipped (${outcome.reason}), proceeding`);
-            }
-            else {
-                console.error(`[loop] compaction failed: ${outcome.error.message}`);
-            }
-        }
-        await this.prompt(stream.sessionId, this.buildLoopPrompt(stream), undefined);
-    }
     // --- internals ----------------------------------------------------------
     createStream(sessionId, history) {
         // Resolve cwd from the owning project. Sessions without a project
@@ -1793,7 +1640,6 @@ export class SessionStreamManager {
                     streaming: false,
                     retrying: false,
                     compacting: false,
-                    looping: false,
                     queued: false,
                 },
             },
@@ -1802,14 +1648,8 @@ export class SessionStreamManager {
             currentTurnSilenceTimer: null,
             currentMessageId: null,
             lastFlushedEventCount: 0,
-            loopActive: false,
-            loopIterationCount: 0,
-            loopOriginalPrompt: null,
-            loopMaxIterations: MAX_LOOP_ITERATIONS,
-            loopGoal: null,
             presetChainBudget: PRESET_CHAIN_BUDGET,
             expandingQueueItem: false,
-            loopGeneration: 0,
             intervalMinutes: null,
             intervalTimer: null,
             intervalNextTickAt: null,
@@ -2036,7 +1876,7 @@ export class SessionStreamManager {
             // row; observed in the wild: a single row with 12 full message cycles,
             // 67MB events_jsonl, content = sum of all cycles' texts). Earlier
             // cycles are already persisted in their own rows; turn-level text is
-            // kept separately in `turnAssistantText` for the loop-done marker.
+            // kept separately in `turnAssistantText`.
             if (event.type === "message_start") {
                 stream.currentTurn.events = [];
                 stream.currentTurn.assistantText = "";
@@ -2283,66 +2123,6 @@ export class SessionStreamManager {
             // compact-and-retry). The deferred settle below re-resolves the final
             // state once the SDK is truly settled.
             stream.pendingContinue = event.willRetry === true;
-            // Autonomous iterative loop (Ralph Wiggum pattern).
-            // When loopActive is set, check for completion marker, then re-send
-            // the ORIGINAL prompt so the agent sees its prior changes and
-            // iteratively improves the solution.
-            if (stream.loopActive && stream.loopOriginalPrompt) {
-                // Use the turn-level accumulator: `assistantText` is rotated per
-                // message cycle now, but the marker is emitted in the first portion
-                // of the response — an earlier message cycle than the last one.
-                const finishedAssistantText = finishedTurn?.turnAssistantText ?? finishedTurn?.assistantText ?? "";
-                // Check for the loop-done marker in the first portion of the
-                // response (the prompt instructs the agent to emit it first).
-                const head = finishedAssistantText.slice(0, 500);
-                if (head.includes(LOOP_DONE_MARKER)) {
-                    console.log(`[loop] completion marker detected after ${stream.loopIterationCount} iteration(s), stopping`);
-                    const completedIterations = stream.loopIterationCount;
-                    stream.loopActive = false;
-                    stream.loopIterationCount = 0;
-                    stream.loopOriginalPrompt = null;
-                    stream.loopGoal = null;
-                    this.broadcast(stream, {
-                        type: "loop_complete",
-                        iterations: completedIterations,
-                    });
-                }
-                else if (stream.loopIterationCount >= stream.loopMaxIterations) {
-                    console.log(`[loop] max iterations (${stream.loopMaxIterations}) reached, stopping`);
-                    stream.loopActive = false;
-                    stream.loopOriginalPrompt = null;
-                    stream.loopGoal = null;
-                    this.broadcast(stream, {
-                        type: "loop_max_iterations",
-                        iterations: stream.loopIterationCount,
-                    });
-                }
-                else {
-                    stream.loopIterationCount++;
-                    console.log(`[loop] iteration ${stream.loopIterationCount}/${stream.loopMaxIterations}`);
-                    this.broadcast(stream, {
-                        type: "loop_iteration",
-                        iteration: stream.loopIterationCount,
-                        maxIterations: stream.loopMaxIterations,
-                        prompt: stream.loopOriginalPrompt,
-                    });
-                    // Deferred via setImmediate: agent_end fires synchronously while
-                    // the agent core is still settling the run (isStreaming is still
-                    // true). Calling prompt() synchronously would throw "Agent is
-                    // already processing" because finishRun() hasn't cleared
-                    // isStreaming yet.
-                    setImmediate(() => {
-                        if (this.disposed)
-                            return;
-                        void this.sendNextLoopIteration(stream).catch((err) => {
-                            console.error(`[loop] iteration failed: ${err instanceof Error ? err.message : String(err)}`);
-                            stream.loopActive = false;
-                            stream.loopOriginalPrompt = null;
-                            stream.loopGoal = null;
-                        });
-                    });
-                }
-            }
             // Fork & Compact: after the first assistant turn of a forked session,
             // compact the context. The custom instructions reference the user's
             // new message so the summary preserves relevant context.
@@ -2351,8 +2131,8 @@ export class SessionStreamManager {
                 stream.forkCompactSourceId = null; // one-shot
                 this.triggerForkCompact(stream);
             }
-            // Auto-dequeue: after the turn finishes and no loop iteration is
-            // pending, check the persistent prompt queue. If there's a queued
+            // Auto-dequeue: after the turn finishes, check the persistent prompt
+            // queue. If there's a queued
             // prompt, start it immediately without broadcasting agent_end —
             // the frontend transitions seamlessly to the next turn.
             // Skip if compaction is in-flight (e.g. fork-compact just started
@@ -2364,17 +2144,13 @@ export class SessionStreamManager {
             // synchronously would throw "Agent is already processing" — the
             // agent core rejects all prompt() calls until finishRun() clears
             // isStreaming, which happens after this listener returns.
-            if (!stream.loopActive && !stream.loopOriginalPrompt) {
-                this.runTurnCleanup(finishedTurn);
-            }
-            if (!stream.loopActive || !stream.loopOriginalPrompt) {
-                if (!stream.compacting) {
-                    setImmediate(() => {
-                        if (this.disposed)
-                            return;
-                        this.maybeAutoDequeue(stream);
-                    });
-                }
+            this.runTurnCleanup(finishedTurn);
+            if (!stream.compacting) {
+                setImmediate(() => {
+                    if (this.disposed)
+                        return;
+                    this.maybeAutoDequeue(stream);
+                });
             }
             this.settleRunState(stream);
         }
@@ -2403,7 +2179,7 @@ export class SessionStreamManager {
     /**
      * Resolve the authoritative run-state snapshot for a stream. This is the
      * ONLY place `phase`/`flags`/`busy` are computed. Phase precedence:
-     * retrying > compacting > looping > streaming > queued > idle.
+     * retrying > compacting > streaming > queued > idle.
      */
     resolveRunState(stream) {
         const bridge = stream.bridge;
@@ -2411,7 +2187,6 @@ export class SessionStreamManager {
             streaming: stream.currentTurn != null || bridge.isStreaming?.() === true,
             retrying: bridge.isRetrying?.() === true,
             compacting: stream.compacting,
-            looping: stream.loopActive,
             // Prompt queue is pending work, not active work. It is exposed as a
             // flag for the badge only — it never feeds `busy`.
             queued: stream.queued,
@@ -2419,7 +2194,6 @@ export class SessionStreamManager {
         const busy = flags.streaming ||
             flags.retrying ||
             flags.compacting ||
-            flags.looping ||
             stream.pendingContinue ||
             // R1: a `prompt()` dispatch is in flight — the turn is not armed yet
             // (we may still be awaiting `ready`/`setModel`), but the session is
@@ -2429,15 +2203,13 @@ export class SessionStreamManager {
             ? "retrying"
             : flags.compacting
                 ? "compacting"
-                : flags.looping
-                    ? "looping"
-                    : flags.streaming
-                        ? "streaming"
-                        : flags.queued
-                            ? "queued"
-                            : busy
-                                ? "streaming" // pendingContinue gap — keep "streaming"
-                                : "idle";
+                : flags.streaming
+                    ? "streaming"
+                    : flags.queued
+                        ? "queued"
+                        : busy
+                            ? "streaming" // pendingContinue gap — keep "streaming"
+                            : "idle";
         return { ...stream.runState, busy, phase, flags };
     }
     computeBusy(stream) {
@@ -2597,14 +2369,12 @@ export class SessionStreamManager {
     }
     /**
      * Auto-dequeue the next prompt from the persistent queue and start a
-     * new turn. Called from the `agent_end` handler when no loop is active.
+     * new turn. Called from the `agent_end` handler.
      * Returns true if a prompt was dequeued and a turn started.
      */
     maybeAutoDequeue(stream) {
         if (stream.currentTurn || stream.compacting)
             return false;
-        if (stream.loopActive && stream.loopOriginalPrompt)
-            return false;
         // A dequeued "@preset:" reference is being expanded (async resolver) —
         // never dequeue a second item into the same gap.
         if (stream.expandingQueueItem)

package/dist/server/wire.d.ts

@@ -71,10 +71,10 @@ export interface WireMessage {
 /**
  * Authoritative per-session agent run phase. The CLI resolves this single
  * value server-side (see `SessionStream.resolveRunState`) using the
- * precedence: retrying > compacting > looping > streaming > queued > idle.
+ * precedence: retrying > compacting > streaming > queued > idle.
  * The frontend badge renders it but never derives it locally.
  */
-export type RunPhase = "idle" | "streaming" | "retrying" | "compacting" | "looping" | "queued";
+export type RunPhase = "idle" | "streaming" | "retrying" | "compacting" | "queued";
 /**
  * Single source of truth for "is the agent working right now". `busy` is the
  * only field the frontend composer should use to decide send vs queue; `phase`
@@ -93,7 +93,6 @@ export interface WireRunState {
         streaming: boolean;
         retrying: boolean;
         compacting: boolean;
-        looping: boolean;
         queued: boolean;
     };
 }
@@ -316,18 +315,12 @@ export interface WireCompactionTokenSourceBucket {
 export type ClientMessage = {
     type: "user_message";
     content: string;
-    /** Enable autonomous iterative loop for this message (Ralph Wiggum pattern). */
-    loop?: boolean;
     /** Optional image attachments (hosted `url` preferred, inline base64 legacy). */
     images?: ImageAttachment[];
-    /** Optional loop max iterations (server caps at MAX_LOOP_ITERATIONS). */
-    loopMaxIterations?: number;
-    /** Optional loop goal / acceptance criteria. */
-    loopGoal?: string;
     /**
      * Optional interval scheduler (minutes). When set, arms a recurring
-     * scheduler that re-launches the prompt (or a fresh loop, when `loop`
-     * is also set) every N minutes, guarded by an idle check. The first
+     * scheduler that re-launches the prompt every N minutes, guarded by an
+     * idle check. The first
      * launch happens immediately via the normal prompt path; the scheduler
      * ticks from +N minutes.
      */
@@ -337,7 +330,7 @@ export type ClientMessage = {
      * immediately (and resets the cadence); `"stop"` disarms the scheduler.
      * Sent as a user_message with no content.
      */
-    loopControl?: "run_now" | "stop";
+    intervalControl?: "run_now" | "stop";
 };
 /**
  * Subset of `ServerEvent` that's safe to buffer per turn and replay on
@@ -394,8 +387,6 @@ export type ServerEvent = {
     intervalMinutes?: number | null;
     intervalNextTickAt?: number | null;
     intervalLaunchCount?: number;
-    intervalHasLoop?: boolean;
-    intervalGoal?: string | null;
     /** Authoritative run-state snapshot for reconnect/hydration. */
     runState?: WireRunState;
 } | {
@@ -426,8 +417,6 @@ export type ServerEvent = {
     intervalMinutes?: number | null;
     intervalNextTickAt?: number | null;
     intervalLaunchCount?: number;
-    intervalHasLoop?: boolean;
-    intervalGoal?: string | null;
     /** Authoritative run-state snapshot for reconnect/hydration. */
     runState?: WireRunState;
 } | {
@@ -559,6 +548,19 @@ export type ServerEvent = {
 } | {
     type: "error";
     message: string;
+} | {
+    /**
+     * Emitted when a requested modelId is no longer active in the backend's
+     * available-models registry (stale whitelist entry) and the server
+     * substituted an active fallback — the backend default (`isDefault`)
+     * when present, else the first available model — so the turn proceeds
+     * instead of failing. The turn runs with `activeModelId`, which is
+     * also persisted as the session's sticky model. Clients should update
+     * their model picker to `activeModelId`.
+     */
+    type: "model_fallback";
+    requestedModelId: string;
+    activeModelId: string;
 } | {
     /**
      * Best-effort feedback for a `stop_tool_call` request. `stopped` when the
@@ -570,26 +572,10 @@ export type ServerEvent = {
     status: "stopped" | "not_found";
     /** Echoed reason from the request, when supplied. */
     reason?: string;
-} | {
-    /** Emitted at the start of each loop iteration. */
-    type: "loop_iteration";
-    iteration: number;
-    maxIterations: number;
-    prompt: string;
-} | {
-    /** Emitted when the agent signals completion via <LOOP_DONE> marker. */
-    type: "loop_complete";
-    iterations: number;
-} | {
-    /** Emitted when the loop hits the safety iteration limit. */
-    type: "loop_max_iterations";
-    iterations: number;
 } | {
     /** Emitted when the interval scheduler is armed. */
     type: "interval_armed";
     intervalMinutes: number;
-    hasLoop: boolean;
-    goal: string | null;
 } | {
     /** Emitted each time the interval scheduler launches a new occurrence. */
     type: "interval_launched";