@kernel.chat/kbot 3.83.0 → 3.85.0

package/dist/agent-protocol.d.ts

@@ -47,6 +47,14 @@ export declare function blackboardQuery(type?: BlackboardEntry['type']): Blackbo
 export declare function blackboardSubscribe(key: string, agentId: string, callback?: SubscriptionCallback): void;
 /** Get all decision-type entries (consensus view) */
 export declare function blackboardGetDecisions(): BlackboardEntry[];
+type BlackboardTypeSubscriber = (entry: BlackboardEntry) => void;
+/** Subscribe to blackboard entries by type. Use '*' for wildcard (all types). */
+export declare function subscribeToBlackboard(type: string, callback: BlackboardTypeSubscriber): void;
+/**
+ * Write an entry to the blackboard AND broadcast to all type-based subscribers.
+ * This is the preferred write path when cognitive modules should be notified.
+ */
+export declare function broadcastToBlackboard(key: string, value: unknown, author: string, type: BlackboardEntry['type'], confidence?: number): BlackboardEntry;
 /** Clear the entire blackboard for a new task */
 export declare function blackboardClear(): void;
 export interface Proposal {

package/dist/agent-protocol.js

@@ -152,6 +152,31 @@ export function blackboardSubscribe(key, agentId, callback) {
 export function blackboardGetDecisions() {
     return blackboardQuery('decision');
 }
+const typeSubscribers = new Map();
+/** Subscribe to blackboard entries by type. Use '*' for wildcard (all types). */
+export function subscribeToBlackboard(type, callback) {
+    if (!typeSubscribers.has(type))
+        typeSubscribers.set(type, []);
+    typeSubscribers.get(type).push(callback);
+}
+/**
+ * Write an entry to the blackboard AND broadcast to all type-based subscribers.
+ * This is the preferred write path when cognitive modules should be notified.
+ */
+export function broadcastToBlackboard(key, value, author, type, confidence = 1.0) {
+    // Write to blackboard (this already notifies key-based subscribers)
+    const entry = blackboardWrite(key, value, author, type, confidence);
+    // Broadcast to type-based subscribers
+    const typeSubs = typeSubscribers.get(type) || [];
+    const wildcardSubs = typeSubscribers.get('*') || [];
+    for (const sub of [...typeSubs, ...wildcardSubs]) {
+        try {
+            sub(entry);
+        }
+        catch { /* subscriber errors don't break the bus */ }
+    }
+    return entry;
+}
 /** Clear the entire blackboard for a new task */
 export function blackboardClear() {
     blackboard.entries.clear();

package/dist/agent.js

@@ -41,10 +41,11 @@ import { CheckpointManager, newSessionId } from './checkpoint.js';
 import { TelemetryEmitter } from './telemetry.js';
 import { loadSkills } from './skills-loader.js';
 import { queueSignal, getCollectiveRecommendation, isCollectiveEnabled } from './collective.js';
+import { subscribeToBlackboard } from './agent-protocol.js';
 import { ActiveInferenceEngine } from './free-energy.js';
 import { PredictiveEngine } from './predictive-processing.js';
 import { selectStrategy, recordStrategyOutcome } from './reasoning.js';
-import { getDriveState, updateMotivation } from './intentionality.js';
+import { getDriveState, getMotivation, updateMotivation } from './intentionality.js';
 import { anticipateNext, recordUserAction, updateIdentity } from './temporal.js';
 import { estimateConfidence, updateSkillProfile, recordActualEffort } from './confidence.js';
 import { StrangeLoopDetector } from './strange-loops.js';
@@ -1022,12 +1023,56 @@ Always quote file paths that contain spaces. Never reference internal system nam
     const entropyScorer = new EntropyScorer();
     // ── Autopoiesis: self-maintaining system health ──
     const autopoietic = new AutopoieticSystem();
-    // ── Full cognitive stack (wired in v3.6.2) ──
+    // ── Full cognitive stack (wired in v3.6.2, integrated in v3.85.0) ──
     const freeEnergy = new ActiveInferenceEngine();
     const predictive = new PredictiveEngine();
     const strangeLoops = new StrangeLoopDetector();
     const integrationMeter = new IntegrationMeter();
+    // Blackboard journal for dream consolidation (Change 2: facts → dream journal)
+    const blackboardDreamJournal = [];
+    // Change 2: Subscribe cognitive modules to the blackboard broadcast bus
+    try {
+        // Everything → free energy engine as observations (global workspace)
+        subscribeToBlackboard('*', (entry) => {
+            freeEnergy.observeBlackboardEntry({
+                type: entry.type,
+                content: typeof entry.value === 'string' ? entry.value : String(entry.key),
+                confidence: entry.confidence,
+            });
+        });
+        // Facts → dream journal for later consolidation
+        subscribeToBlackboard('fact', (entry) => {
+            blackboardDreamJournal.push({
+                content: typeof entry.value === 'string' ? entry.value : JSON.stringify(entry.value),
+                timestamp: Date.now(),
+                source: 'blackboard',
+            });
+        });
+        // Decisions → intentionality drives (task completion signal)
+        subscribeToBlackboard('decision', (entry) => {
+            try {
+                if (entry.confidence > 0.7) {
+                    updateMotivation({ type: 'task_success' });
+                }
+            }
+            catch { /* non-critical */ }
+        });
+        // Hypotheses → predictive engine
+        subscribeToBlackboard('hypothesis', (entry) => {
+            // Feed hypotheses into the predictive engine's message history
+            // so it can refine predictions based on intermediate reasoning
+            try {
+                const hypContent = typeof entry.value === 'string' ? entry.value : String(entry.key);
+                predictive.evaluate(predictive.predict([hypContent], []), hypContent, []);
+            }
+            catch { /* non-critical */ }
+        });
+    }
+    catch { /* blackboard subscriptions are non-critical */ }
     // Pre-execution intelligence: predict, plan, estimate (all non-critical)
+    // Policy and tool bias are hoisted so they can be applied to the system prompt (Change 5)
+    let cognitivePolicy = 'balanced';
+    let cognitiveToolBias = { preferred: [], discouraged: [] };
     try {
         // Predictive processing — anticipate what the user will ask next
         const prediction = predictive.predict([originalMessage], toolSequenceLog);
@@ -1036,7 +1081,17 @@ Always quote file paths that contain spaces. Never reference internal system nam
         }
         // Free energy — observe the incoming message and update beliefs
         freeEnergy.observeMessage(originalMessage);
-        const policy = freeEnergy.recommendPolicy();
+        // Change 1: Feed predictive engine results into free energy engine
+        // The predictive engine's pattern classification improves the generative model.
+        const pattern = prediction ? prediction.predictedAction : '';
+        freeEnergy.integrateWithPredictiveEngine({
+            pattern,
+            confidence: prediction?.confidence ?? 0.3,
+            accuracy: predictive.getState().accuracy,
+        });
+        // Change 5: Capture policy and tool bias for system prompt injection
+        cognitivePolicy = freeEnergy.recommendPolicy();
+        cognitiveToolBias = freeEnergy.recommendToolBias();
         // Confidence — how well can we handle this task?
         const conf = estimateConfidence(originalMessage, contextSnippet || '');
         // Reasoning — select the best strategy for this task type
@@ -1047,6 +1102,21 @@ Always quote file paths that contain spaces. Never reference internal system nam
         const anticipated = anticipateNext([originalMessage], originalMessage);
     }
     catch { /* cognitive stack is non-critical — never block the agent loop */ }
+    // Change 5: Apply cognitive policy to system prompt
+    // explore → broader thinking, exploit → direct proven approaches
+    try {
+        if (cognitivePolicy === 'explore') {
+            systemContext += '\n\nNote: Consider unconventional approaches. The user may benefit from a different perspective than the obvious one.';
+        }
+        else if (cognitivePolicy === 'exploit') {
+            systemContext += '\n\nNote: Use the most reliable, proven approach. The user needs a direct solution.';
+        }
+        // Apply tool bias from learned patterns
+        if (cognitiveToolBias.preferred.length > 0) {
+            systemContext += `\n\nPreferred tools based on learned patterns: ${cognitiveToolBias.preferred.join(', ')}`;
+        }
+    }
+    catch { /* cognitive prompt injection is non-critical */ }
     // ── Tool execution pipeline ──
     const pipeline = options.pipeline ?? createDefaultPipeline({
         checkPermission,
@@ -1625,8 +1695,30 @@ Always quote file paths that contain spaces. Never reference internal system nam
     // ── Memory Scanner: stop and persist session stats ──
     stopMemoryScanner();
     // ── Dream Engine: consolidate session memories (non-blocking, $0 via Ollama) ──
+    // Changes 3 & 4: Pass intentionality drives and surprise scores for
+    // priority-guided consolidation and surprise-weighted replay selection.
     setBuddyMood('learning');
-    dreamAfterSession(sessionId);
+    try {
+        const motivation = getMotivation();
+        const driveState = getDriveState();
+        const dreamContext = {
+            driveState: {
+                curiosity: motivation.curiosity,
+                frustration: driveState.frustrated ? 0.8 : 0.2,
+                motivation: motivation.momentum,
+                consolidation: driveState.overallSatisfaction < 0.5 ? 0.8 : 0.4,
+            },
+            surpriseScores: freeEnergy.getSurpriseHistory().map(s => ({
+                message: s.message,
+                surprise: s.surprise,
+            })),
+        };
+        dreamAfterSession(sessionId, dreamContext);
+    }
+    catch {
+        // Fallback: dream without cognitive context if anything fails
+        dreamAfterSession(sessionId);
+    }
     // ── Buddy Evolution: award XP for completing a session ──
     addBuddyXP(1);
     // ── Achievements: check for newly unlocked milestones ──

package/dist/collective.d.ts

@@ -43,12 +43,23 @@ export declare function flushSignals(): Promise<void>;
 export declare function pullCollectiveHints(): Promise<RoutingHint[]>;
 /** Pull collective patterns (tool sequences, strategies) */
 export declare function pullCollectivePatterns(): Promise<CollectivePattern[]>;
-/** Get the best agent for a task category based on collective wisdom */
+/**
+ * Apply temporal decay to collective patterns.
+ * Confidence halves every 30 days without reinforcement (exponential decay).
+ * Dead patterns below 0.05 confidence are pruned.
+ */
+export declare function decayPatterns(patterns: CollectivePattern[]): CollectivePattern[];
+/**
+ * Reinforce a pattern when a new instance confirms it.
+ * 15% confidence boost per confirmation, capped at 1.0.
+ */
+export declare function reinforcePattern(pattern: CollectivePattern): CollectivePattern;
+/** Get the best agent for a task category based on collective wisdom (with decay applied) */
 export declare function getCollectiveRecommendation(category: string): {
     agent: string;
     confidence: number;
 } | null;
-/** Get the best tool sequence for a task category based on collective wisdom */
+/** Get the best tool sequence for a task category based on collective wisdom (with decay applied) */
 export declare function getCollectiveToolSequence(category: string): string[] | null;
 /** Get the current signal queue size (pending signals not yet flushed) */
 export declare function getSignalQueueSize(): number;

package/dist/collective.js

@@ -207,19 +207,64 @@ function loadCachedPatterns() {
     catch { /* corrupt cache */ }
     return [];
 }
+// ── Temporal Decay + Positive Feedback (Change 6) ──
+/**
+ * Apply temporal decay to collective patterns.
+ * Confidence halves every 30 days without reinforcement (exponential decay).
+ * Dead patterns below 0.05 confidence are pruned.
+ */
+export function decayPatterns(patterns) {
+    const now = Date.now();
+    return patterns.map(p => {
+        const lastSeen = p.last_updated ? new Date(p.last_updated).getTime() : now;
+        const ageMs = now - lastSeen;
+        const ageDays = ageMs / (1000 * 60 * 60 * 24);
+        // Exponential decay: halve confidence every 30 days
+        // ln(2)/30 ≈ 0.023
+        const decayFactor = Math.exp(-0.023 * ageDays);
+        return {
+            ...p,
+            confidence: p.confidence * decayFactor,
+            // sample_count is preserved — it records historical evidence, not current relevance
+        };
+    }).filter(p => p.confidence > 0.05);
+}
+/**
+ * Reinforce a pattern when a new instance confirms it.
+ * 15% confidence boost per confirmation, capped at 1.0.
+ */
+export function reinforcePattern(pattern) {
+    return {
+        ...pattern,
+        confidence: Math.min(1.0, pattern.confidence * 1.15),
+        sample_count: pattern.sample_count + 1,
+        last_updated: new Date().toISOString(),
+    };
+}
 // ── Integration Helpers ──
-/** Get the best agent for a task category based on collective wisdom */
+/** Get the best agent for a task category based on collective wisdom (with decay applied) */
 export function getCollectiveRecommendation(category) {
     const hints = loadCachedHints();
-    const match = hints.find(h => h.category === category && h.confidence > 0.7 && h.sample_count > 50);
+    // Apply temporal decay to routing hints by mapping to CollectivePattern shape
+    const hintPatterns = hints.map(h => ({
+        type: 'routing_rule',
+        pattern: { category: h.category, best_agent: h.best_agent },
+        confidence: h.confidence,
+        sample_count: h.sample_count,
+        last_updated: new Date().toISOString(), // Cached hints don't track last_updated individually
+    }));
+    const decayed = decayPatterns(hintPatterns);
+    const match = decayed.find(p => p.pattern.category === category &&
+        p.confidence > 0.7 &&
+        p.sample_count > 50);
     if (match) {
-        return { agent: match.best_agent, confidence: match.confidence };
+        return { agent: match.pattern.best_agent, confidence: match.confidence };
     }
     return null;
 }
-/** Get the best tool sequence for a task category based on collective wisdom */
+/** Get the best tool sequence for a task category based on collective wisdom (with decay applied) */
 export function getCollectiveToolSequence(category) {
-    const patterns = loadCachedPatterns();
+    const patterns = decayPatterns(loadCachedPatterns());
     const match = patterns.find(p => p.type === 'tool_sequence' &&
         p.pattern.category === category &&
         p.confidence > 0.7 &&

package/dist/dream.d.ts

@@ -55,8 +55,23 @@ export interface ApplyResult {
     factsLearned: number;
     promptAmendments: number;
 }
+/** Cognitive context passed from agent.ts to guide dream consolidation */
+export interface DreamCognitiveContext {
+    /** Intentionality drive state */
+    driveState?: {
+        curiosity: number;
+        frustration: number;
+        motivation: number;
+        consolidation: number;
+    };
+    /** Per-message surprise scores from the free energy engine */
+    surpriseScores?: Array<{
+        message: string;
+        surprise: number;
+    }>;
+}
 /** Run a full dream cycle — consolidate, reinforce, age */
-export declare function dream(sessionId?: string): Promise<DreamResult>;
+export declare function dream(sessionId?: string, cognitiveContext?: DreamCognitiveContext): Promise<DreamResult>;
 export interface DreamResult {
     success: boolean;
     newInsights: number;
@@ -81,5 +96,5 @@ export declare function searchDreams(query: string): DreamInsight[];
 /** Manually reinforce a specific insight (user confirms it's still relevant) */
 export declare function reinforceInsight(insightId: string): boolean;
 /** Run dream after session ends (non-blocking) */
-export declare function dreamAfterSession(sessionId?: string): void;
+export declare function dreamAfterSession(sessionId?: string, cognitiveContext?: DreamCognitiveContext): void;
 //# sourceMappingURL=dream.d.ts.map

package/dist/dream.js

@@ -147,7 +147,7 @@ function archiveInsights(insights) {
     writeFileSync(archivePath, JSON.stringify(insights, null, 2));
 }
 // ── Consolidation Prompts ──
-function buildConsolidationPrompt(sessionHistory, existingInsights, existingMemory) {
+function buildConsolidationPrompt(sessionHistory, existingInsights, existingMemory, driveState, surpriseScores) {
     const historyText = sessionHistory
         .map(t => `[${t.role}]: ${t.content.slice(0, 500)}`)
         .join('\n');
@@ -188,6 +188,36 @@ function buildConsolidationPrompt(sessionHistory, existingInsights, existingMemo
     }
     // ── Tier 7: User computer behavior — desktop observation ──
     const behaviorText = getBehaviorForDream(48) || '(no behavior data yet)';
+    // Change 4: Surprise-weighted replay selection.
+    // High-surprise messages are prioritized for consolidation (like biological sleep).
+    let replayHistoryText = historyText;
+    if (surpriseScores && surpriseScores.length > 0) {
+        const scored = sessionHistory.map(t => {
+            const msgSnippet = t.content.slice(0, 100);
+            const score = surpriseScores.find(s => msgSnippet.includes(s.message) || s.message.includes(msgSnippet.slice(0, 50)));
+            return { turn: t, surprise: score?.surprise ?? 0.5 };
+        });
+        // Sort by surprise (descending) and take top 60%
+        scored.sort((a, b) => b.surprise - a.surprise);
+        const topCount = Math.max(4, Math.ceil(scored.length * 0.6));
+        const replayTurns = scored.slice(0, topCount).map(s => s.turn);
+        replayHistoryText = replayTurns
+            .map(t => `[${t.role}]: ${t.content.slice(0, 500)}`)
+            .join('\n');
+    }
+    // Change 3: Drive-based consolidation priority guidance
+    let driveGuidance = '';
+    if (driveState) {
+        driveGuidance += '\n\nPRIORITY GUIDANCE (based on current intrinsic drives):';
+        if (driveState.curiosity > 0.7)
+            driveGuidance += '\n- HIGH CURIOSITY: Focus on novel connections and unexplored topics';
+        if (driveState.frustration > 0.5)
+            driveGuidance += '\n- FRUSTRATION DETECTED: Prioritize consolidating problem-solving patterns that resolved errors';
+        if (driveState.motivation > 0.8)
+            driveGuidance += '\n- HIGH MOTIVATION: Focus on patterns related to successful task completion';
+        if (driveState.consolidation > 0.6)
+            driveGuidance += '\n- CONSOLIDATION DRIVE: Focus on integrating fragmented knowledge into coherent structures';
+    }
     return `You are a memory consolidation system. Analyze this conversation session and ALL accumulated knowledge tiers to extract durable cross-tier insights.
 
 EXISTING DREAM INSIGHTS (Tier 4 — Dream Journal):
@@ -214,8 +244,9 @@ ${musicText}
 USER COMPUTER BEHAVIOR (Tier 7 — Desktop Observation):
 ${behaviorText}
 
-SESSION TO CONSOLIDATE:
-${historyText}
+SESSION TO CONSOLIDATE (surprise-weighted — high-value moments prioritized):
+${replayHistoryText}
+${driveGuidance}
 
 INSTRUCTIONS:
 Extract 1-5 insights by synthesizing across ALL tiers. Each insight should be:
@@ -468,9 +499,8 @@ function extractToolHintsFromInsight(text) {
     }
     return mapped;
 }
-// ── Core Dream Functions ──
 /** Run a full dream cycle — consolidate, reinforce, age */
-export async function dream(sessionId = 'default') {
+export async function dream(sessionId = 'default', cognitiveContext) {
     const result = {
         success: false,
         newInsights: 0,
@@ -512,7 +542,8 @@ export async function dream(sessionId = 'default') {
     journal = aged;
     result.archived = archived.length;
     // Phase 2: Extract new insights from session (cross-tier consolidation)
-    const consolidationPrompt = buildConsolidationPrompt(history, journal, memory);
+    // Changes 3 & 4: Pass drive state and surprise scores for priority guidance + replay weighting
+    const consolidationPrompt = buildConsolidationPrompt(history, journal, memory, cognitiveContext?.driveState, cognitiveContext?.surpriseScores);
     const rawInsights = await ollamaGenerate(consolidationPrompt);
     const newlyCreatedInsights = [];
     if (rawInsights) {
@@ -650,9 +681,9 @@ export function reinforceInsight(insightId) {
     return true;
 }
 /** Run dream after session ends (non-blocking) */
-export function dreamAfterSession(sessionId = 'default') {
+export function dreamAfterSession(sessionId = 'default', cognitiveContext) {
     // Fire and forget — don't block the user
-    dream(sessionId).catch(() => {
+    dream(sessionId, cognitiveContext).catch(() => {
         // Dream failed silently — non-critical
     });
 }

package/dist/free-energy.d.ts

@@ -44,11 +44,42 @@ export declare class ActiveInferenceEngine {
     private toolOutcomeHistory;
     private beliefUpdates;
     private actionsTaken;
+    private recentObservations;
+    private surpriseLog;
     private readonly explorationThreshold;
     private readonly exploitationThreshold;
     private readonly learningRate;
     private readonly decayRate;
     constructor();
+    /**
+     * Integrate predictions from the PredictiveEngine to improve the generative model.
+     * If the predictive engine detected 'drill_down', the generative model should predict
+     * increasingly specific queries. If 'topic_switch', predict new domain.
+     */
+    integrateWithPredictiveEngine(predictions: {
+        pattern: string;
+        confidence: number;
+        accuracy: number;
+    }): void;
+    private mapPatternToIntent;
+    /**
+     * Observe a blackboard broadcast and update beliefs.
+     * Blackboard entries reduce entropy proportional to their confidence.
+     */
+    observeBlackboardEntry(entry: {
+        type: string;
+        content: string;
+        confidence: number;
+    }): void;
+    /**
+     * Get per-message surprise history for dream replay selection.
+     * High-surprise messages are worth consolidating during "sleep."
+     */
+    getSurpriseHistory(): Array<{
+        message: string;
+        surprise: number;
+        timestamp: number;
+    }>;
     /**
      * Observe a user message and compute surprise.
      * High surprise = our model of the user is wrong → update beliefs.

package/dist/free-energy.js

@@ -28,6 +28,8 @@ export class ActiveInferenceEngine {
     toolOutcomeHistory = [];
     beliefUpdates = 0;
     actionsTaken = 0;
+    recentObservations = [];
+    surpriseLog = [];
     // Hyperparameters
     explorationThreshold = 0.6; // Above this → explore
     exploitationThreshold = 0.3; // Below this → exploit
@@ -41,6 +43,49 @@ export class ActiveInferenceEngine {
             entropy: 1.0,
         };
     }
+    /**
+     * Integrate predictions from the PredictiveEngine to improve the generative model.
+     * If the predictive engine detected 'drill_down', the generative model should predict
+     * increasingly specific queries. If 'topic_switch', predict new domain.
+     */
+    integrateWithPredictiveEngine(predictions) {
+        if (predictions.confidence > 0.7) {
+            this.beliefs.predictedIntent = this.mapPatternToIntent(predictions.pattern);
+            this.beliefs.confidence = Math.max(this.beliefs.confidence, predictions.confidence * 0.8);
+        }
+    }
+    mapPatternToIntent(pattern) {
+        const mapping = {
+            'iterative_refinement': 'refine_previous',
+            'topic_switch': 'explore_new',
+            'drill_down': 'deepen_understanding',
+            'error_recovery': 'fix_problem',
+            'capability_test': 'test_limits',
+            'creative_request': 'create_something',
+            'verification': 'verify_result',
+            'follow_up': 'continue_thread',
+            'meta_question': 'introspect',
+        };
+        return mapping[pattern] || 'general';
+    }
+    /**
+     * Observe a blackboard broadcast and update beliefs.
+     * Blackboard entries reduce entropy proportional to their confidence.
+     */
+    observeBlackboardEntry(entry) {
+        this.beliefs.entropy = Math.max(0, this.beliefs.entropy - entry.confidence * 0.1);
+        const snippet = typeof entry.content === 'string' ? entry.content.slice(0, 100) : '';
+        this.recentObservations.push(snippet);
+        if (this.recentObservations.length > 20)
+            this.recentObservations.shift();
+    }
+    /**
+     * Get per-message surprise history for dream replay selection.
+     * High-surprise messages are worth consolidating during "sleep."
+     */
+    getSurpriseHistory() {
+        return this.surpriseLog.slice(-50);
+    }
     /**
      * Observe a user message and compute surprise.
      * High surprise = our model of the user is wrong → update beliefs.
@@ -67,6 +112,14 @@ export class ActiveInferenceEngine {
             predictionError,
         };
         this.surpriseHistory.push(surprise);
+        // Track per-message surprise for dream replay selection (Change 4)
+        this.surpriseLog.push({
+            message: message.slice(0, 100),
+            surprise: predictionError,
+            timestamp: Date.now(),
+        });
+        if (this.surpriseLog.length > 100)
+            this.surpriseLog.shift();
         // Update beliefs via perceptual inference
         if (predictionError > this.explorationThreshold) {
             this.beliefs.confidence *= (1 - this.learningRate);
@@ -175,6 +228,8 @@ export class ActiveInferenceEngine {
         this.toolOutcomeHistory = [];
         this.beliefUpdates = 0;
         this.actionsTaken = 0;
+        this.recentObservations = [];
+        this.surpriseLog = [];
     }
 }
 //# sourceMappingURL=free-energy.js.map

package/dist/tools/render-engine.d.ts

@@ -81,6 +81,11 @@ export declare function tickParticles(particles: Particle[]): Particle[];
  * Render all particles to the canvas.
  */
 export declare function renderParticles(ctx: CanvasRenderingContext2D, particles: Particle[]): void;
+/**
+ * Tick particles using Verlet integration (PBD style) instead of simple velocity.
+ * Adds floor constraints with realistic bounce and attractor constraints for orbital particles.
+ */
+export declare function tickParticlesPBD(particles: Particle[], groundLevel?: number, attractorX?: number, attractorY?: number): Particle[];
 /**
  * Render a full procedural sky based on time of day, weather, and frame.
  */
@@ -155,4 +160,108 @@ export interface PostProcessOptions {
  * Apply screen-space post-processing effects.
  */
 export declare function renderPostProcessing(ctx: CanvasRenderingContext2D, width: number, height: number, frame: number, options: PostProcessOptions): void;
+export interface RadianceGrid {
+    cells: Float32Array;
+    width: number;
+    height: number;
+}
+/**
+ * Create an empty radiance grid (20x12 cells covering the 1280x720 canvas).
+ */
+export declare function createRadianceGrid(): RadianceGrid;
+/**
+ * Update radiance grid by propagating light from all sources using inverse-square falloff.
+ * Clears grid each frame before re-propagating.
+ */
+export declare function updateRadianceGrid(grid: RadianceGrid, lights: Light[]): void;
+/**
+ * Render the radiance grid as an additive overlay.
+ * Each grid cell is drawn as a colored rect at low opacity, creating ambient light propagation.
+ */
+export declare function renderRadianceOverlay(ctx: CanvasRenderingContext2D, grid: RadianceGrid, width: number, height: number): void;
+/**
+ * Render subsurface scattering approximation on translucent robot panels.
+ * Creates a soft warm glow "leaking through" panel edges using shadowBlur + screen compositing.
+ */
+export declare function renderSubsurfaceGlow(ctx: CanvasRenderingContext2D, panels: Array<{
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+    color: string;
+    intensity: number;
+}>): void;
+/**
+ * Build SSS panel definitions for the kbot character.
+ */
+export declare function buildSubsurfacePanels(robotX: number, robotY: number, scale: number, moodColor: string): Array<{
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+    color: string;
+    intensity: number;
+}>;
+export interface FrameCache {
+    backgroundLayer: any | null;
+    bodyLayer: any | null;
+    lastBackgroundFrame: number;
+    lastBodyFrame: number;
+}
+/**
+ * Create an empty frame cache for importance-sampled rendering.
+ */
+export declare function createFrameCache(): FrameCache;
+/**
+ * Determine if a layer should be re-rendered this frame.
+ * - Background: every 4th frame (cached)
+ * - Body: every 2nd frame when idle (cached), always when moving
+ * - Effects: every frame
+ */
+export declare function shouldRenderLayer(cache: FrameCache, layer: 'background' | 'body' | 'effects', currentFrame: number, isMoving?: boolean, moodChanged?: boolean, worldChanged?: boolean): boolean;
+/**
+ * Cache a rendered layer as ImageData.
+ */
+export declare function cacheLayer(cache: FrameCache, ctx: CanvasRenderingContext2D, layer: 'background' | 'body', x: number, y: number, w: number, h: number, currentFrame: number): void;
+/**
+ * Draw a cached layer onto the canvas.
+ */
+export declare function drawCachedLayer(ctx: CanvasRenderingContext2D, cache: FrameCache, layer: 'background' | 'body'): void;
+/**
+ * Render volumetric fog with drifting horizontal bands.
+ * Fog is thinner near light sources and varies by biome.
+ */
+export declare function renderVolumetricFog(ctx: CanvasRenderingContext2D, width: number, height: number, frame: number, fogDensity: number, fogColor: string, lightSources: Array<{
+    x: number;
+    y: number;
+    color: string;
+    intensity: number;
+}>): void;
+/**
+ * Get fog parameters for the current world state.
+ */
+export declare function getFogParams(biome: string, timeOfDay: string): {
+    density: number;
+    color: string;
+};
+/**
+ * Cycle palette colors subtly based on frame, mood, and time of day.
+ * Creates a living, shimmering effect using HSL-based color shifting.
+ */
+export declare function cyclePalette(basePalette: Record<string, string>, frame: number, mood: string, timeOfDay: string): Record<string, string>;
+export interface AnimationParams {
+    blinkRate: number;
+    wobbleFreq: number;
+    wobbleAmp: number;
+    glowPulseSpeed: number;
+    breathSpeed: number;
+    energyLevel: number;
+}
+/**
+ * Compute animation parameters based on stream context.
+ * Higher engagement = faster, more energetic animations.
+ */
+export declare function computeAnimationParams(chatRate: number, // messages per minute
+viewerCount: number, // estimated viewers
+mood: string, timeOfDay: string, streamDuration: number): AnimationParams;
 //# sourceMappingURL=render-engine.d.ts.map