@kernel.chat/kbot 3.97.1 → 3.98.0

package/README.md

@@ -6,7 +6,7 @@
 </p>
 
 <p align="center">
-  <img src="https://raw.githubusercontent.com/isaacsight/kernel/main/tools/video-assets/demo.gif" alt="kbot demo" width="700">
+  <img src="https://raw.githubusercontent.com/isaacsight/kernel/main/tools/video-assets/demo-quick.gif" alt="kbot demo" width="700">
 </p>
 
 <p align="center">

package/dist/agent.js

@@ -654,6 +654,19 @@ function isComplexTask(message) {
 async function callProvider(provider, apiKey, model, systemContext, messages, tools, options) {
     const p = getProvider(provider);
     const startTime = Date.now();
+    // Teacher logger — captures (prompt, response) pairs for later distillation.
+    // Disabled for local providers (already free) and when KBOT_TEACHER_LOG=0.
+    const { getTeacherLogger } = await import('./teacher-logger.js');
+    const teacher = getTeacherLogger();
+    const teacherId = (teacher.isEnabled() && !isLocalProvider(provider))
+        ? teacher.begin({
+            sessionId: options?.sessionId,
+            provider,
+            model,
+            system: systemContext,
+            messages: messages.map(m => ({ role: m.role, content: m.content })),
+        })
+        : '';
     try {
         let result;
         // Embedded inference — runs in-process via node-llama-cpp, no HTTP
@@ -692,6 +705,14 @@ async function callProvider(provider, apiKey, model, systemContext, messages, to
             }
         }
         recordSuccess(provider, Date.now() - startTime);
+        if (teacherId) {
+            teacher.end(teacherId, {
+                content: result.content,
+                thinking: result.thinking,
+                tool_calls: result.tool_calls,
+                stop_reason: result.stop_reason,
+            }, result.usage);
+        }
         return result;
     }
     catch (err) {

package/dist/cli.js

@@ -3875,6 +3875,125 @@ async function main() {
     pikaCmd.action(() => {
         pikaCmd.commands.find(c => c.name() === 'status')?.parse(['', '', 'status']);
     });
+    // ── train-self / train-cycle / train-merge / train-grpo ──
+    // Fine-tune a local model on your own agent sessions.
+    program
+        .command('train-self')
+        .description('Fine-tune a local model on your own kbot sessions (MLX LoRA)')
+        .option('--mode <mode>', 'default | reasoning | agent-trace | code-only', 'default')
+        .option('--base-model <model>', 'Override base model (HF path or mlx-community/*)')
+        .option('--output-name <name>', 'Ollama model name to register')
+        .option('--backend <backend>', 'mlx | unsloth | llama-cpp | together', 'mlx')
+        .option('--iters <n>', 'Training iterations', (v) => parseInt(v, 10))
+        .option('--batch-size <n>', 'Batch size', (v) => parseInt(v, 10))
+        .option('--num-layers <n>', 'LoRA layers', (v) => parseInt(v, 10))
+        .option('--learning-rate <lr>', 'Learning rate', parseFloat)
+        .option('--max-examples <n>', 'Cap curated examples', (v) => parseInt(v, 10))
+        .option('--dry-run', 'Curate only, do not train')
+        .option('--skip-curate', 'Skip curation (use existing dataset)')
+        .option('--skip-train', 'Skip training (prepare + deploy only)')
+        .option('--skip-deploy', 'Skip Ollama deploy')
+        .option('--no-grad-checkpoint', 'Disable gradient checkpointing')
+        .action(async (opts) => {
+        const { trainSelf, formatTrainSelfReport } = await import('./train-self.js');
+        const r = await trainSelf({
+            mode: opts.mode,
+            baseModel: opts.baseModel,
+            outputName: opts.outputName,
+            backend: opts.backend,
+            iters: opts.iters,
+            batchSize: opts.batchSize,
+            numLayers: opts.numLayers,
+            learningRate: opts.learningRate,
+            maxExamples: opts.maxExamples,
+            dryRun: Boolean(opts.dryRun),
+            skipCurate: Boolean(opts.skipCurate),
+            skipTrain: Boolean(opts.skipTrain),
+            skipDeploy: Boolean(opts.skipDeploy),
+            gradCheckpoint: opts.gradCheckpoint !== false,
+        });
+        console.log(formatTrainSelfReport(r));
+    });
+    program
+        .command('train-cycle')
+        .description('On-policy distillation: student generates → Claude grades/corrects → retrain')
+        .option('--student <model>', 'Local student model (Ollama)', 'kernel-coder:latest')
+        .option('--teacher <model>', 'Teacher model', 'claude-opus-4-6')
+        .option('--samples <n>', 'Prompts to sample per cycle', (v) => parseInt(v, 10), 50)
+        .option('--threshold <score>', 'Pass threshold 0..1', parseFloat, 0.6)
+        .option('--retrain', 'Trigger train-self after collecting corrections')
+        .option('--dry-run', 'Skip teacher grading, just test student generation')
+        .action(async (opts) => {
+        const { runCycle, formatCycleReport } = await import('./train-cycle.js');
+        const r = await runCycle({
+            studentModel: opts.student,
+            teacherModel: opts.teacher,
+            samples: opts.samples,
+            passThreshold: opts.threshold,
+            retrain: Boolean(opts.retrain),
+            dryRun: Boolean(opts.dryRun),
+        });
+        console.log(formatCycleReport(r));
+    });
+    program
+        .command('train-merge')
+        .description('Merge models via MergeKit (TIES/SLERP/DARE)')
+        .option('--method <method>', 'ties | slerp | dare_ties | linear', 'ties')
+        .option('--base <model>', 'Base model (HF path)', 'Qwen/Qwen2.5-Coder-7B-Instruct')
+        .option('--output <name>', 'Output name')
+        .option('--default', 'Use kbot triad defaults (qwen-coder + deepseek-r1 + self)')
+        .option('--deploy', 'Register with Ollama after merge')
+        .action(async (opts) => {
+        const { mergeKbotDefault, mergeModels, formatMergeReport } = await import('./train-merge.js');
+        if (opts.default) {
+            const r = await mergeKbotDefault();
+            console.log(formatMergeReport(r));
+            return;
+        }
+        const r = await mergeModels({
+            method: opts.method,
+            baseModel: opts.base,
+            models: [
+                { model: opts.base, weight: 1, density: 0.5 },
+            ],
+            outputName: opts.output,
+            deploy: Boolean(opts.deploy),
+        });
+        console.log(formatMergeReport(r));
+    });
+    program
+        .command('train-grpo')
+        .description('GRPO on verifiable tasks (build-pass, test-pass, regex-match, json-valid)')
+        .option('--student <model>', 'Student model', 'kernel-coder:latest')
+        .option('--group-size <n>', 'Rollouts per prompt', (v) => parseInt(v, 10), 8)
+        .option('--iters <n>', 'Outer iterations', (v) => parseInt(v, 10), 100)
+        .option('--dry-run', 'Collect rollouts only, do not update weights')
+        .option('--runner-cmd <cmd>', 'External GRPO runner command')
+        .action(async (opts) => {
+        const { runGrpoRollouts, DEFAULT_VERIFIER_SUITE, formatGrpoReport } = await import('./train-grpo.js');
+        const r = await runGrpoRollouts({
+            studentModel: opts.student,
+            prompts: DEFAULT_VERIFIER_SUITE,
+            groupSize: opts.groupSize,
+            iters: opts.iters,
+            dryRun: Boolean(opts.dryRun),
+            runnerCmd: opts.runnerCmd,
+        });
+        console.log(formatGrpoReport(r));
+    });
+    program
+        .command('train-agent-trace')
+        .description('Reformat tool-use traces as agent training examples')
+        .option('--min-tools <n>', 'Minimum tool calls per trajectory', (v) => parseInt(v, 10), 1)
+        .option('--verified-only', 'Only use trajectories tagged verified')
+        .action(async (opts) => {
+        const { formatAgentTraces, formatAgentTraceReport } = await import('./train-agent-trace.js');
+        const r = formatAgentTraces({
+            minTools: opts.minTools,
+            verifiedOnly: Boolean(opts.verifiedOnly),
+        });
+        console.log(formatAgentTraceReport(r));
+    });
     program.parse(process.argv);
     const opts = program.opts();
     const promptArgs = program.args;

package/dist/teacher-logger.d.ts

@@ -0,0 +1,71 @@
+export interface TeacherTrace {
+    id: string;
+    ts: number;
+    session_id?: string;
+    provider: string;
+    model: string;
+    system: string;
+    messages: Array<{
+        role: string;
+        content: string;
+    }>;
+    response: {
+        content: string;
+        thinking?: string;
+        tool_calls?: Array<{
+            id: string;
+            name: string;
+            arguments: Record<string, unknown>;
+        }>;
+        stop_reason?: string;
+    };
+    usage?: {
+        input_tokens: number;
+        output_tokens: number;
+    };
+    latency_ms?: number;
+    outcome?: {
+        verified: boolean;
+        signal: 'user_retry' | 'build_pass' | 'test_pass' | 'tool_error' | 'self_eval' | 'none';
+        score?: number;
+    };
+    tags?: string[];
+}
+export interface TeacherLoggerOptions {
+    enabled?: boolean;
+    dir?: string;
+    maxBytes?: number;
+    scrub?: boolean;
+}
+declare class TeacherLogger {
+    private enabled;
+    private dir;
+    private traceFile;
+    private maxBytes;
+    private scrub;
+    private pending;
+    constructor(opts?: TeacherLoggerOptions);
+    isEnabled(): boolean;
+    setEnabled(v: boolean): void;
+    /** Begin a trace — returns an ID to finalize later */
+    begin(input: {
+        sessionId?: string;
+        provider: string;
+        model: string;
+        system: string;
+        messages: Array<{
+            role: string;
+            content: string;
+        }>;
+    }): string;
+    /** Finalize a trace with the model response. No-op if id is empty/unknown. */
+    end(id: string, response: TeacherTrace['response'], usage?: TeacherTrace['usage'], outcome?: TeacherTrace['outcome']): void;
+    /** Tag an already-persisted trace with outcome later (e.g. after verifier runs). */
+    tagOutcome(traceId: string, outcome: TeacherTrace['outcome']): void;
+    private persist;
+    path(): string;
+}
+export declare function getTeacherLogger(): TeacherLogger;
+export declare function setTeacherLogger(logger: TeacherLogger): void;
+export {};
+//# sourceMappingURL=teacher-logger.d.ts.map

package/dist/teacher-logger.js

@@ -0,0 +1,162 @@
+// Teacher Logger — captures provider calls as (prompt, response, tools, outcome) pairs
+// for later distillation / fine-tuning. Writes to ~/.kbot/teacher/traces.jsonl.
+//
+// One logger per process. Append-only, JSONL, crash-safe (flush per record).
+// PII scrubber runs before persist.
+import { appendFileSync, existsSync, mkdirSync, statSync } from 'node:fs';
+import { join } from 'node:path';
+import { homedir } from 'node:os';
+import { randomUUID } from 'node:crypto';
+// ── PII / secret scrubber ────────────────────────────────────────────
+// Patterns for API keys, tokens, common secrets
+const SCRUB_PATTERNS = [
+    [/sk-ant-[A-Za-z0-9\-_]{20,}/g, 'sk-ant-<REDACTED>'],
+    [/sk-[A-Za-z0-9]{20,}/g, 'sk-<REDACTED>'],
+    [/ghp_[A-Za-z0-9]{30,}/g, 'ghp_<REDACTED>'],
+    [/github_pat_[A-Za-z0-9_]{30,}/g, 'github_pat_<REDACTED>'],
+    [/AIza[A-Za-z0-9\-_]{30,}/g, 'AIza<REDACTED>'],
+    [/xoxb-[A-Za-z0-9\-]{20,}/g, 'xoxb-<REDACTED>'],
+    [/eyJ[A-Za-z0-9\-_]+\.[A-Za-z0-9\-_]+\.[A-Za-z0-9\-_]+/g, '<JWT_REDACTED>'],
+    [/[A-Za-z0-9._%+\-]+@[A-Za-z0-9.\-]+\.[A-Za-z]{2,}/g, '<EMAIL>'],
+    [/\b(?:\d{1,3}\.){3}\d{1,3}\b/g, '<IP>'],
+    [/\b[A-Fa-f0-9]{64}\b/g, '<HEX64>'],
+];
+function scrubString(s) {
+    let out = s;
+    for (const [pat, repl] of SCRUB_PATTERNS)
+        out = out.replace(pat, repl);
+    // Home path scrub — keep structure but redact username
+    const home = homedir();
+    if (home && out.includes(home)) {
+        out = out.split(home).join('~');
+    }
+    return out;
+}
+function scrubTrace(t) {
+    return {
+        ...t,
+        system: scrubString(t.system),
+        messages: t.messages.map(m => ({ role: m.role, content: scrubString(m.content) })),
+        response: {
+            ...t.response,
+            content: scrubString(t.response.content),
+            thinking: t.response.thinking ? scrubString(t.response.thinking) : undefined,
+            tool_calls: t.response.tool_calls?.map(tc => ({
+                id: tc.id,
+                name: tc.name,
+                arguments: JSON.parse(scrubString(JSON.stringify(tc.arguments))),
+            })),
+        },
+    };
+}
+// ── Logger ───────────────────────────────────────────────────────────
+class TeacherLogger {
+    enabled;
+    dir;
+    traceFile;
+    maxBytes;
+    scrub;
+    pending = new Map();
+    constructor(opts = {}) {
+        this.enabled = opts.enabled ?? envEnabled();
+        this.dir = opts.dir ?? join(homedir(), '.kbot', 'teacher');
+        this.traceFile = join(this.dir, 'traces.jsonl');
+        this.maxBytes = opts.maxBytes ?? 500 * 1024 * 1024; // 500MB cap; rotate beyond
+        this.scrub = opts.scrub ?? true;
+        if (this.enabled && !existsSync(this.dir)) {
+            try {
+                mkdirSync(this.dir, { recursive: true });
+            }
+            catch { /* ignore */ }
+        }
+    }
+    isEnabled() { return this.enabled; }
+    setEnabled(v) { this.enabled = v; }
+    /** Begin a trace — returns an ID to finalize later */
+    begin(input) {
+        if (!this.enabled)
+            return '';
+        const id = randomUUID();
+        this.pending.set(id, {
+            id,
+            session_id: input.sessionId,
+            provider: input.provider,
+            model: input.model,
+            system: input.system,
+            messages: input.messages,
+            started_at: Date.now(),
+        });
+        return id;
+    }
+    /** Finalize a trace with the model response. No-op if id is empty/unknown. */
+    end(id, response, usage, outcome) {
+        if (!this.enabled || !id)
+            return;
+        const p = this.pending.get(id);
+        if (!p)
+            return;
+        this.pending.delete(id);
+        const trace = {
+            id: p.id,
+            ts: Date.now(),
+            session_id: p.session_id,
+            provider: p.provider,
+            model: p.model,
+            system: p.system,
+            messages: p.messages,
+            response,
+            usage,
+            latency_ms: Date.now() - p.started_at,
+            outcome,
+        };
+        this.persist(trace);
+    }
+    /** Tag an already-persisted trace with outcome later (e.g. after verifier runs). */
+    tagOutcome(traceId, outcome) {
+        if (!this.enabled || !traceId)
+            return;
+        const outcomeFile = join(this.dir, 'outcomes.jsonl');
+        try {
+            appendFileSync(outcomeFile, JSON.stringify({ id: traceId, outcome, ts: Date.now() }) + '\n');
+        }
+        catch { /* swallow */ }
+    }
+    persist(trace) {
+        try {
+            // Size-based rotation
+            if (existsSync(this.traceFile)) {
+                const sz = statSync(this.traceFile).size;
+                if (sz > this.maxBytes) {
+                    const rotated = join(this.dir, `traces.${Date.now()}.jsonl`);
+                    try {
+                        require('node:fs').renameSync(this.traceFile, rotated);
+                    }
+                    catch { /* ignore */ }
+                }
+            }
+            const t = this.scrub ? scrubTrace(trace) : trace;
+            appendFileSync(this.traceFile, JSON.stringify(t) + '\n');
+        }
+        catch {
+            // Never throw from logger — swallow and continue
+        }
+    }
+    path() { return this.traceFile; }
+}
+function envEnabled() {
+    const v = process.env.KBOT_TEACHER_LOG;
+    if (v == null)
+        return true; // default on — cost-free data collection
+    return v !== '0' && v.toLowerCase() !== 'false' && v !== '';
+}
+// ── Singleton ────────────────────────────────────────────────────────
+let singleton = null;
+export function getTeacherLogger() {
+    if (!singleton)
+        singleton = new TeacherLogger();
+    return singleton;
+}
+export function setTeacherLogger(logger) {
+    singleton = logger;
+}
+//# sourceMappingURL=teacher-logger.js.map