@aexol/spectral 0.9.58 → 0.9.59

package/dist/server/session-stream.js

@@ -38,8 +38,10 @@
  */
 import { randomUUID } from "node:crypto";
 import { AgentBridge } from "./agent-bridge.js";
+import { SettingsManager } from "../sdk/coding-agent/index.js";
 import { InterAgentBroker } from "./inter-agent-broker.js";
 import { setInterAgentBroker } from "../memory/inter-agent-broker-singleton.js";
+import { DEFAULT_COMPACTION_POLICY, getAutoOlderHistoryContextThresholdTokens, } from "../sdk/coding-agent/core/compaction/policy.js";
 import { getMemoryState, isSourceEntry, rawTokensSinceLastBound, rawTokensSinceLastCompaction, } from "../memory/branch.js";
 import { observationPoolTokens, renderSummary } from "../memory/compaction.js";
 import { loadConfig } from "../memory/config.js";
@@ -49,11 +51,6 @@ import { reflectionContent, reflectionId } from "../memory/types.js";
 const DEFAULT_BRIDGE_FACTORY = (args) => new AgentBridge(args);
 /** Safety limit for autonomous loop iterations per session. */
 const MAX_LOOP_ITERATIONS = 100;
-/**
- * Token threshold above which the loop triggers compaction between iterations.
- * Aligned with the observational memory extension default (memory/config.ts).
- */
-const LOOP_COMPACTION_THRESHOLD_TOKENS = 50_000;
 /**
  * Defensive cap for fresh-bridge history replay when we already have a
  * persisted observational-memory snapshot. spectral's own compaction keeps a
@@ -109,6 +106,160 @@ function estimateStoredMessageReplayTokens(message) {
         estimateStringTokens(message.events) +
         (message.images?.length ?? 0) * 2_000);
 }
+function formatCompactionTokenStats(event) {
+    const parts = [];
+    if (typeof event.compactionNumber === "number") {
+        parts.push(`compaction #${event.compactionNumber.toLocaleString()}`);
+    }
+    if (typeof event.tokensBefore === "number") {
+        parts.push(`from ~${event.tokensBefore.toLocaleString()} tokens`);
+    }
+    if (typeof event.tokensCompacted === "number") {
+        parts.push(`compacted ~${event.tokensCompacted.toLocaleString()} tokens`);
+    }
+    if (typeof event.tokensRemoved === "number") {
+        parts.push(`removed ~${event.tokensRemoved.toLocaleString()} tokens`);
+    }
+    if (typeof event.summaryTokens === "number") {
+        parts.push(`summary +~${event.summaryTokens.toLocaleString()} tokens`);
+    }
+    if (typeof event.reductionPercent === "number") {
+        parts.push(`reduction ~${event.reductionPercent.toLocaleString(undefined, { maximumFractionDigits: 2 })}%`);
+    }
+    if (event.largestTokenSources?.length) {
+        const sources = event.largestTokenSources
+            .slice(0, 3)
+            .map((bucket) => `${bucket.type}:${bucket.name} ~${bucket.tokens.toLocaleString()}`)
+            .join("; ");
+        parts.push(`largest sources ${sources}`);
+    }
+    return parts.length > 0 ? ` (${parts.join(", ")})` : "";
+}
+function isSkippedCompactionResult(result) {
+    return Boolean(result && typeof result === "object" && result.skipped === true);
+}
+// Persisted-history prune is deliberately stricter than timeline status
+// rendering: only a successful compaction_end proves Pi appended a usable
+// compaction entry. Aborted, skipped, or failed endings may leave the branch
+// unchanged or partially settled, so pruning must skip instead of guessing.
+function getCompactionEndPruneSkipReason(event) {
+    if (event.aborted)
+        return "aborted";
+    if (event.skipped)
+        return "skipped";
+    if (event.errorMessage)
+        return "failed";
+    if (typeof event.tokensRemoved !== "number" || event.tokensRemoved <= 0)
+        return "missing_token_reduction";
+    return null;
+}
+const BRANCH_MESSAGE_TIMESTAMP_TOLERANCE_MS = 5_000;
+function isRecord(value) {
+    return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+function contentAsPersistedText(content) {
+    if (typeof content === "string")
+        return content;
+    if (!Array.isArray(content))
+        return null;
+    const textParts = [];
+    for (const part of content) {
+        if (typeof part === "string") {
+            textParts.push(part);
+            continue;
+        }
+        if (isRecord(part) && part.type === "text" && typeof part.text === "string") {
+            textParts.push(part.text);
+        }
+    }
+    return textParts.length > 0 ? textParts.join("") : null;
+}
+function branchMessageTimestampMs(entry, message) {
+    if (typeof message.timestamp === "number" && Number.isFinite(message.timestamp))
+        return message.timestamp;
+    if (typeof entry.timestamp !== "string")
+        return null;
+    const parsed = Date.parse(entry.timestamp);
+    return Number.isFinite(parsed) ? parsed : null;
+}
+function branchMessageSignature(entry) {
+    if (entry.type !== "message" || !isRecord(entry.message))
+        return null;
+    const role = entry.message.role;
+    if (role !== "user" && role !== "assistant")
+        return null;
+    const content = contentAsPersistedText(entry.message.content);
+    if (content === null)
+        return null;
+    return {
+        role,
+        content,
+        timestampMs: branchMessageTimestampMs(entry, entry.message),
+        entryId: entry.id,
+    };
+}
+function branchMessageRole(entry) {
+    return entry.type === "message" && isRecord(entry.message) ? entry.message.role : undefined;
+}
+function getKeptBranchMessageSignatures(entries, keptEntryIndex) {
+    const signatures = [];
+    for (let i = keptEntryIndex; i < entries.length; i++) {
+        const entry = entries[i];
+        if (entry.type !== "message")
+            continue;
+        const role = branchMessageRole(entry);
+        if (role !== "user" && role !== "assistant")
+            continue;
+        const signature = branchMessageSignature(entry);
+        if (!signature) {
+            console.log(`[spectral] prune: skipped – reason=unsafe_kept_message, ` +
+                `kept branch message ${entry.id} cannot be matched safely`);
+            return null;
+        }
+        signatures.push(signature);
+    }
+    return signatures;
+}
+function selectUniqueCandidate(candidates, kept) {
+    if (candidates.length === 1)
+        return candidates[0];
+    if (kept.timestampMs === null)
+        return null;
+    const keptTimestampMs = kept.timestampMs;
+    const timestampMatches = candidates.filter((candidate) => Math.abs(candidate.message.createdAt - keptTimestampMs) <= BRANCH_MESSAGE_TIMESTAMP_TOLERANCE_MS);
+    return timestampMatches.length === 1 ? timestampMatches[0] : null;
+}
+function matchKeptPersistedMessageIds(existing, keptBranchMessages) {
+    const existingConversationMessages = existing
+        .filter((message) => message.role === "user" || message.role === "assistant")
+        .map((message, conversationIndex) => ({ message, conversationIndex }));
+    const matchedIds = new Set();
+    let searchStart = 0;
+    for (const kept of keptBranchMessages) {
+        const candidates = existingConversationMessages.filter((candidate) => candidate.conversationIndex >= searchStart &&
+            !matchedIds.has(candidate.message.id) &&
+            candidate.message.role === kept.role &&
+            candidate.message.content === kept.content);
+        const selected = selectUniqueCandidate(candidates, kept);
+        if (!selected) {
+            console.log(`[spectral] prune: skipped – reason=ambiguous_kept_mapping, ` +
+                `could not stably match kept branch entry ${kept.entryId} ` +
+                `(${kept.role}, ${kept.content.length.toLocaleString()} chars) to SQLite history`);
+            return null;
+        }
+        matchedIds.add(selected.message.id);
+        searchStart = selected.conversationIndex + 1;
+    }
+    return matchedIds;
+}
+function loadCompactionPolicy(cwd) {
+    try {
+        return SettingsManager.create(cwd).getCompactionPolicy();
+    }
+    catch {
+        return DEFAULT_COMPACTION_POLICY;
+    }
+}
 function selectHistoryForBridge(history, hasMemorySnapshot) {
     if (!history || history.length === 0)
         return history;
@@ -125,8 +276,122 @@ function selectHistoryForBridge(history, hasMemorySnapshot) {
     const selected = history.slice(Math.max(0, start + 1));
     return selected.length > 0 ? selected : [history[history.length - 1]];
 }
+function prunePersistedHistoryAfterCompaction(store, sessionId, bridge) {
+    if (!bridge.getSessionBranch)
+        return;
+    try {
+        const entries = bridge.getSessionBranch();
+        // Pi appends a CompactionEntry (type "compaction") at the end whose
+        // firstKeptEntryId marks the first branch entry that survives in LLM context.
+        // We scan backwards so we find the most recent compaction (there should be
+        // exactly one per compaction pass).
+        const lastCompaction = [...entries].reverse().find((entry) => entry.type === "compaction");
+        const firstKeptEntryId = lastCompaction?.firstKeptEntryId;
+        if (!firstKeptEntryId) {
+            console.log(`[spectral] prune: skipped – reason=missing_compaction_entry, ` +
+                `no compaction entry (or no firstKeptEntryId) ` +
+                `in branch for ${sessionId} (${entries.length} entries)`);
+            return;
+        }
+        const keptEntryIndex = entries.findIndex((entry) => entry.id === firstKeptEntryId);
+        if (keptEntryIndex === -1) {
+            console.log(`[spectral] prune: skipped – reason=missing_kept_entry, ` +
+                `firstKeptEntryId "${firstKeptEntryId}" ` +
+                `not found in ${entries.length} branch entries for ${sessionId}`);
+            return;
+        }
+        const keptBranchMessages = getKeptBranchMessageSignatures(entries, keptEntryIndex);
+        if (!keptBranchMessages)
+            return;
+        const existing = store.getMessages(sessionId);
+        if (existing.length === 0)
+            return;
+        if (keptBranchMessages.length === 0) {
+            console.log(`[spectral] prune: skipped – reason=no_kept_conversation_messages, ` +
+                `no kept persisted user/assistant messages for ${sessionId}`);
+            return;
+        }
+        console.log(`[spectral] prune: ${sessionId} – source=compaction_end, branch has ${entries.length} entries, ` +
+            `kept portion starts at index ${keptEntryIndex} (id=${firstKeptEntryId}), ` +
+            `${keptBranchMessages.length} user+assistant entries kept, ` +
+            `${existing.length} SQLite messages`);
+        const matchedKeptIds = matchKeptPersistedMessageIds(existing, keptBranchMessages);
+        if (!matchedKeptIds)
+            return;
+        const deleteIds = existing
+            .filter((message) => (message.role === "user" || message.role === "assistant") && !matchedKeptIds.has(message.id))
+            .map((message) => message.id);
+        if (deleteIds.length === 0) {
+            console.log(`[spectral] prune: skipped – reason=already_pruned, ` +
+                `SQLite history already matches compacted branch for ${sessionId}`);
+            return;
+        }
+        const pruned = store.deleteMessagesByIdForSession(sessionId, deleteIds);
+        console.log(`[spectral] prune: finished – reason=successful_compaction_end, ` +
+            `dropped ${pruned} pre-compaction message(s) ` +
+            `for ${sessionId}, ${matchedKeptIds.size} user/assistant message(s) kept`);
+    }
+    catch (err) {
+        console.warn(`[spectral] warn: failed to prune persisted history after compaction for ${sessionId}: ${err instanceof Error ? err.message : String(err)}`);
+    }
+}
+function buildDcpLiteThresholds(config, policy) {
+    return {
+        nudgeMinRawTokens: config.dcpNudgeMinRawTokens,
+        nudgeMinContextTokens: config.dcpNudgeMinContextTokens,
+        nudgeContextPercent: config.dcpNudgeContextPercent,
+        providerRequestThreshold: config.dcpInRunNudgeIterationThreshold,
+        providerRequestFrequency: config.dcpInRunNudgeFrequency,
+        postRunCompactionThresholdTokens: Math.max(config.compactionThresholdTokens, policy.autoOlderHistory.minRawTokens),
+        autoContextLimitRatio: policy.autoOlderHistory.contextLimitRatio,
+        olderHistoryKeepRecentTokens: policy.agentDriven.olderHistoryKeepRecentTokens,
+        olderHistoryMinCompactableTokens: policy.agentDriven.olderHistoryMinCompactableTokens,
+        cooldownTurns: policy.agentDriven.cooldownTurns,
+    };
+}
+function contextPercent(usedTokens, maxTokens) {
+    if (typeof usedTokens !== "number" || typeof maxTokens !== "number" || maxTokens <= 0)
+        return null;
+    return Math.max(0, Math.min(100, (usedTokens / maxTokens) * 100));
+}
+function applyDcpLiteRuntimeStatus(status, stream) {
+    if (!status.dcpLite || !stream)
+        return;
+    const usage = stream.bridge.getContextUsage?.();
+    const usedTokens = usage ? usage.tokens : stream.contextWindowUsed;
+    const maxTokens = usage ? usage.contextWindow : stream.contextWindowMax;
+    const percent = usage?.percent ?? contextPercent(usedTokens, maxTokens);
+    if (usage || usedTokens !== null || maxTokens !== null) {
+        status.dcpLite.contextWindow = { usedTokens, maxTokens, percent };
+    }
+    if (stream.lastDcpEvent) {
+        status.dcpLite.lastEvent = stream.lastDcpEvent;
+    }
+}
+function dcpLiteEventKindFromMessage(message) {
+    const lower = message.toLowerCase();
+    if (lower.includes("failed") || lower.includes("threw"))
+        return "failed";
+    if (lower.includes("skipped"))
+        return "skipped";
+    if (lower.includes("deferred"))
+        return "deferred";
+    if (lower.includes("complete") || lower.includes("applied"))
+        return "completed";
+    return "scheduled";
+}
+function dcpLiteEventFromServerEvent(event) {
+    if (event.type !== "agent_notification" || !event.message.includes("DCP-lite"))
+        return null;
+    return {
+        kind: dcpLiteEventKindFromMessage(event.message),
+        message: event.message,
+        timestamp: Date.now(),
+    };
+}
 function defaultMemoryStatus(cwd) {
     const config = loadConfig(cwd);
+    const policy = loadCompactionPolicy(cwd);
     return {
         mode: config.passive ? "passive" : "active",
         phase: "idle",
@@ -153,6 +418,9 @@ function defaultMemoryStatus(cwd) {
             sinceLastCompactionTokens: 0,
             observationPoolTokens: 0,
         },
+        dcpLite: {
+            thresholds: buildDcpLiteThresholds(config, policy),
+        },
     };
 }
 export class SessionStreamManager {
@@ -164,6 +432,7 @@ export class SessionStreamManager {
     agentDir;
     broker;
     streams = new Map();
+    managerCompactions = new Map();
     disposed = false;
     constructor(opts) {
         this.store = opts.store;
@@ -224,6 +493,12 @@ export class SessionStreamManager {
             contextWindowUsed: stream.contextWindowUsed,
             contextWindowMax: stream.contextWindowMax,
             compacting: stream.compacting,
+            intervalActive: stream.intervalTimer != null,
+            intervalMinutes: stream.intervalMinutes,
+            intervalNextTickAt: stream.intervalNextTickAt,
+            intervalLaunchCount: stream.intervalLaunchCount,
+            intervalHasLoop: stream.intervalConfig?.loop ?? false,
+            intervalGoal: stream.intervalConfig?.loopGoal ?? null,
         };
     }
     /**
@@ -326,6 +601,7 @@ export class SessionStreamManager {
             status.phase = "compacting";
             status.inFlight.compaction = true;
         }
+        applyDcpLiteRuntimeStatus(status, stream);
         return status;
     }
     getSessionMemoryDetails(sessionId) {
@@ -383,38 +659,92 @@ export class SessionStreamManager {
             reflections: wireReflections,
         };
     }
-    async compactSession(sessionId) {
-        if (this.disposed)
-            throw new Error("SessionStreamManager disposed");
-        const detail = this.store.getSession(sessionId);
-        if (!detail)
-            throw new Error(`Unknown sessionId: ${sessionId}`);
-        let stream = this.streams.get(sessionId);
-        if (!stream) {
-            stream = this.createStream(sessionId, detail.messages);
-            this.streams.set(sessionId, stream);
+    async requestManagerCompaction(stream, request) {
+        if (!stream.bridge.compact) {
+            return { status: "skipped", source: request.source, reason: "unsupported" };
         }
         if (stream.currentTurn) {
-            throw new Error("Session is busy with an active turn");
+            return { status: "skipped", source: request.source, reason: "active_turn" };
         }
-        if (stream.compacting) {
-            throw new Error("Session is already being compacted");
+        const active = this.managerCompactions.get(stream.sessionId);
+        if (active || stream.compacting) {
+            const activeSource = active ? ` from ${active.source}` : "";
+            console.log(`[spectral] compaction ${request.source} skipped for ${stream.sessionId}: ` +
+                `compaction already in flight${activeSource}`);
+            return { status: "skipped", source: request.source, reason: "already_in_flight" };
         }
-        if (!stream.bridge.compact) {
-            throw new Error("Manual compaction is not supported for this session");
+        try {
+            await stream.ready;
+        }
+        catch (err) {
+            const error = err instanceof Error ? err : new Error(String(err));
+            return { status: "failed", source: request.source, error };
+        }
+        if (stream.currentTurn) {
+            return { status: "skipped", source: request.source, reason: "active_turn" };
+        }
+        if (this.managerCompactions.has(stream.sessionId) || stream.compacting) {
+            return { status: "skipped", source: request.source, reason: "already_in_flight" };
         }
-        await stream.ready;
         stream.compacting = true;
+        let promise;
         try {
-            await stream.bridge.compact();
-            // Prune persisted history synchronously after compaction, so even if the
-            // compaction_end event handler races or misses, SQLite reflects the
-            // compacted state before the next user prompt or reconnect.
+            promise = stream.bridge.compact(request.options);
+        }
+        catch (err) {
+            stream.compacting = false;
+            const error = err instanceof Error ? err : new Error(String(err));
+            return { status: "failed", source: request.source, error };
+        }
+        this.managerCompactions.set(stream.sessionId, {
+            source: request.source,
+            promise,
+        });
+        try {
+            const result = await promise;
+            if (isSkippedCompactionResult(result)) {
+                return { status: "skipped", source: request.source, reason: "skipped_result", result };
+            }
+            return { status: "completed", source: request.source, result };
+        }
+        catch (err) {
+            const error = err instanceof Error ? err : new Error(String(err));
+            return { status: "failed", source: request.source, error };
         }
         finally {
+            const activeAfterRun = this.managerCompactions.get(stream.sessionId);
+            if (activeAfterRun?.promise === promise)
+                this.managerCompactions.delete(stream.sessionId);
             if (stream.compacting)
                 stream.compacting = false;
-            this.maybeAutoDequeue(stream);
+            if (!this.disposed)
+                this.maybeAutoDequeue(stream);
+        }
+    }
+    async compactSession(sessionId, options) {
+        if (this.disposed)
+            throw new Error("SessionStreamManager disposed");
+        const detail = this.store.getSession(sessionId);
+        if (!detail)
+            throw new Error(`Unknown sessionId: ${sessionId}`);
+        let stream = this.streams.get(sessionId);
+        if (!stream) {
+            stream = this.createStream(sessionId, detail.messages);
+            this.streams.set(sessionId, stream);
+        }
+        const outcome = await this.requestManagerCompaction(stream, {
+            source: "manual_api",
+            options,
+        });
+        if (outcome.status === "failed")
+            throw outcome.error;
+        if (outcome.status === "skipped") {
+            if (outcome.reason === "active_turn")
+                throw new Error("Session is busy with an active turn");
+            if (outcome.reason === "unsupported")
+                throw new Error("Manual compaction is not supported for this session");
+            if (outcome.reason === "already_in_flight")
+                throw new Error("Session is already being compacted");
         }
     }
     /**
@@ -636,6 +966,7 @@ export class SessionStreamManager {
         this.disposed = true;
         for (const stream of this.streams.values()) {
             stream.loopActive = false;
+            this.clearIntervalTimer(stream);
             try {
                 stream.bridge.dispose();
             }
@@ -687,6 +1018,10 @@ export class SessionStreamManager {
         stream.loopOriginalPrompt = null;
         stream.loopGoal = null;
         stream.loopIterationCount = 0;
+        this.clearIntervalTimer(stream);
+        stream.intervalMinutes = null;
+        stream.intervalConfig = null;
+        stream.intervalNextTickAt = null;
         // Capture whether a turn is in-flight BEFORE we dispose the bridge.
         // dispose() tears down spectral, which can cause the in-flight prompt()
         // promise to reject synchronously/microtask and emit an error event
@@ -738,6 +1073,10 @@ export class SessionStreamManager {
         if (!stream)
             return;
         stream.loopActive = false;
+        this.clearIntervalTimer(stream);
+        stream.intervalMinutes = null;
+        stream.intervalConfig = null;
+        stream.intervalNextTickAt = null;
         // Flush the last batch of in-flight events before tearing down, so a
         // shutdown / GC doesn't lose events that haven't hit the interval yet.
         this.flushInFlightTurn(stream);
@@ -802,21 +1141,101 @@ export class SessionStreamManager {
             }
         }
     }
+    /**
+     * Arms the interval scheduler for a session. The first launch is assumed
+     * to have already happened (via the normal prompt path); this only sets
+     * up the recurring `setInterval` that re-launches on each idle tick.
+     * Replaces any previously-armed scheduler for the session.
+     */
+    armInterval(sessionId, config, intervalMinutes) {
+        const stream = this.streams.get(sessionId);
+        if (!stream)
+            return;
+        const minutes = Math.max(1, Math.min(1440, Math.floor(intervalMinutes)));
+        this.clearIntervalTimer(stream);
+        stream.intervalMinutes = minutes;
+        stream.intervalConfig = config;
+        stream.intervalLaunchCount = 0;
+        this.scheduleIntervalTick(stream, minutes);
+        this.broadcast(stream, {
+            type: "interval_armed",
+            intervalMinutes: minutes,
+            hasLoop: config.loop,
+            goal: config.loopGoal ?? null,
+        });
+    }
+    /**
+     * Fires the next interval occurrence immediately if the session is idle,
+     * and resets the cadence so the following tick is +N minutes from now.
+     * If the session is busy, this is a no-op (the cadence is still reset).
+     */
+    triggerIntervalNow(sessionId) {
+        const stream = this.streams.get(sessionId);
+        if (!stream || !stream.intervalTimer)
+            return;
+        const minutes = stream.intervalMinutes ?? 1;
+        this.scheduleIntervalTick(stream, minutes);
+        this.intervalTick(stream);
+    }
+    /** Disarms the interval scheduler for a session. */
+    stopInterval(sessionId) {
+        const stream = this.streams.get(sessionId);
+        if (!stream)
+            return;
+        if (!stream.intervalTimer)
+            return;
+        this.clearIntervalTimer(stream);
+        stream.intervalMinutes = null;
+        stream.intervalConfig = null;
+        stream.intervalNextTickAt = null;
+        this.broadcast(stream, { type: "interval_stopped" });
+    }
+    /** True when the interval scheduler is armed for this session. */
+    isIntervalArmed(sessionId) {
+        return this.streams.get(sessionId)?.intervalTimer != null;
+    }
+    scheduleIntervalTick(stream, minutes) {
+        this.clearIntervalTimer(stream);
+        stream.intervalNextTickAt = Date.now() + minutes * 60_000;
+        stream.intervalTimer = setInterval(() => this.intervalTick(stream), minutes * 60_000);
+    }
+    clearIntervalTimer(stream) {
+        if (stream.intervalTimer) {
+            clearInterval(stream.intervalTimer);
+            stream.intervalTimer = null;
+        }
+    }
+    intervalTick(stream) {
+        if (!stream.intervalConfig)
+            return;
+        const idle = !stream.loopActive &&
+            stream.currentTurn === null &&
+            !stream.compacting;
+        if (!idle) {
+            this.broadcast(stream, { type: "interval_skipped", reason: "busy" });
+            return;
+        }
+        stream.intervalLaunchCount++;
+        const occurrence = stream.intervalLaunchCount;
+        this.broadcast(stream, { type: "interval_launched", occurrence });
+        const cfg = stream.intervalConfig;
+        if (cfg.loop) {
+            this.setLoopActive(stream.sessionId, true, cfg.prompt, cfg.loopMaxIterations, cfg.loopGoal);
+        }
+        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)}`);
+        });
+    }
     /**
      * Fork & Compact: trigger compaction after the first assistant turn of a
-     * forked session. Uses spectral's built-in `compact()` which generates a summary
+     * forked session. Uses spectral's built-in DCP compaction, which generates a summary
      * of older context, retaining the most recent ~20K tokens (including the
      * user's new message + the assistant's response).
      *
-     * Custom instructions reference the most recent user message so the LLM
-     * summary prioritizes information relevant to the current task.
+     * Custom instructions reference the most recent user message so compaction
+     * hooks can prioritize information relevant to the current task.
      */
     triggerForkCompact(stream) {
-        if (!stream.bridge.compact) {
-            console.warn(`[spectral] warn: bridge does not support compact ("Fork & Compact" skipped for ${stream.sessionId})`);
-            return;
-        }
-        stream.compacting = true;
         // Read the most recent user message to use as guidance for the
         // compaction summary.
         const detail = this.store.getSession(stream.sessionId);
@@ -827,73 +1246,33 @@ export class SessionStreamManager {
         const customInstructions = guidanceMessage
             ? `Focus the context summary on information relevant to: "${guidanceMessage}"`
             : undefined;
-        void stream.bridge
-            .compact(customInstructions)
-            .then(() => {
-            stream.compacting = false;
+        void this.requestManagerCompaction(stream, {
+            source: "fork_compact",
+            options: { customInstructions },
+        })
+            .then((outcome) => {
             try {
                 this.store.clearForkCompactSource(stream.sessionId);
             }
             catch {
                 // best-effort
             }
-            console.log(`[spectral] fork-compact completed for ${stream.sessionId}`);
-            this.maybeAutoDequeue(stream);
-        })
-            .catch((err) => {
-            stream.compacting = false;
-            const msg = err instanceof Error ? err.message : String(err);
-            if (msg === "Compaction already in progress") {
-                console.log(`[spectral] fork-compact skipped for ${stream.sessionId}: compaction already in progress`);
-            }
-            else {
-                console.error(`[spectral] fork-compact failed for ${stream.sessionId}: ${msg}`);
-                this.broadcast(stream, {
-                    type: "error",
-                    message: `Context compaction failed: ${msg}`,
-                });
-            }
-            // Clear the flag even on failure so it doesn't block forever.
-            try {
-                this.store.clearForkCompactSource(stream.sessionId);
+            if (outcome.status === "completed") {
+                console.log(`[spectral] fork-compact completed for ${stream.sessionId}`);
+                return;
             }
-            catch {
-                // best-effort
+            if (outcome.status === "skipped") {
+                console.log(`[spectral] fork-compact skipped for ${stream.sessionId}: ${outcome.reason}`);
+                return;
             }
-            this.maybeAutoDequeue(stream);
+            console.error(`[spectral] fork-compact failed for ${stream.sessionId}: ${outcome.error.message}`);
+            this.broadcast(stream, {
+                type: "error",
+                message: `Context compaction failed: ${outcome.error.message}`,
+            });
         });
     }
-    /**
-     * Send the next prompt for an autonomous loop iteration, waiting for any
-     * in-flight observational-memory compaction to finish first so the LLM
-     * sees the compacted context.
-     *
-     * The compaction-trigger extension fires on agent_end (via setTimeout),
-     * so we poll stream.compacting briefly. If compaction hasn't started after
-     * a short grace period, we check whether the context window exceeds the
-     * threshold and proactively trigger compaction via the bridge (which
-     * invokes spectral's full pipeline, including the session_before_compact hook
-     * where the observational memory extension provides its summary).
-     *
-     * A duplicate call from the extension's delayed compaction trigger is
-     * harmless — spectral throws "Already compacted" which the extension catches.
-     */
-    /**
-     * Send the next prompt for an autonomous loop iteration, compacting first
-     * if the context window exceeds the threshold.
-     *
-     * Instead of polling for the extension's delayed compaction-trigger (which
-     * fires via setTimeout), we proactively call bridge.compact() directly.
-     * bridge.compact() → session.compact() → fires session_before_compact
-     * (where the extension's compaction-hook provides the observational-memory
-     * summary), then appends the compaction entry, reloads the compacted
-     * context into agent.state.messages, and emits compaction_start/end.
-     *
-     * The extension's trigger still fires (via setTimeout), but by the time
-     * its callback runs, bridge.compact() has already appended the compaction
-     * entry → prepareCompaction() returns undefined → "Already compacted"
-     * → the trigger's onError handler catches it harmlessly.
-     */
+    /** Build the next autonomous-loop prompt after optional policy-driven compaction. */
     buildLoopPrompt(stream) {
         const parts = [];
         if (stream.loopGoal) {
@@ -918,25 +1297,24 @@ export class SessionStreamManager {
         return parts.join("\n");
     }
     async sendNextLoopIteration(stream) {
-        const shouldCompact = stream.bridge.compact &&
-            typeof stream.contextWindowUsed === "number" &&
-            stream.contextWindowUsed > LOOP_COMPACTION_THRESHOLD_TOKENS;
+        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) {
-            try {
-                console.log(`[loop] compacting context (~${stream.contextWindowUsed.toLocaleString()} tokens > ${LOOP_COMPACTION_THRESHOLD_TOKENS.toLocaleString()} threshold)`);
-                await stream.bridge.compact();
+            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");
             }
-            catch (err) {
-                const msg = err instanceof Error ? err.message : String(err);
-                if (msg === "Already compacted" ||
-                    msg === "Nothing to compact (session too small)" ||
-                    msg === "Compaction already in progress") {
-                    console.log("[loop] compaction already done or not needed, proceeding");
-                }
-                else {
-                    console.error(`[loop] compaction failed: ${msg}`);
-                }
+            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);
@@ -972,10 +1350,16 @@ export class SessionStreamManager {
             loopOriginalPrompt: null,
             loopMaxIterations: MAX_LOOP_ITERATIONS,
             loopGoal: null,
+            intervalMinutes: null,
+            intervalTimer: null,
+            intervalNextTickAt: null,
+            intervalLaunchCount: 0,
+            intervalConfig: null,
             forkCompactSourceId: forkSourceId ?? null,
             compacting: false,
             contextWindowUsed: null,
             contextWindowMax: null,
+            lastDcpEvent: null,
         };
         const memorySnapshot = this.store.getSessionMemorySnapshot(sessionId);
         const bridgeHistory = selectHistoryForBridge(history, memorySnapshot != null);
@@ -1099,6 +1483,10 @@ export class SessionStreamManager {
         return stream;
     }
     handleBridgeEvent(stream, event) {
+        const dcpLiteEvent = dcpLiteEventFromServerEvent(event);
+        if (dcpLiteEvent) {
+            stream.lastDcpEvent = dcpLiteEvent;
+        }
         // Buffer replayable events into the in-flight turn. We intentionally
         // accept events even if currentTurn is null (rare race: spectral emits before
         // prompt() opened the turn), in which case we open one defensively so
@@ -1195,9 +1583,14 @@ export class SessionStreamManager {
         }
         if (event.type === "compaction_end") {
             stream.compacting = false;
-            // Keep the full persisted history in SQLite after compaction.
-            // The LLM context is already compacted via the bridge/session manager;
-            // landing can still load older messages through the REST endpoint.
+            const pruneSkipReason = getCompactionEndPruneSkipReason(event);
+            if (pruneSkipReason === null) {
+                prunePersistedHistoryAfterCompaction(this.store, stream.sessionId, stream.bridge);
+            }
+            else {
+                console.log(`[spectral] prune: skipped – reason=${pruneSkipReason}, ` +
+                    `compaction_end did not authorize persisted-history prune for ${stream.sessionId}`);
+            }
             persistObservationalMemorySnapshot(this.store, stream.sessionId, stream.bridge);
             // Drain the prompt queue after compaction finishes. During
             // compaction, auto-dequeue in agent_end is skipped to prevent the
@@ -1207,7 +1600,14 @@ export class SessionStreamManager {
             // "Agent is already processing" guard because isStreaming is
             // still true until finishRun() fires.
             setImmediate(() => {
-                this.maybeAutoDequeue(stream);
+                if (this.disposed)
+                    return;
+                try {
+                    this.maybeAutoDequeue(stream);
+                }
+                catch (err) {
+                    console.warn(`[spectral] warn: failed to drain queue after compaction for ${stream.sessionId}: ${err instanceof Error ? err.message : String(err)}`);
+                }
             });
             // After compaction the session context has been reduced; push updated
             // context-window stats to all subscribers so the frontend's context
@@ -1232,14 +1632,16 @@ export class SessionStreamManager {
                     contextWindowMax: ctx.contextWindow,
                 });
             }
-            const tokensMsg = typeof event.tokensBefore === "number"
-                ? ` (from ~${event.tokensBefore.toLocaleString()} tokens)`
-                : "";
+            const tokensMsg = formatCompactionTokenStats(event);
             const sysMsg = event.aborted
                 ? "Compaction aborted."
-                : event.summary
-                    ? `Compaction complete${tokensMsg}. Summary: ${event.summary}`
-                    : `Compaction complete${tokensMsg}.`;
+                : event.skipped
+                    ? `Compaction skipped${tokensMsg}: ${event.skipReason ? `${event.skipReason}: ` : ""}${event.errorMessage ?? "summary would not shrink context"}`
+                    : event.errorMessage
+                        ? `Compaction failed${tokensMsg}: ${event.errorMessage}`
+                        : event.summary
+                            ? `Compaction complete${tokensMsg}. Summary: ${event.summary}`
+                            : `Compaction complete${tokensMsg}.`;
             try {
                 // Update the existing "compacting…" system message in-place rather than
                 // appending a second system row. This keeps history replay at one entry
@@ -1482,8 +1884,12 @@ function isReplayable(event) {
         event.type === "token_usage" ||
         event.type === "error" ||
         event.type === "subagent_start" ||
-        event.type === "subagent_progress" ||
-        event.type === "subagent_end");
+        // `subagent_progress` carries full accumulated live snapshots (streaming
+        // text/thinking/status) and is intentionally live-only; buffering it into
+        // currentTurn or batch persistence recreates O(n²) snapshot growth while a
+        // long subagent is running. Keep lifecycle/tool/end events replayable.
+        event.type === "subagent_end" ||
+        event.type === "subagent_tool_progress");
 }
 function snapshotTurn(turn) {
     // Defensive copy of the events array so the snapshot can't be mutated by