@kernel.chat/kbot 3.94.0 → 3.97.0

package/dist/agent.js

@@ -54,6 +54,7 @@ import { generateReflections, getRelevantReflections, formatReflectionsForPrompt
 import { getSynthesisContext } from './memory-synthesis.js';
 import { getActiveCorrectionsPrompt } from './synthesis-engine.js';
 import { recordTrace, shouldEvolve, evolvePrompt, getPromptAmendment, updateMutationScore } from './prompt-evolution.js';
+import { getCoordinator } from './coordinator.js';
 const MAX_TOOL_LOOPS = 75;
 /** Maximum cumulative cost (USD) before auto-stopping tool loops */
 const MAX_COST_CEILING = 1.00;
@@ -1102,6 +1103,18 @@ 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 */ }
+    // ── Intelligence Coordinator: unified pre-processing ──
+    let coordinatorContext = '';
+    try {
+        const coordinator = getCoordinator();
+        const preResult = await coordinator.preProcess(originalMessage, sessionId);
+        if (preResult.systemPromptAddition)
+            coordinatorContext = preResult.systemPromptAddition;
+        if (preResult.needsClarification) {
+            telemetry.emit('tool_call_end', { tool: 'coordinator', duration_ms: 0, error: preResult.clarificationReason });
+        }
+    }
+    catch { /* coordinator is non-critical */ }
     // Change 5: Apply cognitive policy to system prompt
     // explore → broader thinking, exploit → direct proven approaches
     try {
@@ -1115,6 +1128,8 @@ Always quote file paths that contain spaces. Never reference internal system nam
         if (cognitiveToolBias.preferred.length > 0) {
             systemContext += `\n\nPreferred tools based on learned patterns: ${cognitiveToolBias.preferred.join(', ')}`;
         }
+        if (coordinatorContext)
+            systemContext += `\n\n${coordinatorContext}`;
     }
     catch { /* cognitive prompt injection is non-critical */ }
     // ── Tool execution pipeline ──
@@ -1126,6 +1141,14 @@ Always quote file paths that contain spaces. Never reference internal system nam
         },
         runPostHook: (name, args, result) => { runPostToolHook(name, args, result, options.agent || 'kernel'); },
         executeTool: async (name, args) => {
+            // Coordinator tool oversight
+            try {
+                const coord = getCoordinator();
+                const eval_ = coord.evaluateToolCall(name, args);
+                if (eval_.warn)
+                    process.stderr.write(`\n  \x1b[2m[coordinator] ${eval_.warn}\x1b[0m\n`);
+            }
+            catch { /* non-critical */ }
             const r = await executeTool({ id: name, name, arguments: args });
             return { result: r.result, error: r.error ? r.result : undefined };
         },
@@ -1478,6 +1501,13 @@ Always quote file paths that contain spaces. Never reference internal system nam
                             }
                             catch { /* silent */ }
                         }
+                        // ── Intelligence Coordinator: post-response self-evaluation ──
+                        try {
+                            const coord = getCoordinator();
+                            coord.postProcess(originalMessage, content, toolSequenceLog, sessionId)
+                                .catch(() => { });
+                        }
+                        catch { /* coordinator is non-critical */ }
                         // ── Prompt Evolution (GEPA): record trace and evolve if threshold met ──
                         try {
                             const traceAgent = lastResponse.agent || 'kernel';

package/dist/coordinator.d.ts

@@ -0,0 +1,132 @@
+export interface Goal {
+    id: string;
+    description: string;
+    priority: number;
+    status: 'active' | 'completed' | 'abandoned';
+    created: string;
+    toolsUsed: string[];
+}
+export interface Insight {
+    id: string;
+    content: string;
+    source: string;
+    confidence: number;
+    timestamp: string;
+}
+export interface Conflict {
+    modules: [string, string];
+    description: string;
+    resolution: string | null;
+    timestamp: string;
+}
+export interface SelfEval {
+    sessionId: string;
+    messageHash: string;
+    score: number;
+    toolSuccessRate: number;
+    responseAppropriate: boolean;
+    patternsMatched: number;
+    timestamp: string;
+}
+export interface PreProcessResult {
+    agent: string | null;
+    confidence: number;
+    graphContext: string;
+    reasoning: string;
+    toolHints: string[];
+    systemPromptAddition: string;
+    needsClarification: boolean;
+    clarificationReason?: string;
+    drives: {
+        dominant: string;
+        level: number;
+    } | null;
+    anticipation: string | null;
+}
+export interface ToolEvaluation {
+    allow: boolean;
+    warn?: string;
+    alternatives?: string[];
+    anticipated: boolean;
+}
+export interface PostProcessResult {
+    score: number;
+    patternsExtracted: number;
+    insightsGenerated: number;
+    graphUpdates: number;
+    consolidationTriggered: boolean;
+}
+export interface ConsolidationResult {
+    patternsConsolidated: number;
+    rulesAdded: number;
+    insightsFound: number;
+    graphPruned: {
+        nodes: number;
+        edges: number;
+    };
+    routingAccuracy: number;
+}
+export interface CoordinatorStats {
+    totalInteractions: number;
+    successRate: number;
+    patternsLearnedToday: number;
+    routingAccuracy: number;
+    activeGoals: number;
+    recentInsights: number;
+    conflicts: number;
+    lastConsolidation: string | null;
+    policy: 'explore' | 'exploit' | 'balanced';
+    confidenceThreshold: number;
+    uptimeMs: number;
+}
+export interface CoordinatorState {
+    lastPolicy: 'explore' | 'exploit' | 'balanced';
+    confidenceThreshold: number;
+    totalInteractions: number;
+    successRate: number;
+    activeGoals: Goal[];
+    recentInsights: Insight[];
+    conflictLog: Conflict[];
+    evalHistory: SelfEval[];
+    patternsLearnedToday: number;
+    patternsLearnedDate: string;
+    routingAccuracy: number;
+    lastConsolidation: string | null;
+    startedAt: string;
+}
+export declare class IntelligenceCoordinator {
+    private state;
+    private anticipatedTools;
+    private currentSessionId;
+    private pendingRouteAgent;
+    private initTime;
+    constructor();
+    preProcess(message: string, sessionId: string): Promise<PreProcessResult>;
+    evaluateToolCall(toolName: string, args: Record<string, unknown>, _context?: {
+        sessionId?: string;
+        agent?: string;
+        message?: string;
+    }): ToolEvaluation;
+    postProcess(message: string, response: string, toolsUsed: string[], sessionId: string): Promise<PostProcessResult>;
+    consolidate(): Promise<ConsolidationResult>;
+    private selfEvaluate;
+    private synthesizePolicy;
+    private logToolToGraph;
+    private addInsight;
+    addGoal(description: string, priority?: number): Goal;
+    completeGoal(goalId: string): void;
+    recordConflict(modules: [string, string], description: string, resolution?: string): void;
+    load(): void;
+    save(): void;
+    getStats(): CoordinatorStats;
+    getHealthReport(): string;
+    getState(): Readonly<CoordinatorState>;
+    /** Adjust the confidence threshold (e.g., user prefers fewer clarification requests) */
+    setConfidenceThreshold(threshold: number): void;
+    /** Reset all state (for testing or fresh start) */
+    reset(): void;
+}
+export declare function getCoordinator(): IntelligenceCoordinator;
+/** Register coordinator tools with the kbot tool registry */
+export declare function registerCoordinatorTools(): void;
+//# sourceMappingURL=coordinator.d.ts.map