@pellux/goodvibes-sdk 0.18.13 → 0.18.15

package/dist/_internal/platform/core/event-replay.js

@@ -0,0 +1,224 @@
+import { randomUUID } from 'node:crypto';
+import { logger } from '@pellux/goodvibes-sdk/platform/utils/logger';
+/** Events that are significant enough to track for replay. */
+export const TRACKED_EVENTS = [
+    'AGENT_COMPLETED',
+    'AGENT_FAILED',
+    'WORKFLOW_STATE_CHANGED',
+    'WORKFLOW_CHAIN_PASSED',
+    'WORKFLOW_CHAIN_FAILED',
+];
+function generateId() {
+    return randomUUID();
+}
+/**
+ * EventReplayQueue — holds events and replays unacknowledged ones.
+ *
+ * Grace period: events are held for 1 full LLM turn after they fire.
+ * After the grace period, if unacknowledged, they are replayed as
+ * system messages in the conversation.
+ *
+ * Replay strategy:
+ * - After 1 turn grace: replay once as system message
+ * - After 2nd replay: replay with emphasis
+ * - After 3rd replay: mark as dropped, log warning
+ * - Max 3 replays per event
+ */
+export class EventReplayQueue {
+    queue = [];
+    currentTurn = 0;
+    droppedCount = 0;
+    maxReplays;
+    graceTurns;
+    constructor(maxReplays = 3, graceTurns = 1) {
+        this.maxReplays = maxReplays;
+        this.graceTurns = graceTurns;
+    }
+    /**
+     * Enqueue an event for tracking.
+     * Called when significant events fire (agent complete, WRFC state change, etc.)
+     * Returns the assigned event ID.
+     */
+    enqueue(eventName, payload) {
+        const id = generateId();
+        this.queue.push({
+            id,
+            eventName,
+            payload,
+            timestamp: Date.now(),
+            acknowledged: false,
+            turnCount: this.currentTurn,
+            replayCount: 0,
+        });
+        return id;
+    }
+    /**
+     * Mark an event as acknowledged by ID.
+     * Called when the model demonstrates awareness of the event.
+     */
+    acknowledge(eventId) {
+        const event = this.queue.find((e) => e.id === eventId);
+        if (event) {
+            event.acknowledged = true;
+        }
+    }
+    /**
+     * Acknowledge all events matching a predicate.
+     * E.g., acknowledge all events for a specific agent ID.
+     * Returns the number of events acknowledged.
+     */
+    acknowledgeWhere(predicate) {
+        let count = 0;
+        for (const event of this.queue) {
+            if (!event.acknowledged && predicate(event)) {
+                event.acknowledged = true;
+                count++;
+            }
+        }
+        return count;
+    }
+    /**
+     * Signal that an LLM turn has completed.
+     * Increments the turn counter and returns events that need replaying.
+     * Events that exceed maxReplays are dropped (logged and removed from queue).
+     */
+    onTurnComplete() {
+        this.currentTurn++;
+        const toReplay = [];
+        const toRemove = [];
+        for (const event of this.queue) {
+            if (event.acknowledged)
+                continue;
+            const turnsElapsed = this.currentTurn - event.turnCount;
+            if (turnsElapsed <= this.graceTurns)
+                continue;
+            if (event.replayCount >= this.maxReplays) {
+                // Drop: exceeded max replays
+                logger.debug(`[EventReplayQueue] Dropping event ${event.id} (${event.eventName}) after ${event.replayCount} replays — model did not acknowledge.`);
+                toRemove.push(event.id);
+                this.droppedCount++;
+            }
+            else {
+                event.replayCount++;
+                toReplay.push(event);
+            }
+        }
+        // Remove dropped events
+        if (toRemove.length > 0) {
+            const toRemoveSet = new Set(toRemove);
+            this.queue = this.queue.filter((e) => !toRemoveSet.has(e.id));
+        }
+        return toReplay;
+    }
+    /**
+     * Format replay events as system messages ready to inject into the conversation.
+     */
+    formatReplays(events) {
+        return events.map((event) => {
+            const turnsAgo = this.currentTurn - event.turnCount;
+            const base = this._formatEventMessage(event, turnsAgo);
+            if (event.replayCount >= this.maxReplays) {
+                return `[Replay][URGENT] ${base}`;
+            }
+            else if (event.replayCount >= Math.ceil(this.maxReplays * (2 / 3))) {
+                return `[Replay][Action Required] ${base}`;
+            }
+            return `[Replay] ${base}`;
+        });
+    }
+    /**
+     * Get queue stats for telemetry and debugging.
+     */
+    getStats() {
+        const acknowledged = this.queue.filter((e) => e.acknowledged).length;
+        const pending = this.queue.filter((e) => !e.acknowledged).length;
+        const replayed = this.queue.filter((e) => e.replayCount > 0).length;
+        return {
+            queued: this.queue.length,
+            acknowledged,
+            pending,
+            replayed,
+            dropped: this.droppedCount,
+        };
+    }
+    /**
+     * Clear all events (e.g., on session reset).
+     */
+    clear() {
+        this.queue = [];
+        this.currentTurn = 0;
+        this.droppedCount = 0;
+    }
+    /** Format a human-readable message for a single event. */
+    _formatEventMessage(event, turnsAgo) {
+        const turnWord = turnsAgo === 1 ? 'turn' : 'turns';
+        const payload = event.payload;
+        switch (event.eventName) {
+            case 'AGENT_COMPLETED': {
+                const id = payload?.id ?? 'unknown';
+                const output = payload?.result?.output;
+                const taskStr = output ? ` task "${output.slice(0, 60)}"` : '';
+                return `Agent ${id} completed${taskStr} (first notified ${turnsAgo} ${turnWord} ago)`;
+            }
+            case 'AGENT_FAILED': {
+                const id = payload?.id ?? 'unknown';
+                const err = payload?.error;
+                const errStr = err?.message ? `: ${err.message}` : '';
+                return `Agent ${id} failed${errStr} (first notified ${turnsAgo} ${turnWord} ago)`;
+            }
+            case 'WORKFLOW_STATE_CHANGED': {
+                const chainId = payload?.chainId ?? 'unknown';
+                const from = payload?.from ?? '?';
+                const to = payload?.to ?? '?';
+                return `WRFC chain ${chainId} transitioned ${from} \u2192 ${to} — waiting for action (first notified ${turnsAgo} ${turnWord} ago)`;
+            }
+            case 'WORKFLOW_CHAIN_PASSED': {
+                const chainId = payload?.chainId ?? 'unknown';
+                return `WRFC chain ${chainId} passed — waiting for action (first notified ${turnsAgo} ${turnWord} ago)`;
+            }
+            case 'WORKFLOW_CHAIN_FAILED': {
+                const chainId = payload?.chainId ?? 'unknown';
+                const reason = payload?.reason ?? 'unknown reason';
+                return `WRFC chain ${chainId} failed: ${reason} — waiting for action (first notified ${turnsAgo} ${turnWord} ago)`;
+            }
+            default: {
+                return `Event ${event.eventName} (id: ${event.id}) fired ${turnsAgo} ${turnWord} ago — waiting for acknowledgment`;
+            }
+        }
+    }
+    /**
+     * Wire up listeners for replay-significant events on the typed runtime bus.
+     * Returns an unsubscribe function that removes all listeners.
+     */
+    static attachToRuntimeBus(bus, queue) {
+        const unsubs = [];
+        unsubs.push(bus.on('AGENT_COMPLETED', ({ payload }) => {
+            queue.enqueue('AGENT_COMPLETED', {
+                id: payload.agentId,
+                result: {
+                    id: payload.agentId,
+                    success: true,
+                    output: payload.output ?? '',
+                    toolCallsMade: payload.toolCallsMade ?? 0,
+                    duration: payload.durationMs,
+                },
+            });
+        }));
+        unsubs.push(bus.on('AGENT_FAILED', ({ payload }) => {
+            queue.enqueue('AGENT_FAILED', {
+                id: payload.agentId,
+                error: new Error(payload.error),
+            });
+        }));
+        unsubs.push(bus.on('WORKFLOW_STATE_CHANGED', ({ payload }) => {
+            queue.enqueue('WORKFLOW_STATE_CHANGED', payload);
+        }));
+        unsubs.push(bus.on('WORKFLOW_CHAIN_PASSED', ({ payload }) => {
+            queue.enqueue('WORKFLOW_CHAIN_PASSED', payload);
+        }));
+        unsubs.push(bus.on('WORKFLOW_CHAIN_FAILED', ({ payload }) => {
+            queue.enqueue('WORKFLOW_CHAIN_FAILED', payload);
+        }));
+        return () => unsubs.forEach((u) => u());
+    }
+}

package/dist/_internal/platform/core/orchestrator-context-runtime.d.ts

@@ -0,0 +1,58 @@
+import type { ConversationManager } from './conversation.js';
+import type { ConfigManager } from '../config/manager.js';
+import type { ModelDefinition, ProviderRegistry } from '../providers/registry.js';
+import type { SessionMemoryStore } from '@pellux/goodvibes-sdk/platform/core/session-memory';
+import type { SessionLineageTracker } from '@pellux/goodvibes-sdk/platform/core/session-lineage';
+import type { AgentManager } from '../tools/agent/index.js';
+import type { WrfcController } from '../agents/wrfc-controller.js';
+import type { ExecutionPlanManager } from '@pellux/goodvibes-sdk/platform/core/execution-plan';
+import type { RuntimeEventBus } from '../runtime/events/index.js';
+import type { HookEvent, HookResult } from '@pellux/goodvibes-sdk/platform/hooks/types';
+type HookDispatcherLike = {
+    fire(event: HookEvent): Promise<HookResult>;
+};
+type EmitterContextFactory = (turnId: string) => import('../runtime/emitters/index.js').EmitterContext;
+type CatalogTier = 'free' | 'paid' | 'subscription';
+export type PreflightDeps = {
+    conversation: ConversationManager;
+    requestRender: () => void;
+    hookDispatcher: HookDispatcherLike | null;
+    configManager: Pick<ConfigManager, 'get'>;
+    providerRegistry: ProviderRegistry;
+    sessionLineageTracker: Pick<SessionLineageTracker, 'getEntries' | 'getCompactionCount'>;
+    sessionId: string;
+    agentManager: Pick<AgentManager, 'list'>;
+    wrfcController: Pick<WrfcController, 'listChains'>;
+    planManager: Pick<ExecutionPlanManager, 'getActive'> | null;
+    sessionMemoryStore: Pick<SessionMemoryStore, 'list'> | null;
+    runtimeBus: RuntimeEventBus | null;
+    emitterContext: EmitterContextFactory;
+    isCompacting: boolean;
+    setIsCompacting: (value: boolean) => void;
+};
+export declare function checkContextWindowPreflight(deps: PreflightDeps, turnId: string, model: ModelDefinition): Promise<'ok' | 'compacted' | 'error'>;
+export declare function emitContextOverflowError(conversation: {
+    addSystemMessage: (message: string) => void;
+}, requestRender: () => void, _turnId: string, estimatedTokens: number, contextWindow: number, modelDisplayName: string, providerRegistry: Pick<ProviderRegistry, 'listModels' | 'getContextWindowForModel'>, tier?: CatalogTier): void;
+export type PostTurnContextDeps = {
+    conversation: ConversationManager;
+    agentManager: Pick<AgentManager, 'list'>;
+    wrfcController: Pick<WrfcController, 'listChains'>;
+    planManager: Pick<ExecutionPlanManager, 'getActive'> | null;
+    sessionMemoryStore: Pick<SessionMemoryStore, 'list'> | null;
+    runtimeBus: RuntimeEventBus | null;
+    emitterContext: EmitterContextFactory;
+    hookDispatcher: HookDispatcherLike | null;
+    configManager: Pick<ConfigManager, 'get'>;
+    providerRegistry: ProviderRegistry;
+    sessionLineageTracker: Pick<SessionLineageTracker, 'getEntries' | 'getCompactionCount'>;
+    sessionId: string;
+    requestRender: () => void;
+    isCompacting: boolean;
+    setIsCompacting: (value: boolean) => void;
+    lastWarningBracket: number;
+    setLastWarningBracket: (value: number) => void;
+};
+export declare function handlePostTurnContextMaintenance(deps: PostTurnContextDeps, turnId: string, totalTokens: number): Promise<void>;
+export {};
+//# sourceMappingURL=orchestrator-context-runtime.d.ts.map

package/dist/_internal/platform/core/orchestrator-context-runtime.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"orchestrator-context-runtime.d.ts","sourceRoot":"","sources":["../../../../src/_internal/platform/core/orchestrator-context-runtime.ts"],"names":[],"mappings":"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"}

package/dist/_internal/platform/core/orchestrator-context-runtime.js

@@ -0,0 +1,281 @@
+import { logger } from '@pellux/goodvibes-sdk/platform/utils/logger';
+import { estimateConversationTokens, COMPACTION_BUFFER_TOKENS, SMALL_WINDOW_THRESHOLD, compactSmallWindow, shouldAutoCompact } from './context-compaction.js';
+import { emitOpsContextWarning } from '../runtime/emitters/index.js';
+import { summarizeError } from '@pellux/goodvibes-sdk/platform/utils/error-display';
+function normalizeCatalogTier(tier) {
+    if (tier === 'free')
+        return 'free';
+    if (tier === 'subscription')
+        return 'subscription';
+    if (tier === 'standard' || tier === 'premium')
+        return 'paid';
+    return undefined;
+}
+function findLargerContextModels(providerRegistry, minContext, tier, limit = 3) {
+    return providerRegistry
+        .listModels()
+        .filter((model) => model.selectable)
+        .map((model) => ({
+        id: model.id,
+        displayName: model.displayName,
+        context: providerRegistry.getContextWindowForModel(model),
+        tier: normalizeCatalogTier(model.tier),
+    }))
+        .filter((model) => model.context > minContext && (tier === undefined || model.tier === tier))
+        .sort((a, b) => b.context - a.context)
+        .slice(0, limit)
+        .map(({ id, displayName, context }) => ({ id, displayName, context }));
+}
+export async function checkContextWindowPreflight(deps, turnId, model) {
+    const contextWindow = deps.providerRegistry.getContextWindowForModel(model);
+    const tier = normalizeCatalogTier(model.tier);
+    if (contextWindow <= 0)
+        return 'ok';
+    const messages = deps.conversation.getMessagesForLLM();
+    const estimatedTokens = estimateConversationTokens(messages);
+    if (estimatedTokens <= contextWindow)
+        return 'ok';
+    const threshold = deps.configManager.get('behavior.autoCompactThreshold');
+    const autoCompactEnabled = threshold > 0;
+    if (autoCompactEnabled && !deps.isCompacting) {
+        logger.info('Orchestrator: context window pre-flight - auto-compacting before chat call', {
+            modelId: model.id,
+            estimatedTokens,
+            contextWindow,
+        });
+        deps.setIsCompacting(true);
+        deps.conversation.addSystemMessage(`Context pre-check: request (~${Math.round(estimatedTokens / 1000)}K tokens) exceeds ${model.displayName} context window (${Math.round(contextWindow / 1000)}K). Auto-compacting...`);
+        deps.requestRender();
+        if (deps.hookDispatcher) {
+            const preResult = await deps.hookDispatcher.fire({
+                path: 'Pre:compact:preflight',
+                phase: 'Pre',
+                category: 'compact',
+                specific: 'preflight',
+                sessionId: deps.sessionId,
+                timestamp: Date.now(),
+                payload: { trigger: 'preflight', estimatedTokens, contextWindow },
+            }).catch((err) => {
+                logger.debug('Pre:compact:preflight hook error', { error: summarizeError(err) });
+                return { ok: true };
+            });
+            if (preResult.decision === 'deny') {
+                deps.setIsCompacting(false);
+                logger.info('Orchestrator: Pre:compact:preflight denied by hook - skipping preflight compact', { reason: preResult.reason });
+                return 'ok';
+            }
+        }
+        try {
+            const preflightCtx = {
+                messages,
+                sessionMemories: deps.sessionMemoryStore?.list() ?? [],
+                lineageEntries: deps.sessionLineageTracker.getEntries(),
+                agents: deps.agentManager.list().filter(a => a.status === 'running' || a.status === 'pending'),
+                wrfcChains: deps.wrfcController.listChains(),
+                activePlan: deps.planManager?.getActive(deps.sessionId) ?? null,
+                compactionCount: deps.sessionLineageTracker.getCompactionCount(),
+                contextWindow,
+                trigger: 'auto',
+                extractionModelId: model.id,
+                extractionProvider: model.provider,
+            };
+            await deps.conversation.compact(deps.providerRegistry, model.id, 'auto', model.provider, preflightCtx);
+            deps.conversation.addSystemMessage('Context compacted. Retrying request...');
+            if (deps.hookDispatcher) {
+                deps.hookDispatcher.fire({
+                    path: 'Post:compact:preflight',
+                    phase: 'Post',
+                    category: 'compact',
+                    specific: 'preflight',
+                    sessionId: deps.sessionId,
+                    timestamp: Date.now(),
+                    payload: { trigger: 'preflight', estimatedTokens, contextWindow },
+                }).catch((err) => { logger.debug('Post:compact:preflight hook error', { error: summarizeError(err) }); });
+            }
+        }
+        catch (compactErr) {
+            const msg = compactErr instanceof Error ? compactErr.message : String(compactErr);
+            logger.error('Orchestrator: pre-flight compact failed', { error: msg });
+            deps.conversation.addSystemMessage(`Auto-compact failed: ${msg}.`);
+            if (deps.hookDispatcher) {
+                deps.hookDispatcher.fire({
+                    path: 'Fail:compact:preflight',
+                    phase: 'Fail',
+                    category: 'compact',
+                    specific: 'preflight',
+                    sessionId: deps.sessionId,
+                    timestamp: Date.now(),
+                    payload: { trigger: 'preflight', estimatedTokens, contextWindow, error: msg },
+                }).catch((err) => { logger.debug('Fail:compact:preflight hook error', { error: summarizeError(err) }); });
+            }
+        }
+        finally {
+            deps.setIsCompacting(false);
+        }
+        const tokensAfter = estimateConversationTokens(deps.conversation.getMessagesForLLM());
+        if (tokensAfter <= contextWindow) {
+            return 'compacted';
+        }
+        emitContextOverflowError(deps.conversation, deps.requestRender, turnId, estimatedTokens, contextWindow, model.displayName, deps.providerRegistry, tier);
+        return 'error';
+    }
+    emitContextOverflowError(deps.conversation, deps.requestRender, turnId, estimatedTokens, contextWindow, model.displayName, deps.providerRegistry, tier);
+    return 'error';
+}
+export function emitContextOverflowError(conversation, requestRender, _turnId, estimatedTokens, contextWindow, modelDisplayName, providerRegistry, tier) {
+    const requestK = Math.round(estimatedTokens / 1000);
+    const contextK = Math.round(contextWindow / 1000);
+    const alternatives = findLargerContextModels(providerRegistry, contextWindow, tier, 3);
+    let msg = `Request (~${requestK}K tokens) exceeds ${modelDisplayName} context window (${contextK}K). ` +
+        `Use /compact to reduce context or switch to a larger model.`;
+    if (alternatives.length > 0) {
+        const altNames = alternatives.map(a => `${a.displayName} (${Math.round(a.context / 1000)}K)`).join(', ');
+        msg += ` Larger-context alternatives: ${altNames}.`;
+    }
+    logger.warn('Orchestrator: context window overflow', {
+        estimatedTokens,
+        contextWindow,
+        modelDisplayName,
+        alternatives: alternatives.map(a => a.id),
+    });
+    conversation.addSystemMessage(msg);
+    requestRender();
+}
+export async function handlePostTurnContextMaintenance(deps, turnId, totalTokens) {
+    const currentModel = deps.providerRegistry.getCurrentModel();
+    const maxTokens = deps.providerRegistry.getContextWindowForModel(currentModel);
+    if (maxTokens <= 0)
+        return;
+    const usagePct = Math.round((totalTokens / maxTokens) * 100);
+    const configuredThreshold = deps.configManager.get('behavior.autoCompactThreshold');
+    const warningsEnabled = deps.configManager.get('behavior.staleContextWarnings');
+    const autoCompactEnabled = configuredThreshold > 0;
+    const bracket = Math.floor(usagePct / 10) * 10;
+    if (autoCompactEnabled &&
+        shouldAutoCompact({
+            currentTokens: totalTokens,
+            contextWindow: maxTokens,
+            isCompacting: deps.isCompacting,
+        })) {
+        deps.setIsCompacting(true);
+        deps.conversation.addSystemMessage(`Context usage at ${usagePct}% (${totalTokens}/${maxTokens} tokens). Auto-compacting conversation...`);
+        if (deps.runtimeBus) {
+            emitOpsContextWarning(deps.runtimeBus, deps.emitterContext(turnId), {
+                usage: usagePct,
+                threshold: COMPACTION_BUFFER_TOKENS,
+            });
+        }
+        deps.requestRender();
+        let skipAutoCompact = false;
+        if (deps.hookDispatcher) {
+            const preAutoResult = await deps.hookDispatcher.fire({
+                path: 'Pre:compact:auto',
+                phase: 'Pre',
+                category: 'compact',
+                specific: 'auto',
+                sessionId: deps.sessionId,
+                timestamp: Date.now(),
+                payload: { trigger: 'auto', usagePct, totalTokens, maxTokens },
+            }).catch((err) => {
+                logger.debug('Pre:compact:auto hook error', { error: summarizeError(err) });
+                return { ok: true };
+            });
+            if (preAutoResult.decision === 'deny') {
+                deps.setIsCompacting(false);
+                skipAutoCompact = true;
+                logger.info('Orchestrator: Pre:compact:auto denied by hook - skipping auto-compact', { reason: preAutoResult.reason });
+            }
+        }
+        try {
+            const currentMsgs = deps.conversation.getMessagesForLLM();
+            const useSmallWindow = maxTokens < SMALL_WINDOW_THRESHOLD;
+            if (!skipAutoCompact && useSmallWindow) {
+                try {
+                    const compactedMsgs = compactSmallWindow(currentMsgs, 10);
+                    deps.conversation.replaceMessagesForLLM(compactedMsgs);
+                    deps.setIsCompacting(false);
+                    deps.setLastWarningBracket(0);
+                    deps.conversation.addSystemMessage('Context auto-compacted (small window mode). Kept last 10 messages.');
+                    deps.requestRender();
+                }
+                catch (err) {
+                    deps.setIsCompacting(false);
+                    const msg = summarizeError(err);
+                    logger.error('Orchestrator: small-window auto-compact failed', { error: msg });
+                    deps.conversation.addSystemMessage(`Auto-compact failed: ${msg}. Use /compact to retry manually.`);
+                    deps.requestRender();
+                }
+            }
+            else if (!skipAutoCompact) {
+                const compactionCtx = {
+                    messages: currentMsgs,
+                    sessionMemories: deps.sessionMemoryStore?.list() ?? [],
+                    lineageEntries: deps.sessionLineageTracker.getEntries(),
+                    agents: deps.agentManager.list().filter(a => a.status === 'running' || a.status === 'pending'),
+                    wrfcChains: deps.wrfcController.listChains(),
+                    activePlan: deps.planManager?.getActive(deps.sessionId) ?? null,
+                    compactionCount: deps.sessionLineageTracker.getCompactionCount(),
+                    contextWindow: maxTokens,
+                    trigger: 'auto',
+                    extractionModelId: currentModel.id,
+                    extractionProvider: currentModel.provider,
+                };
+                void deps.conversation.compact(deps.providerRegistry, currentModel.id, 'auto', currentModel.provider, compactionCtx).then(() => {
+                    deps.setIsCompacting(false);
+                    deps.setLastWarningBracket(0);
+                    deps.conversation.addSystemMessage('Context auto-compacted. Conversation history summarized to free context window.');
+                    deps.requestRender();
+                    logger.info('Orchestrator: auto-compact complete', { modelId: currentModel.id, usagePct });
+                    if (deps.hookDispatcher) {
+                        deps.hookDispatcher.fire({
+                            path: 'Post:compact:auto',
+                            phase: 'Post',
+                            category: 'compact',
+                            specific: 'auto',
+                            sessionId: deps.sessionId,
+                            timestamp: Date.now(),
+                            payload: { trigger: 'auto', usagePct, totalTokens, maxTokens },
+                        }).catch((err) => { logger.debug('Post:compact:auto hook error', { error: summarizeError(err) }); });
+                    }
+                }).catch((err) => {
+                    deps.setIsCompacting(false);
+                    const msg = summarizeError(err);
+                    logger.error('Orchestrator: auto-compact failed', { error: msg });
+                    deps.conversation.addSystemMessage(`Auto-compact failed: ${msg}. Use /compact to retry manually.`);
+                    deps.requestRender();
+                    if (deps.hookDispatcher) {
+                        deps.hookDispatcher.fire({
+                            path: 'Fail:compact:auto',
+                            phase: 'Fail',
+                            category: 'compact',
+                            specific: 'auto',
+                            sessionId: deps.sessionId,
+                            timestamp: Date.now(),
+                            payload: { trigger: 'auto', usagePct, totalTokens, maxTokens, error: msg },
+                        }).catch((err) => { logger.debug('Fail:compact:auto hook error', { error: summarizeError(err) }); });
+                    }
+                });
+            }
+        }
+        catch (compactErr) {
+            deps.setIsCompacting(false);
+            logger.error('Auto-compact failed', { error: String(compactErr) });
+            deps.conversation.addSystemMessage(`[Compact] Auto-compaction failed: ${String(compactErr)}`);
+            deps.requestRender();
+        }
+    }
+    else if (warningsEnabled &&
+        autoCompactEnabled &&
+        (maxTokens - totalTokens) <= COMPACTION_BUFFER_TOKENS * 2 &&
+        bracket > deps.lastWarningBracket) {
+        deps.setLastWarningBracket(bracket);
+        deps.conversation.addSystemMessage(`Context usage at ${usagePct}% (${totalTokens}/${maxTokens} tokens). Auto-compact will trigger within ${COMPACTION_BUFFER_TOKENS.toLocaleString()} remaining tokens.`);
+        if (deps.runtimeBus) {
+            emitOpsContextWarning(deps.runtimeBus, deps.emitterContext(turnId), {
+                usage: usagePct,
+                threshold: COMPACTION_BUFFER_TOKENS,
+            });
+        }
+        deps.requestRender();
+    }
+}

package/dist/_internal/platform/core/orchestrator-follow-up-runtime.d.ts

@@ -0,0 +1,34 @@
+import type { ConversationManager } from './conversation.js';
+import type { ModelDefinition, ProviderRegistry } from '../providers/registry.js';
+import { type ConversationFollowUpItem } from '@pellux/goodvibes-sdk/platform/core/conversation-follow-ups';
+import { normalizeUsage } from './orchestrator-runtime.js';
+export interface OrchestratorFollowUpRuntimeOptions {
+    readonly conversation: ConversationManager;
+    readonly getViewportHeight: () => number;
+    readonly scrollToEnd: (height: number) => void;
+    readonly getSystemPrompt: () => string;
+    readonly requestRender: () => void;
+    readonly getThinkingState: () => {
+        readonly isThinking: boolean;
+        readonly isCompacting: boolean;
+    };
+    readonly getQueuedUserMessageCount: () => number;
+    readonly getProviderRegistry: () => ProviderRegistry;
+    readonly getCurrentModel: () => ModelDefinition;
+    readonly routeLowPriorityMessage: (message: string) => void;
+    readonly applyUsage: (usage: ReturnType<typeof normalizeUsage>) => void;
+}
+export declare class OrchestratorFollowUpRuntime {
+    private readonly options;
+    private queue;
+    private flushScheduled;
+    private isRunning;
+    private readonly recentKeys;
+    constructor(options: OrchestratorFollowUpRuntimeOptions);
+    enqueue(item: ConversationFollowUpItem): void;
+    scheduleFlush(): void;
+    private pruneRecent;
+    private takeBatch;
+    private flush;
+}
+//# sourceMappingURL=orchestrator-follow-up-runtime.d.ts.map

package/dist/_internal/platform/core/orchestrator-follow-up-runtime.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"orchestrator-follow-up-runtime.d.ts","sourceRoot":"","sources":["../../../../src/_internal/platform/core/orchestrator-follow-up-runtime.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,mBAAmB,CAAC;AAC7D,OAAO,KAAK,EAAE,eAAe,EAAE,gBAAgB,EAAE,MAAM,0BAA0B,CAAC;AAGlF,OAAO,EAGL,KAAK,wBAAwB,EAC9B,MAAM,6DAA6D,CAAC;AACrE,OAAO,EAAE,cAAc,EAAE,MAAM,2BAA2B,CAAC;AAM3D,MAAM,WAAW,kCAAkC;IACjD,QAAQ,CAAC,YAAY,EAAE,mBAAmB,CAAC;IAC3C,QAAQ,CAAC,iBAAiB,EAAE,MAAM,MAAM,CAAC;IACzC,QAAQ,CAAC,WAAW,EAAE,CAAC,MAAM,EAAE,MAAM,KAAK,IAAI,CAAC;IAC/C,QAAQ,CAAC,eAAe,EAAE,MAAM,MAAM,CAAC;IACvC,QAAQ,CAAC,aAAa,EAAE,MAAM,IAAI,CAAC;IACnC,QAAQ,CAAC,gBAAgB,EAAE,MAAM;QAAE,QAAQ,CAAC,UAAU,EAAE,OAAO,CAAC;QAAC,QAAQ,CAAC,YAAY,EAAE,OAAO,CAAA;KAAE,CAAC;IAClG,QAAQ,CAAC,yBAAyB,EAAE,MAAM,MAAM,CAAC;IACjD,QAAQ,CAAC,mBAAmB,EAAE,MAAM,gBAAgB,CAAC;IACrD,QAAQ,CAAC,eAAe,EAAE,MAAM,eAAe,CAAC;IAChD,QAAQ,CAAC,uBAAuB,EAAE,CAAC,OAAO,EAAE,MAAM,KAAK,IAAI,CAAC;IAC5D,QAAQ,CAAC,UAAU,EAAE,CAAC,KAAK,EAAE,UAAU,CAAC,OAAO,cAAc,CAAC,KAAK,IAAI,CAAC;CACzE;AAED,qBAAa,2BAA2B;IAMnB,OAAO,CAAC,QAAQ,CAAC,OAAO;IAL3C,OAAO,CAAC,KAAK,CAAkC;IAC/C,OAAO,CAAC,cAAc,CAAS;IAC/B,OAAO,CAAC,SAAS,CAAS;IAC1B,OAAO,CAAC,QAAQ,CAAC,UAAU,CAA6B;gBAEpB,OAAO,EAAE,kCAAkC;IAExE,OAAO,CAAC,IAAI,EAAE,wBAAwB,GAAG,IAAI;IAY7C,aAAa,IAAI,IAAI;IAS5B,OAAO,CAAC,WAAW;IAQnB,OAAO,CAAC,SAAS;YAWH,KAAK;CAwDpB"}