@kernel.chat/kbot 3.95.0 → 3.97.1

package/README.md

@@ -2,7 +2,7 @@
 
 <p align="center">
   <strong>kbot</strong><br>
-  Open-source terminal AI agent. 764+ tools. 35 agents. 20 providers. Dreams, learns, watches your system, controls your phone. $0 local.
+  Open-source terminal AI agent. 787+ tools. 35 agents. 20 providers. Dreams, learns, watches your system, controls your phone. $0 local.
 </p>
 
 <p align="center">
@@ -31,7 +31,7 @@ Most terminal AI agents lock you into one provider, one model, one way of workin
 - **Runs fully offline** — Embedded llama.cpp, Ollama, LM Studio, or Jan. $0, fully private.
 - **Learns your patterns** — Bayesian skill ratings + pattern extraction. Gets faster over time.
 - **35 specialist agents** — auto-routes your request to the right expert (coder, researcher, writer, guardian, quant, and 30 more).
-- **764+ tools** — files, bash, git, GitHub, web search, deploy, database, game dev, VFX, research, science, finance, security, music production, iPhone control, and more.
+- **787+ tools** — files, bash, git, GitHub, web search, deploy, database, game dev, VFX, research, science, finance, security, music production, iPhone control, and more.
 - **Programmatic SDK** — use kbot as a library in your own apps.
 - **MCP server built in** — plug kbot into Claude Code, Cursor, VS Code, Zed, or Neovim as a tool provider.
 
@@ -142,7 +142,7 @@ Checks security, documentation, code quality, CI/CD, community health, and DevOp
 |---|---|---|---|---|---|
 | AI providers | 20 | 1 | 1 | 6 | 75+ |
 | Specialist agents | 35 | 0 | 0 | 0 | 0 |
-| Built-in tools | 764+ | ~20 | ~15 | ~10 | ~15 |
+| Built-in tools | 787+ | ~20 | ~15 | ~10 | ~15 |
 | Science tools | 114 | 0 | 0 | 0 | 0 |
 | Memory system | 7-tier bidirectional | File-based | No | No | No |
 | Dream engine | Yes ($0 local) | Cloud API | No | No | No |

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/cli.js

@@ -102,7 +102,7 @@ async function main() {
         console.log(`  ${chalk.cyan('https://github.com/isaacsight/kernel/issues')}  ${chalk.dim('Bug reports')}`);
         console.log(`  ${chalk.cyan('support@kernel.chat')}  ${chalk.dim('Email (AI-assisted replies)')}`);
         console.log();
-        console.log(`  ${chalk.dim('35 specialist agents · 360+ tools · 20 providers · MIT licensed')}`);
+        console.log(`  ${chalk.dim('35 specialist agents · 787+ tools · 20 providers · MIT licensed')}`);
         console.log();
         process.exit(0);
     });

package/dist/coordinator.d.ts

@@ -0,0 +1,164 @@
+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;
+export interface Task {
+    id: string;
+    goal: string;
+    status: 'pending' | 'running' | 'done' | 'failed';
+    agent: string;
+    dependencies: string[];
+    result?: string;
+    error?: string;
+}
+export interface CoordinatorPlan {
+    id: string;
+    goal: string;
+    tasks: Task[];
+    createdAt: string;
+    completedAt?: string;
+    status: 'planning' | 'executing' | 'done' | 'failed';
+}
+/**
+ * Decompose a high-level goal into ordered sub-tasks with dependencies.
+ * Uses the LLM (via runAgent) to break the goal into 2-6 concrete tasks.
+ */
+export declare function decompose(goal: string): Promise<CoordinatorPlan>;
+/**
+ * Execute a plan's tasks in dependency order (sequential for now).
+ * Tasks whose dependencies are all 'done' are eligible to run.
+ */
+export declare function execute(plan: CoordinatorPlan): Promise<CoordinatorPlan>;
+/**
+ * Convenience: decompose a goal, execute the plan, and synthesize results.
+ * Returns a human-readable summary of what was accomplished.
+ */
+export declare function coordinate(goal: string): Promise<string>;
+//# sourceMappingURL=coordinator.d.ts.map