mixdog 0.9.3 → 0.9.5

package/src/runtime/agent/orchestrator/session/manager/compaction-runner.mjs

@@ -0,0 +1,471 @@
+// Session compaction runner — recall-fasttrack / semantic / prune-fallback.
+// Extracted verbatim from manager.mjs (behavior-preserving). Self-contained:
+// operates on a live `session` object + opts, using pure compact/context
+// helpers. No runtime-liveness (_runtimeState) coupling — manager.mjs still
+// owns scheduling / stage gating and simply calls runSessionCompaction().
+import { createHash } from 'crypto';
+import { getProvider } from '../../providers/registry.mjs';
+import {
+    recallFastTrackCompactMessages,
+    semanticCompactMessages,
+    pruneToolOutputsUnanchored,
+    effectiveBudget as compactEffectiveBudget,
+    compactTypeIsRecallFastTrack,
+    compactTypeIsSemantic,
+    drainSessionCycle1,
+} from '../compact.mjs';
+import { estimateMessagesTokens, estimateRequestReserveTokens, estimateTranscriptContextUsage, resolveCompactBufferRatio } from '../context-utils.mjs';
+import { executeInternalTool } from '../../internal-tools.mjs';
+import {
+    positiveContextWindow,
+    compactTriggerForSession,
+    compactTargetBudget,
+    semanticCompactionEnabledForSession,
+    compactTypeForSession,
+} from './context-meta.mjs';
+import { uncachedInputTokensForProvider } from './usage-metrics.mjs';
+
+// 'compacting' is a transient in-flight stage written just before semantic /
+// recall-fasttrack compaction runs. If the process crashes or only partially
+// saves while it is set, a later load/resume reads a session that is NOT
+// actually compacting but whose UI marker (App.jsx / ContextPanel) shows
+// "Compacting conversation" permanently. Normalize that stale transient stage
+// to 'interrupted' so the surface recovers. Terminal stages (post_turn /
+// manual / auto_clear / *_failed / overflow_failed) are intentionally left as
+// the durable record of the last real outcome.
+export function normalizeStaleCompactingStage(session) {
+    const c = session?.compaction;
+    if (!c || typeof c !== 'object') return false;
+    if (c.lastStage !== 'compacting' && c.inProgress !== true) return false;
+    c.lastStage = 'interrupted';
+    c.inProgress = false;
+    c.lastCheckedAt = Date.now();
+    return true;
+}
+function addCompactUsageToSession(session, usage) {
+    if (!session || !usage) return;
+    const inputTokens = usage.inputTokens || 0;
+    const outputTokens = usage.outputTokens || 0;
+    const cachedTokens = usage.cachedTokens || 0;
+    const cacheWriteTokens = usage.cacheWriteTokens || 0;
+    const uncachedInputTokens = uncachedInputTokensForProvider(session.provider, inputTokens, cachedTokens, cacheWriteTokens);
+    session.totalInputTokens = (session.totalInputTokens || 0) + inputTokens;
+    session.totalOutputTokens = (session.totalOutputTokens || 0) + outputTokens;
+    session.totalCachedReadTokens = (session.totalCachedReadTokens || 0) + cachedTokens;
+    session.totalCacheWriteTokens = (session.totalCacheWriteTokens || 0) + cacheWriteTokens;
+    session.totalUncachedInputTokens = (session.totalUncachedInputTokens || 0) + uncachedInputTokens;
+    session.tokensCumulative = (session.tokensCumulative || 0) + inputTokens + outputTokens;
+}
+async function runRecallFastTrackForSession(session, messages, opts = {}) {
+    const sessionId = opts.sessionId || session?.id || null;
+    if (!sessionId) throw new Error('recall-fasttrack requires a session id');
+    const query = `session:${sessionId}:all-chunks`;
+    const querySha = createHash('sha256').update(query).digest('hex').slice(0, 16);
+    const callerCtx = {
+        callerSessionId: sessionId,
+        callerCwd: session?.cwd || undefined,
+        routingSessionId: sessionId,
+        clientHostPid: session?.clientHostPid,
+        signal: opts.signal || null,
+    };
+    const hydrateLimit = positiveContextWindow(session?.compaction?.recallIngestLimit)
+        || Math.max(500, Math.min(5000, messages.length || 0));
+    try {
+        await executeInternalTool('memory', {
+            action: 'ingest_session',
+            sessionId,
+            messages,
+            cwd: session?.cwd,
+            limit: hydrateLimit,
+        }, callerCtx);
+    } catch (err) {
+        try { process.stderr.write(`[session] recall-fasttrack ingest skipped (sess=${sessionId}): ${err?.message || err}\n`); } catch {}
+    }
+    const dumpArgs = {
+        action: 'dump_session_roots',
+        sessionId,
+        includeRaw: true,
+        limit: positiveContextWindow(session?.compaction?.recallChunkLimit ?? session?.compaction?.recallLimit) || hydrateLimit,
+    };
+    const runTool = (name, args) => executeInternalTool(name, args, callerCtx);
+    let recallText = await executeInternalTool('memory', dumpArgs, callerCtx);
+    let cycle1Text = '';
+    let cycle1Error = null;
+    const hasRawRows = /(?:^|\n)# raw_pending\s+\d+\s+id=/i.test(String(recallText || ''));
+    if (hasRawRows) {
+        try {
+            // Drain this session's cycle1 in window×concurrency units until no
+            // raw rows remain, so the injected root is fully chunked rather than
+            // carrying the unprocessed transcript tail (single-pass left raw in).
+            const drained = await drainSessionCycle1(runTool, {
+                sessionId,
+                dumpArgs,
+                deadlineMs: positiveContextWindow(session?.compaction?.recallCycle1DeadlineMs) || 120_000,
+                maxPasses: positiveContextWindow(session?.compaction?.recallCycle1MaxPasses) || 0,
+                cycleArgs: {
+                    min_batch: 1,
+                    session_cap: 1,
+                    batch_size: positiveContextWindow(session?.compaction?.recallCycle1BatchSize) || 100,
+                    rows_per_session: positiveContextWindow(session?.compaction?.recallRowsPerSession) || 100,
+                    window_size: positiveContextWindow(session?.compaction?.recallWindowSize) || 20,
+                    concurrency: positiveContextWindow(session?.compaction?.recallConcurrency) || 5,
+                },
+            });
+            recallText = drained.recallText;
+            cycle1Text = drained.cycle1Text;
+            if (drained.error) {
+                cycle1Error = drained.error;
+                try { process.stderr.write(`[session] recall-fasttrack cycle1 error (sess=${sessionId}): ${drained.error}\n`); } catch {}
+            }
+            if (drained.rawRemaining > 0) {
+                try { process.stderr.write(`[session] recall-fasttrack drained passes=${drained.passes} rawRemaining=${drained.rawRemaining} (sess=${sessionId})\n`); } catch {}
+            }
+        } catch (err) {
+            try { process.stderr.write(`[session] recall-fasttrack cycle1 skipped (sess=${sessionId}): ${err?.message || err}\n`); } catch {}
+        }
+    } else {
+        cycle1Text = 'cycle1: skipped (session chunks already hydrated)';
+    }
+    return { query, querySha, cycle1Error, recallText: [`session_id=${sessionId}`, cycle1Text, recallText].map(v => String(v || '').trim()).filter(Boolean).join('\n\n') };
+}
+// Element-identity change detection (same approach as loop.mjs messagesArrayChanged): two
+// arrays are "unchanged" only when same length AND every slot is the same object
+// reference. Used to reject a no-op prune (which returns a fresh array whose
+// elements are the untouched originals) from being accepted as a recovery.
+function messagesChanged(before, after) {
+    if (!Array.isArray(before) || !Array.isArray(after)) return before !== after;
+    if (before.length !== after.length) return true;
+    for (let i = 0; i < before.length; i += 1) {
+        if (before[i] !== after[i]) return true;
+    }
+    return false;
+}
+export async function runSessionCompaction(session, opts = {}) {
+    if (!session || session.closed === true) return null;
+    const mode = opts.mode === 'auto' ? 'auto' : 'manual';
+    const force = opts.force === true || mode === 'manual';
+    if (mode === 'auto' && session.compaction?.auto === false) return null;
+    const messages = Array.isArray(session.messages) ? session.messages : [];
+    if (messages.length < 3 && !force) return null;
+    const boundary = positiveContextWindow(session.compactBoundaryTokens)
+        || positiveContextWindow(session.autoCompactTokenLimit)
+        || positiveContextWindow(session.contextWindow);
+    if (!boundary) {
+        if (force) throw new Error('compact: no context window is available for this session');
+        return null;
+    }
+    // Reserve must mirror loop.mjs (buildCompactPolicy): request reserve (tool
+    // schema) PLUS the configured reserve (session.compaction.reservedTokens or
+    // MIXDOG_AGENT_COMPACT_RESERVED_TOKENS env). The old request-only value left
+    // the manual / auto-clear compact budget without the configured headroom the
+    // loop path reserves, so a compacted transcript could overflow on next send.
+    const requestReserveTokens = estimateRequestReserveTokens(session.tools || []);
+    const configuredReserveTokens = positiveContextWindow(session.compaction?.reservedTokens)
+        || positiveContextWindow(process.env.MIXDOG_AGENT_COMPACT_RESERVED_TOKENS)
+        || 0;
+    const reserveTokens = requestReserveTokens + configuredReserveTokens;
+    const beforeMessageTokens = estimateMessagesTokens(messages);
+    const triggerTokens = compactTriggerForSession(session, boundary)
+        || positiveContextWindow(session.compaction?.triggerTokens)
+        || boundary;
+    const bufferTokens = Math.max(0, boundary - triggerTokens);
+    const bufferRatio = boundary ? (bufferTokens / boundary) : resolveCompactBufferRatio(session.compaction || {});
+    const pressureTokens = estimateTranscriptContextUsage(messages, session.tools || []);
+    const beforeTokens = pressureTokens;
+    const compactType = compactTypeForSession(session);
+    if (!force && pressureTokens < triggerTokens) return {
+        changed: false,
+        reason: 'below threshold',
+        compactType,
+        beforeMessages: messages.length,
+        afterMessages: messages.length,
+        beforeTokens,
+        afterTokens: beforeTokens,
+        beforeMessageTokens,
+        afterMessageTokens: beforeMessageTokens,
+        pressureTokens,
+        triggerTokens,
+        bufferTokens,
+        bufferRatio,
+        boundaryTokens: boundary,
+        budgetTokens: boundary,
+        targetBudgetTokens: boundary,
+        reserveTokens,
+        semanticCompact: false,
+    };
+    const budgetSourceTokens = force ? Math.max(pressureTokens, triggerTokens) : pressureTokens;
+    const compactBudget = compactTargetBudget(boundary, reserveTokens, budgetSourceTokens);
+    const budget = compactBudget || boundary;
+    try { await opts.onStageChange?.('compacting'); } catch { /* best-effort */ }
+    const provider = opts.provider || getProvider(session.provider) || null;
+    let compacted;
+    let compactError = null;
+    let semanticCompactResult = null;
+    let semanticCompactError = null;
+    let recallFastTrackResult = null;
+    let recallFastTrackError = null;
+    if (compactTypeIsRecallFastTrack(compactType)) {
+        try {
+            const recallPayload = await runRecallFastTrackForSession(session, messages, opts);
+            recallFastTrackResult = recallFastTrackCompactMessages(messages, budget, {
+                reserveTokens,
+                force: true,
+                recallText: recallPayload.recallText,
+                query: recallPayload.query,
+                querySha: recallPayload.querySha,
+                // Ingest just ran on the live transcript, so an empty recall dump
+                // means the memory pipeline is broken — do NOT erase history
+                // behind an empty summary shell. Empty recall now throws and is
+                // handled by the semantic fallback below (or recorded failure).
+                allowEmptyRecall: false,
+                tailTurns: positiveContextWindow(session.compaction?.tailTurns) || 2,
+                keepTokens: positiveContextWindow(session.compaction?.keepTokens ?? session.compaction?.keep?.tokens),
+                preserveRecentTokens: positiveContextWindow(session.compaction?.preserveRecentTokens),
+            });
+            if (Array.isArray(recallFastTrackResult?.messages)) {
+                compacted = recallFastTrackResult.messages;
+            }
+            if (recallPayload.cycle1Error) {
+                recallFastTrackError = new Error(String(recallPayload.cycle1Error));
+            }
+        } catch (err) {
+            recallFastTrackError = err;
+            compactError = err;
+            try {
+                process.stderr.write(`[session] recall-fasttrack ${mode} compact failed (sess=${session.id || 'unknown'}): ${err?.message || err}\n`);
+            } catch { /* best-effort */ }
+            // Degraded-compact fallback: recall-fasttrack failed (empty recall,
+            // ingest error, fit failure). Before recording a hard failure, try
+            // the semantic path once so auto-clear/manual compaction still makes
+            // progress WITHOUT shipping an empty-recall summary. History is only
+            // replaced when the semantic summary actually succeeds.
+            if (semanticCompactionEnabledForSession(session)
+                && provider && typeof provider.send === 'function') {
+                try {
+                    semanticCompactResult = await semanticCompactMessages(
+                        provider,
+                        messages,
+                        opts.model || session.model,
+                        budget,
+                        {
+                            reserveTokens,
+                            providerName: session.provider || provider?.name || null,
+                            sessionId: opts.sessionId || session.id || null,
+                            signal: opts.signal || null,
+                            promptCacheKey: session.promptCacheKey || null,
+                            providerCacheKey: session.promptCacheKey || null,
+                            timeoutMs: positiveContextWindow(session.compaction?.timeoutMs) || 30_000,
+                            tailTurns: positiveContextWindow(session.compaction?.tailTurns) || 2,
+                            keepTokens: positiveContextWindow(session.compaction?.keepTokens ?? session.compaction?.keep?.tokens),
+                            preserveRecentTokens: positiveContextWindow(session.compaction?.preserveRecentTokens),
+                            force: true,
+                        },
+                    );
+                    if (Array.isArray(semanticCompactResult?.messages)) {
+                        compacted = semanticCompactResult.messages;
+                        compactError = null;
+                        addCompactUsageToSession(session, semanticCompactResult.usage);
+                        try {
+                            process.stderr.write(`[session] degraded compact: recall-fasttrack failed, semantic fallback succeeded (sess=${session.id || 'unknown'}, mode=${mode})\n`);
+                        } catch { /* best-effort */ }
+                    }
+                } catch (fallbackErr) {
+                    semanticCompactError = fallbackErr;
+                    try {
+                        process.stderr.write(`[session] degraded compact: semantic fallback also failed (sess=${session.id || 'unknown'}): ${fallbackErr?.message || fallbackErr}\n`);
+                    } catch { /* best-effort */ }
+                }
+            }
+        }
+    } else if (compactTypeIsSemantic(compactType)) {
+        try {
+            if (!semanticCompactionEnabledForSession(session)) {
+                throw new Error('semantic compact is disabled for this session');
+            }
+            if (!provider || typeof provider.send !== 'function') {
+                throw new Error(`semantic compact provider unavailable: ${session.provider || 'unknown'}`);
+            }
+            semanticCompactResult = await semanticCompactMessages(
+                provider,
+                messages,
+                opts.model || session.model,
+                budget,
+                {
+                    reserveTokens,
+                    providerName: session.provider || provider?.name || null,
+                    sessionId: opts.sessionId || session.id || null,
+                    signal: opts.signal || null,
+                    promptCacheKey: session.promptCacheKey || null,
+                    providerCacheKey: session.promptCacheKey || null,
+                    timeoutMs: positiveContextWindow(session.compaction?.timeoutMs) || 30_000,
+                    tailTurns: positiveContextWindow(session.compaction?.tailTurns) || 2,
+                    keepTokens: positiveContextWindow(session.compaction?.keepTokens ?? session.compaction?.keep?.tokens),
+                    preserveRecentTokens: positiveContextWindow(session.compaction?.preserveRecentTokens),
+                    force: true,
+                },
+            );
+            if (Array.isArray(semanticCompactResult?.messages)) {
+                compacted = semanticCompactResult.messages;
+                addCompactUsageToSession(session, semanticCompactResult.usage);
+            }
+        } catch (err) {
+            semanticCompactError = err;
+            compactError = err;
+            try {
+                process.stderr.write(`[session] semantic ${mode} compact failed (sess=${session.id || 'unknown'}): ${err?.message || err}\n`);
+            } catch { /* best-effort */ }
+        }
+    }
+    if (!compacted && !compactError) {
+        compactError = new Error(`${compactType} compact produced no messages`);
+    }
+    // Anchor-independent prune safety net (mirror loop.mjs compact catch): when a
+    // non-recall (semantic) compact failed, try one non-LLM prune that needs no
+    // user anchor before recording failure, so Lead manual / auto-clear paths
+    // recover the same transcripts the loop path does. Gated off the recall
+    // path — a recall failure keeps its original contract (no silent prune).
+    if (!compacted && !recallFastTrackError) {
+        try {
+            const acceptThreshold = compactEffectiveBudget(budget, { reserveTokens });
+            const salvaged = pruneToolOutputsUnanchored(messages, budget, { reserveTokens });
+            // pruneToolOutputsUnanchored ALWAYS returns a fresh reconciled array
+            // (never the input identity), so `salvaged !== messages` is always
+            // true and cannot detect a no-op. Compare by element identity so a
+            // transcript that already fit (nothing pruned) is NOT falsely accepted
+            // as a recovery — that would clear compactError and unconditionally
+            // invalidate providerState for an unchanged transcript.
+            if (Array.isArray(salvaged)
+                && messagesChanged(messages, salvaged)
+                && estimateMessagesTokens(salvaged) <= acceptThreshold) {
+                compacted = salvaged;
+                compactError = null;
+                try {
+                    process.stderr.write(`[session] compact fallback prune recovered (sess=${session.id || 'unknown'}, mode=${mode})\n`);
+                } catch { /* best-effort */ }
+            }
+        } catch { /* fall through to failure record */ }
+    }
+    if (!compacted) {
+        const now = Date.now();
+        session.compaction = {
+            ...(session.compaction || {}),
+            auto: mode === 'auto' ? true : session.compaction?.auto !== false,
+            boundaryTokens: boundary,
+            triggerTokens,
+            bufferTokens,
+            bufferRatio,
+            reserveTokens,
+            lastStage: mode === 'auto' ? 'post_turn_failed' : 'manual_failed',
+            lastBeforeTokens: beforeTokens,
+            lastAfterTokens: beforeTokens,
+            lastBeforeMessageTokens: beforeMessageTokens,
+            lastAfterMessageTokens: beforeMessageTokens,
+            lastPressureTokens: pressureTokens,
+            lastCheckedAt: now,
+            lastChanged: false,
+            type: compactType,
+            compactType,
+            lastCompactType: compactType,
+            lastSemantic: false,
+            lastSemanticError: semanticCompactError?.message || null,
+            lastRecallFastTrack: false,
+            lastRecallFastTrackError: recallFastTrackError?.message || null,
+            lastError: compactError?.message || semanticCompactError?.message || recallFastTrackError?.message || String(compactError || semanticCompactError || recallFastTrackError || 'compact failed'),
+        };
+        return {
+            changed: false,
+            error: session.compaction.lastError,
+            compactType,
+            beforeMessages: messages.length,
+            afterMessages: messages.length,
+            beforeTokens,
+            afterTokens: beforeTokens,
+            beforeMessageTokens,
+            afterMessageTokens: beforeMessageTokens,
+            pressureTokens,
+            triggerTokens,
+            bufferTokens,
+            bufferRatio,
+            boundaryTokens: boundary,
+            budgetTokens: boundary,
+            targetBudgetTokens: budget,
+            reserveTokens,
+            semanticCompact: false,
+            semanticError: semanticCompactError?.message || null,
+            recallFastTrack: false,
+            recallFastTrackError: recallFastTrackError?.message || null,
+        };
+    }
+    let beforeEncoded = '';
+    let afterEncoded = '';
+    try { beforeEncoded = JSON.stringify(messages); } catch { beforeEncoded = ''; }
+    try { afterEncoded = JSON.stringify(compacted); } catch { afterEncoded = ''; }
+    const afterMessageTokens = estimateMessagesTokens(compacted);
+    const afterTokens = afterMessageTokens + reserveTokens;
+    const changed = beforeEncoded && afterEncoded
+        ? beforeEncoded !== afterEncoded
+        : (compacted.length !== messages.length || afterMessageTokens !== beforeMessageTokens);
+    const unchangedReason = changed ? null : (force ? 'nothing to compact' : 'below threshold');
+    const now = Date.now();
+    session.messages = compacted;
+    session.providerState = undefined;
+    session.compaction = {
+        ...(session.compaction || {}),
+        auto: mode === 'auto' ? true : session.compaction?.auto !== false,
+        boundaryTokens: boundary,
+        triggerTokens,
+        bufferTokens,
+        bufferRatio,
+        reserveTokens,
+        type: compactType,
+        compactType,
+        lastCompactType: compactType,
+        lastStage: mode === 'auto' ? 'post_turn' : 'manual',
+        lastBeforeTokens: beforeTokens,
+        lastAfterTokens: afterTokens,
+        lastBeforeMessageTokens: beforeMessageTokens,
+        lastAfterMessageTokens: afterMessageTokens,
+        lastPressureTokens: pressureTokens,
+        lastCheckedAt: now,
+        lastChanged: changed,
+        lastChangedAt: changed ? now : session.compaction?.lastChangedAt || null,
+        lastCompactAt: changed ? now : session.compaction?.lastCompactAt || null,
+        lastSemantic: semanticCompactResult?.semantic === true,
+        lastSemanticError: semanticCompactError?.message || null,
+        lastRecallFastTrack: recallFastTrackResult?.recallFastTrack === true,
+        lastRecallFastTrackError: recallFastTrackError?.message || null,
+        lastRecallFastTrackQuerySha: recallFastTrackResult?.query ? createHash('sha256').update(recallFastTrackResult.query).digest('hex').slice(0, 16) : null,
+        lastSemanticUsage: semanticCompactResult?.usage ? {
+            inputTokens: semanticCompactResult.usage.inputTokens || 0,
+            outputTokens: semanticCompactResult.usage.outputTokens || 0,
+            cachedTokens: semanticCompactResult.usage.cachedTokens || 0,
+            cacheWriteTokens: semanticCompactResult.usage.cacheWriteTokens || 0,
+        } : null,
+        compactCount: (session.compaction?.compactCount || 0) + (changed ? 1 : 0),
+    };
+    if (changed && mode === 'auto') session.lastContextTokensStaleAfterCompact = true;
+    return {
+        changed,
+        reason: unchangedReason,
+        compactType,
+        beforeMessages: messages.length,
+        afterMessages: compacted.length,
+        beforeTokens,
+        afterTokens,
+        beforeMessageTokens,
+        afterMessageTokens,
+        pressureTokens,
+        triggerTokens,
+        bufferTokens,
+        bufferRatio,
+        boundaryTokens: boundary,
+        budgetTokens: boundary,
+        targetBudgetTokens: budget,
+        reserveTokens,
+        semanticCompact: semanticCompactResult?.semantic === true,
+        semanticError: semanticCompactError?.message || null,
+        recallFastTrack: recallFastTrackResult?.recallFastTrack === true,
+        recallFastTrackError: recallFastTrackError?.message || null,
+        usage: semanticCompactResult?.usage || null,
+    };
+}

package/src/runtime/agent/orchestrator/session/manager/context-meta.mjs

@@ -35,14 +35,17 @@ const CONTEXT_WINDOWS = {
 // runtime agree on the boundary the first time a model is routed. Local models
 // (llama/mistral/phi/qwen/gemma) stay small so an unknown local id never claims
 // a giant window.
-export function guessContextWindow(model) {
+const LOCAL_PROVIDERS = new Set(['ollama', 'lmstudio', 'llamacpp', 'llama.cpp', 'local', '']);
+export function guessContextWindow(model, provider = null) {
     if (CONTEXT_WINDOWS[model])
         return CONTEXT_WINDOWS[model];
     const m = String(model || '').toLowerCase();
+    const p = String(provider || '').toLowerCase();
+    const isLocalProvider = LOCAL_PROVIDERS.has(p);
     // Local/self-hosted families — never inflate an unknown local id.
-    if (m.includes('llama') || m.includes('mistral') || m.includes('mixtral')
+    if (isLocalProvider && (m.includes('llama') || m.includes('mistral') || m.includes('mixtral')
         || m.includes('phi') || m.includes('qwen') || m.includes('gemma')
-        || m.includes('deepseek-r1') || m.includes('codellama'))
+        || m.includes('deepseek-r1') || m.includes('codellama')))
         return 8192;
     // Current hosted families by name pattern.
     if (m.startsWith('claude-opus') || m.startsWith('claude-sonnet')) return 1000000;
@@ -148,7 +151,7 @@ export function resolveSessionContextMeta(provider, model, seed = {}) {
         || positiveContextWindow(seed.rawContextWindow)
         || positiveContextWindow(seed.raw_context_window)
         || positiveContextWindow(seed.contextWindow)
-        || guessContextWindow(model);
+        || guessContextWindow(model, providerNameOf(provider));
     const effectiveContextWindowPercent = boundedPercent(
         seed.effectiveContextWindowPercent
             ?? seed.effective_context_window_percent

package/src/runtime/agent/orchestrator/session/manager/prompt-utils.mjs

@@ -1,6 +1,7 @@
 // Prompt content + temporal helpers, extracted verbatim from manager.mjs
 // (behavior-preserving). Pure string/date utilities with no session state.
 import { isInternalRuntimeNotificationText as contractIsInternalRuntimeNotificationText } from '../../../../shared/tool-execution-contract.mjs';
+import { SUMMARY_PREFIX } from '../compact.mjs';
 
 export function promptContentText(content) {
     if (typeof content === 'string') return content;
@@ -124,11 +125,22 @@ export function isProtectedContextUserMessage(message) {
         && message.content.trimStart().startsWith('<system-reminder>');
 }
 
+// Compact summary messages (role:'user', content startsWith SUMMARY_PREFIX)
+// are synthetic anchors, not a real human turn — they must not count as
+// "user conversation" or the post-clear/post-compact session-start block
+// would be wrongly suppressed on the next real user turn.
+function isSummaryAnchorMessage(message) {
+    return message?.role === 'user'
+        && typeof message.content === 'string'
+        && message.content.startsWith(SUMMARY_PREFIX);
+}
+
 export function hasUserConversationMessage(messages) {
     return (Array.isArray(messages) ? messages : []).some((message) => (
         message?.role === 'user'
         && !isProtectedContextUserMessage(message)
         && !isReferenceFilesMessage(message)
+        && !isSummaryAnchorMessage(message)
     ));
 }