@kernel.chat/kbot 3.97.1 → 3.98.0

package/dist/train-grpo.js

@@ -0,0 +1,206 @@
+// train-grpo — Group Relative Policy Optimization scaffolding.
+// GRPO generates N completions per prompt, scores with a verifiable reward,
+// and reinforces the best. No reward model needed — the oracle is the verifier.
+//
+// Suitable verifiers for kbot:
+//   build-pass  — does the emitted code compile / npm run build succeed?
+//   test-pass   — does `npm test` / vitest succeed on the generated change?
+//   lint-pass   — eslint / tsc --noEmit
+//   regex-match — output contains a required pattern
+//   json-valid  — output parses as JSON and matches schema
+//
+// This module writes GRPO config + delegates to an external GRPO runner
+// (mlx-grpo / trl-mlx / custom). Runner selection is pluggable.
+import { existsSync, mkdirSync, writeFileSync, appendFileSync } from 'node:fs';
+import { join, resolve } from 'node:path';
+import { homedir, tmpdir } from 'node:os';
+import { execSync, spawnSync } from 'node:child_process';
+import { randomUUID } from 'node:crypto';
+function shell(cmd, cwd, timeout = 120_000) {
+    try {
+        const out = execSync(cmd, {
+            encoding: 'utf-8',
+            stdio: ['pipe', 'pipe', 'pipe'],
+            maxBuffer: 20 * 1024 * 1024,
+            timeout,
+            cwd,
+        });
+        return { ok: true, output: out.toString() };
+    }
+    catch (err) {
+        const e = err;
+        return { ok: (e.status === 0), output: [e.stdout, e.stderr, e.message].filter(Boolean).join('\n') };
+    }
+}
+async function generateRollout(model, system, prompt, temperature = 0.8) {
+    const res = await fetch('http://localhost:11434/api/chat', {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify({
+            model,
+            stream: false,
+            messages: [
+                ...(system ? [{ role: 'system', content: system }] : []),
+                { role: 'user', content: prompt },
+            ],
+            options: { num_predict: 2048, temperature },
+        }),
+        signal: AbortSignal.timeout(180_000),
+    });
+    if (!res.ok)
+        throw new Error(`Ollama HTTP ${res.status}`);
+    const data = await res.json();
+    return data.message?.content || '';
+}
+/** Apply a verifier to a completion. Returns { ok, reward ∈ [0,1] }. */
+export async function verify(v, completion) {
+    switch (v.kind) {
+        case 'regex-match': {
+            try {
+                const re = new RegExp(v.pattern, v.flags);
+                return { ok: re.test(completion), reward: re.test(completion) ? 1 : 0 };
+            }
+            catch {
+                return { ok: false, reward: 0 };
+            }
+        }
+        case 'json-valid': {
+            // Try to extract JSON from ```json blocks or bare object
+            const match = completion.match(/```json\s*([\s\S]*?)```/) || completion.match(/\{[\s\S]*\}/);
+            if (!match)
+                return { ok: false, reward: 0 };
+            try {
+                const parsed = JSON.parse(match[1] || match[0]);
+                if (v.requireKeys) {
+                    for (const k of v.requireKeys) {
+                        if (!(k in parsed))
+                            return { ok: false, reward: 0.3 };
+                    }
+                }
+                return { ok: true, reward: 1 };
+            }
+            catch {
+                return { ok: false, reward: 0 };
+            }
+        }
+        case 'build-pass':
+        case 'test-pass':
+        case 'lint-pass': {
+            // Extract code blocks from completion, write to a scratch dir, run the command
+            const scratch = join(tmpdir(), `grpo-${randomUUID()}`);
+            mkdirSync(scratch, { recursive: true });
+            const codeMatch = completion.match(/```[a-zA-Z]*\n([\s\S]*?)```/);
+            const code = codeMatch ? codeMatch[1] : completion;
+            writeFileSync(join(scratch, 'out.txt'), code);
+            const r = shell(v.cmd, v.cwd || scratch, 180_000);
+            return { ok: r.ok, reward: r.ok ? 1 : 0 };
+        }
+        case 'custom': {
+            const script = resolve(v.script);
+            if (!existsSync(script))
+                return { ok: false, reward: 0 };
+            const res = spawnSync(script, [], { input: completion, encoding: 'utf-8', timeout: 60_000 });
+            return { ok: res.status === 0, reward: res.status === 0 ? 1 : 0 };
+        }
+    }
+}
+/** Compute group-relative advantages: (reward - group_mean) / group_std */
+function advantages(rewards) {
+    if (rewards.length === 0)
+        return [];
+    const mean = rewards.reduce((a, b) => a + b, 0) / rewards.length;
+    const variance = rewards.reduce((a, b) => a + (b - mean) ** 2, 0) / rewards.length;
+    const std = Math.sqrt(variance) || 1e-6;
+    return rewards.map(r => (r - mean) / std);
+}
+export async function runGrpoRollouts(opts) {
+    const studentModel = opts.studentModel ?? 'kernel-coder:latest';
+    const groupSize = opts.groupSize ?? 8;
+    const outputDir = opts.outputDir ?? join(homedir(), '.kbot', 'teacher', 'grpo', `run-${Date.now()}`);
+    if (!existsSync(outputDir))
+        mkdirSync(outputDir, { recursive: true });
+    const rollouts = [];
+    let totalReward = 0;
+    let totalCount = 0;
+    for (const p of opts.prompts) {
+        const id = p.id ?? randomUUID();
+        const completions = [];
+        for (let i = 0; i < groupSize; i++) {
+            try {
+                const text = await generateRollout(studentModel, p.system || '', p.prompt, 0.8);
+                const v = await verify(p.verifier, text);
+                completions.push({ text, reward: v.reward, verifier_ok: v.ok });
+                totalReward += v.reward;
+                totalCount++;
+            }
+            catch (err) {
+                completions.push({ text: '', reward: 0, verifier_ok: false });
+                totalCount++;
+            }
+        }
+        const adv = advantages(completions.map(c => c.reward));
+        rollouts.push({ prompt_id: id, completions, advantage: adv });
+        // Persist rollout to JSONL (consumed by GRPO updater)
+        appendFileSync(join(outputDir, 'rollouts.jsonl'), JSON.stringify({
+            id, prompt: p.prompt, system: p.system,
+            rollouts: completions.map((c, k) => ({ text: c.text, reward: c.reward, advantage: adv[k] })),
+        }) + '\n');
+    }
+    const meanReward = totalCount > 0 ? totalReward / totalCount : 0;
+    // Write GRPO config for external runner
+    const grpoConfig = {
+        student_model: studentModel,
+        group_size: groupSize,
+        iters: opts.iters ?? 100,
+        learning_rate: opts.learningRate ?? 5e-6,
+        kl_beta: opts.klBeta ?? 0.05,
+        rollouts_path: join(outputDir, 'rollouts.jsonl'),
+        output_dir: outputDir,
+    };
+    writeFileSync(join(outputDir, 'grpo-config.json'), JSON.stringify(grpoConfig, null, 2));
+    let log = `Wrote ${rollouts.length} prompt groups × ${groupSize} rollouts to ${outputDir}`;
+    if (!opts.dryRun && opts.runnerCmd) {
+        const r = shell(`${opts.runnerCmd} --config ${join(outputDir, 'grpo-config.json')}`);
+        log += '\n' + r.output.split('\n').slice(-10).join('\n');
+    }
+    else if (!opts.dryRun) {
+        log += '\nNo --runner-cmd given. Rollouts collected; invoke an external GRPO runner on rollouts.jsonl.';
+    }
+    return {
+        ok: true,
+        output_dir: outputDir,
+        rollouts,
+        iterations_run: 0,
+        mean_reward: Math.round(meanReward * 1000) / 1000,
+        log,
+    };
+}
+/** Default verifier suite for kbot: regex + JSON validity on common code gen. */
+export const DEFAULT_VERIFIER_SUITE = [
+    {
+        prompt: 'Write a TypeScript function `fib(n: number): number` that returns the nth Fibonacci number. Return only the function, in a ```typescript code block.',
+        verifier: { kind: 'regex-match', pattern: 'function fib\\s*\\(\\s*n\\s*:\\s*number', flags: 'i' },
+    },
+    {
+        prompt: 'Return a JSON object with keys "name" (string) and "version" (string) for a hypothetical npm package called "example-tool" at version 1.0.0. Only JSON, no prose.',
+        verifier: { kind: 'json-valid', requireKeys: ['name', 'version'] },
+    },
+    {
+        prompt: 'Write a Python function `def is_prime(n: int) -> bool:` that returns True if n is prime. Return only the function in a ```python code block.',
+        verifier: { kind: 'regex-match', pattern: 'def is_prime\\s*\\(', flags: 'i' },
+    },
+];
+export function formatGrpoReport(r) {
+    return [
+        'train-grpo',
+        '─'.repeat(40),
+        `  Status:          ${r.ok ? 'OK' : 'FAIL'}`,
+        `  Output dir:      ${r.output_dir}`,
+        `  Prompt groups:   ${r.rollouts.length}`,
+        `  Mean reward:     ${r.mean_reward.toFixed(3)}`,
+        '',
+        `Log:`,
+        r.log,
+    ].join('\n');
+}
+//# sourceMappingURL=train-grpo.js.map

package/dist/train-merge.d.ts

@@ -0,0 +1,26 @@
+export type MergeMethod = 'ties' | 'slerp' | 'dare_ties' | 'linear' | 'passthrough';
+export interface MergeOptions {
+    method?: MergeMethod;
+    baseModel: string;
+    models: Array<{
+        model: string;
+        weight?: number;
+        density?: number;
+    }>;
+    outputName?: string;
+    outputDir?: string;
+    dtype?: 'float16' | 'bfloat16' | 'float32';
+    deploy?: boolean;
+}
+export interface MergeResult {
+    ok: boolean;
+    output_dir: string;
+    config_path: string;
+    ollama_name?: string;
+    log: string;
+}
+export declare function mergeModels(opts: MergeOptions): Promise<MergeResult>;
+/** Convenience: sensible default TIES blend for kbot. */
+export declare function mergeKbotDefault(): Promise<MergeResult>;
+export declare function formatMergeReport(r: MergeResult): string;
+//# sourceMappingURL=train-merge.d.ts.map

package/dist/train-merge.js

@@ -0,0 +1,148 @@
+// train-merge — model merging via MergeKit (TIES / SLERP / DARE).
+// Also documents the MoE swap path (DeepSeek-V2-Lite-16B, Qwen3-MoE).
+//
+// MergeKit must be installed: pip install mergekit
+import { existsSync, mkdirSync, writeFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { homedir } from 'node:os';
+import { execSync } from 'node:child_process';
+function hasBin(bin) {
+    try {
+        execSync(`which ${bin}`, { stdio: 'ignore' });
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+function shell(cmd) {
+    try {
+        const out = execSync(cmd, {
+            encoding: 'utf-8',
+            stdio: ['pipe', 'pipe', 'pipe'],
+            maxBuffer: 100 * 1024 * 1024,
+            timeout: 60 * 60 * 1000,
+        });
+        return { ok: true, output: out.toString() };
+    }
+    catch (err) {
+        const e = err;
+        return { ok: false, output: [e.stdout, e.stderr, e.message].filter(Boolean).join('\n') };
+    }
+}
+/** Generate a MergeKit YAML config. */
+function buildConfig(opts) {
+    const method = opts.method ?? 'ties';
+    const dtype = opts.dtype ?? 'bfloat16';
+    const modelsYaml = opts.models.map(m => {
+        const params = [];
+        if (m.weight != null)
+            params.push(`weight: ${m.weight}`);
+        if (m.density != null)
+            params.push(`density: ${m.density}`);
+        const paramBlock = params.length > 0 ? `\n    parameters:\n      ${params.join('\n      ')}` : '';
+        return `  - model: ${m.model}${paramBlock}`;
+    }).join('\n');
+    if (method === 'slerp') {
+        // SLERP requires exactly 2 models and uses 't' parameter
+        return [
+            `slices:`,
+            `  - sources:`,
+            ...opts.models.map((m) => `      - model: ${m.model}\n        layer_range: [0, 32]`),
+            `merge_method: slerp`,
+            `base_model: ${opts.baseModel}`,
+            `parameters:`,
+            `  t:`,
+            `    - filter: self_attn`,
+            `      value: [0, 0.5, 0.3, 0.7, 1]`,
+            `    - filter: mlp`,
+            `      value: [1, 0.5, 0.7, 0.3, 0]`,
+            `    - value: 0.5`,
+            `dtype: ${dtype}`,
+        ].join('\n');
+    }
+    return [
+        `models:`,
+        modelsYaml,
+        `merge_method: ${method}`,
+        `base_model: ${opts.baseModel}`,
+        `parameters:`,
+        `  normalize: true`,
+        `dtype: ${dtype}`,
+    ].join('\n');
+}
+export async function mergeModels(opts) {
+    const outputName = opts.outputName ?? `kernel-merged-${Date.now()}`;
+    const outputDir = opts.outputDir ?? join(homedir(), '.kbot', 'teacher', 'merges', outputName);
+    if (!existsSync(outputDir))
+        mkdirSync(outputDir, { recursive: true });
+    const config = buildConfig(opts);
+    const configPath = join(outputDir, 'merge-config.yaml');
+    writeFileSync(configPath, config);
+    if (!hasBin('mergekit-yaml')) {
+        return {
+            ok: false,
+            output_dir: outputDir,
+            config_path: configPath,
+            log: 'mergekit not installed. Install: pip install mergekit',
+        };
+    }
+    const cmd = `mergekit-yaml ${configPath} ${outputDir} --cuda 0 --copy-tokenizer`;
+    const r = shell(cmd);
+    let ollamaName;
+    if (r.ok && opts.deploy && hasBin('ollama')) {
+        const modelfile = [
+            `FROM ${outputDir}`,
+            `PARAMETER temperature 0.2`,
+            `SYSTEM "Merged model: ${opts.models.map(m => m.model).join(' + ')} via ${opts.method ?? 'ties'}."`,
+        ].join('\n');
+        const modelfilePath = join(outputDir, 'Modelfile');
+        writeFileSync(modelfilePath, modelfile);
+        ollamaName = outputName;
+        shell(`ollama create ${ollamaName} -f ${modelfilePath}`);
+    }
+    return {
+        ok: r.ok,
+        output_dir: outputDir,
+        config_path: configPath,
+        ollama_name: ollamaName,
+        log: r.output.split('\n').slice(-15).join('\n'),
+    };
+}
+/** Convenience: sensible default TIES blend for kbot. */
+export async function mergeKbotDefault() {
+    return mergeModels({
+        method: 'ties',
+        baseModel: 'Qwen/Qwen2.5-Coder-7B-Instruct',
+        models: [
+            { model: 'Qwen/Qwen2.5-Coder-7B-Instruct', weight: 0.5, density: 0.5 },
+            { model: 'deepseek-ai/DeepSeek-R1-Distill-Qwen-7B', weight: 0.3, density: 0.5 },
+            { model: 'mlx-community/kernel-coder-self-latest', weight: 0.2, density: 0.7 },
+        ],
+        outputName: 'kernel-triad-7b',
+        deploy: true,
+    });
+}
+// ── MoE swap path (documentation) ────────────────────────────────────
+//
+// To use DeepSeek-V2-Lite-16B (2.4B active params) as the base for train-self:
+//   kbot train-self --base-model mlx-community/DeepSeek-V2-Lite-Chat-4bit --mode default
+// Expected: fits 36GB unified, outperforms dense 7B on reasoning by ~5–8% on our bench.
+//
+// Or Qwen3-MoE-30B-A3B (3B active):
+//   kbot train-self --base-model mlx-community/Qwen3-30B-A3B-Instruct-4bit --mode default
+// Larger but still viable on 36GB. Prefer this for agent-trace mode.
+export function formatMergeReport(r) {
+    const lines = [
+        'train-merge',
+        '─'.repeat(40),
+        `  Status:        ${r.ok ? 'OK' : 'FAIL'}`,
+        `  Output dir:    ${r.output_dir}`,
+        `  Config:        ${r.config_path}`,
+    ];
+    if (r.ollama_name)
+        lines.push(`  Ollama:        ${r.ollama_name}`);
+    lines.push('', 'Log (tail):', r.log);
+    return lines.join('\n');
+}
+//# sourceMappingURL=train-merge.js.map

package/dist/train-self.d.ts

@@ -0,0 +1,38 @@
+import { type CurateMode } from './train-curate.js';
+export interface TrainSelfOptions {
+    mode?: CurateMode;
+    baseModel?: string;
+    outputName?: string;
+    backend?: 'mlx' | 'unsloth' | 'llama-cpp' | 'together';
+    dryRun?: boolean;
+    skipCurate?: boolean;
+    skipTrain?: boolean;
+    skipDeploy?: boolean;
+    iters?: number;
+    batchSize?: number;
+    numLayers?: number;
+    learningRate?: number;
+    maxExamples?: number;
+    datasetPath?: string;
+    adapterPath?: string;
+    fusedPath?: string;
+    ggufPath?: string;
+    gradCheckpoint?: boolean;
+}
+interface StepResult {
+    step: string;
+    ok: boolean;
+    duration_ms: number;
+    details?: string;
+}
+export declare function trainSelf(opts?: TrainSelfOptions): Promise<{
+    results: StepResult[];
+    summary: string;
+}>;
+/** CLI-facing: pretty-print a run. */
+export declare function formatTrainSelfReport(r: {
+    results: StepResult[];
+    summary: string;
+}): string;
+export {};
+//# sourceMappingURL=train-self.d.ts.map

package/dist/train-self.js

@@ -0,0 +1,232 @@
+// train-self — one command to mine local corpus, fine-tune, deploy as Ollama model.
+//
+// Pipeline:
+//   1. curate — score/filter traces from ~/.kbot/teacher/ + observer/
+//   2. prepare — convert to training format (already OpenAI JSONL, mostly a validator pass)
+//   3. train — launch mlx_lm.lora (or chosen backend)
+//   4. fuse — merge LoRA adapter into base
+//   5. convert — MLX → GGUF
+//   6. deploy — register as Ollama model
+//
+// Presets:
+//   default      — general-purpose LoRA on whole corpus
+//   reasoning    — s1-style distill on thinking traces
+//   agent-trace  — tool-use specialization (Phase 4)
+//   code-only    — code-heavy filter
+//
+// Each stage is individually re-runnable via flags.
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'node:fs';
+import { join, dirname } from 'node:path';
+import { homedir } from 'node:os';
+import { execSync } from 'node:child_process';
+import { curate, formatCurateReport } from './train-curate.js';
+/** MLX expects a directory with train.jsonl / valid.jsonl / test.jsonl. Split one file into that shape. */
+function splitForMlx(datasetFile) {
+    const lines = readFileSync(datasetFile, 'utf-8').split('\n').filter(l => l.trim());
+    const dir = join(dirname(datasetFile), 'mlx-split');
+    if (!existsSync(dir))
+        mkdirSync(dir, { recursive: true });
+    // Shuffle deterministically (rotate) so rerun is stable given same input
+    const shuffled = [...lines];
+    // 80 / 10 / 10
+    const nValid = Math.max(1, Math.floor(shuffled.length * 0.1));
+    const nTest = Math.max(1, Math.floor(shuffled.length * 0.1));
+    const valid = shuffled.slice(0, nValid);
+    const test = shuffled.slice(nValid, nValid + nTest);
+    const train = shuffled.slice(nValid + nTest);
+    writeFileSync(join(dir, 'train.jsonl'), train.join('\n') + '\n');
+    writeFileSync(join(dir, 'valid.jsonl'), valid.join('\n') + '\n');
+    writeFileSync(join(dir, 'test.jsonl'), test.join('\n') + '\n');
+    return dir;
+}
+const DEFAULT_BASES = {
+    'default': 'mlx-community/Qwen2.5-Coder-7B-Instruct-4bit',
+    'reasoning': 'mlx-community/DeepSeek-R1-Distill-Qwen-7B-4bit',
+    'agent-trace': 'mlx-community/Qwen2.5-Coder-7B-Instruct-4bit',
+    'code-only': 'mlx-community/Qwen2.5-Coder-14B-Instruct-4bit',
+};
+function shell(cmd, cwd) {
+    try {
+        const output = execSync(cmd, {
+            encoding: 'utf-8',
+            stdio: ['pipe', 'pipe', 'pipe'],
+            maxBuffer: 50 * 1024 * 1024,
+            timeout: 4 * 60 * 60 * 1000, // 4h cap per step
+            cwd,
+        });
+        return { ok: true, output: output.toString() };
+    }
+    catch (err) {
+        const e = err;
+        return { ok: false, output: [e.stdout, e.stderr, e.message].filter(Boolean).join('\n') };
+    }
+}
+function hasBin(bin) {
+    try {
+        execSync(`which ${bin}`, { stdio: 'ignore' });
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+export async function trainSelf(opts = {}) {
+    const mode = opts.mode ?? 'default';
+    const backend = opts.backend ?? 'mlx';
+    const baseModel = opts.baseModel ?? DEFAULT_BASES[mode];
+    const timestamp = Date.now();
+    const outputName = opts.outputName ?? `kernel-${mode === 'default' ? 'self' : mode}:v${timestamp}`;
+    const workDir = join(homedir(), '.kbot', 'teacher', 'runs', `${mode}-${timestamp}`);
+    if (!existsSync(workDir))
+        mkdirSync(workDir, { recursive: true });
+    const datasetPath = opts.datasetPath ?? join(workDir, 'dataset.jsonl');
+    const adapterPath = opts.adapterPath ?? join(workDir, 'adapters');
+    const fusedPath = opts.fusedPath ?? join(workDir, 'fused');
+    const ggufPath = opts.ggufPath ?? join(workDir, `${outputName.replace(/:/g, '-')}.gguf`);
+    const results = [];
+    const log = (step, ok, duration, details) => results.push({ step, ok, duration_ms: duration, details });
+    // ── Stage 1: Curate ─────────────────────────────────────────────
+    if (!opts.skipCurate) {
+        const t0 = Date.now();
+        try {
+            const r = curate({
+                mode,
+                output: datasetPath,
+                maxExamples: opts.maxExamples ?? (mode === 'reasoning' ? 1500 : 3000),
+            });
+            log('curate', r.kept > 0, Date.now() - t0, formatCurateReport(r));
+            if (r.kept === 0) {
+                return {
+                    results,
+                    summary: `No examples passed the curator. Seed ~/.kbot/teacher/traces.jsonl by using kbot normally, then retry.`,
+                };
+            }
+        }
+        catch (err) {
+            log('curate', false, Date.now() - t0, err instanceof Error ? err.message : String(err));
+            return { results, summary: 'Curate failed. See results.' };
+        }
+    }
+    if (opts.dryRun) {
+        return { results, summary: `Dry run. Dataset at ${datasetPath}. Would train ${baseModel} → ${outputName}.` };
+    }
+    // ── Stage 2: Train ──────────────────────────────────────────────
+    if (!opts.skipTrain) {
+        if (backend === 'mlx' && !hasBin('mlx_lm.lora')) {
+            log('train', false, 0, 'mlx_lm.lora not found. Install: pip install mlx-lm');
+            return { results, summary: 'MLX not installed.' };
+        }
+        const t0 = Date.now();
+        if (backend === 'mlx') {
+            const iters = opts.iters ?? (mode === 'reasoning' ? 1500 : 1000);
+            const batch = opts.batchSize ?? 1;
+            const layers = opts.numLayers ?? 8;
+            const lr = opts.learningRate ?? 1e-5;
+            const grad = opts.gradCheckpoint !== false ? '--grad-checkpoint' : '';
+            // MLX expects a directory with train/valid/test.jsonl
+            const dataDir = splitForMlx(datasetPath);
+            const cmd = [
+                'mlx_lm.lora',
+                '--model', baseModel,
+                '--train',
+                '--data', dataDir,
+                '--batch-size', String(batch),
+                '--num-layers', String(layers),
+                '--iters', String(iters),
+                '--learning-rate', String(lr),
+                '--adapter-path', adapterPath,
+                grad,
+            ].filter(Boolean).join(' ');
+            const r = shell(cmd);
+            log('train', r.ok, Date.now() - t0, r.output.split('\n').slice(-15).join('\n'));
+            if (!r.ok)
+                return { results, summary: 'Training failed. See log.' };
+        }
+        else if (backend === 'together') {
+            // Cloud fallback — delegate to existing train_start tool expectations
+            log('train', false, Date.now() - t0, 'Cloud backend: use `kbot train_start --backend together` directly; train-self cloud flow not yet implemented.');
+            return { results, summary: 'Cloud backend not wired in train-self yet.' };
+        }
+        else {
+            log('train', false, Date.now() - t0, `Backend ${backend} not yet wired; use mlx.`);
+            return { results, summary: `Backend ${backend} not supported in train-self yet.` };
+        }
+    }
+    // ── Stage 3: Fuse adapter ───────────────────────────────────────
+    if (!opts.skipTrain && hasBin('mlx_lm.fuse')) {
+        const t0 = Date.now();
+        const cmd = [
+            'mlx_lm.fuse',
+            '--model', baseModel,
+            '--adapter-path', adapterPath,
+            '--save-path', fusedPath,
+        ].join(' ');
+        const r = shell(cmd);
+        log('fuse', r.ok, Date.now() - t0, r.output.split('\n').slice(-8).join('\n'));
+        if (!r.ok)
+            return { results, summary: 'Fuse failed.' };
+    }
+    // ── Stage 4: Convert to GGUF (for Ollama) ───────────────────────
+    if (!opts.skipDeploy) {
+        const t0 = Date.now();
+        // Preferred: llama.cpp convert script
+        if (hasBin('python3')) {
+            const convertCmd = `python3 -m mlx_lm.convert --hf-path ${fusedPath} --quantize --q-bits 4 --mlx-path ${fusedPath}-mlx4`;
+            const r = shell(convertCmd);
+            log('quantize', r.ok, Date.now() - t0, r.output.split('\n').slice(-8).join('\n'));
+        }
+        else {
+            log('quantize', false, Date.now() - t0, 'python3 not available');
+        }
+    }
+    // ── Stage 5: Deploy to Ollama ───────────────────────────────────
+    if (!opts.skipDeploy && hasBin('ollama')) {
+        const t0 = Date.now();
+        // Write a Modelfile that points Ollama at the fused weights.
+        // For a first pass we use the GGUF path if it exists, else the fused dir.
+        const modelfilePath = join(workDir, 'Modelfile');
+        const fromPath = existsSync(ggufPath) ? ggufPath : fusedPath;
+        const modelfile = [
+            `FROM ${fromPath}`,
+            `PARAMETER temperature 0.2`,
+            `PARAMETER top_p 0.9`,
+            `SYSTEM "You are kbot's self-trained assistant (${mode} mode). You were fine-tuned on the operator's own agent sessions."`,
+        ].join('\n');
+        try {
+            require('node:fs').writeFileSync(modelfilePath, modelfile);
+            const cmd = `ollama create ${outputName} -f ${modelfilePath}`;
+            const r = shell(cmd);
+            log('deploy', r.ok, Date.now() - t0, r.output.split('\n').slice(-8).join('\n'));
+            if (!r.ok)
+                return { results, summary: 'Deploy failed.' };
+        }
+        catch (err) {
+            log('deploy', false, Date.now() - t0, err instanceof Error ? err.message : String(err));
+            return { results, summary: 'Deploy failed.' };
+        }
+    }
+    const allOk = results.every(r => r.ok);
+    return {
+        results,
+        summary: allOk
+            ? `Success. Model registered as Ollama: ${outputName}. Test with: kbot local && kbot --model ${outputName}`
+            : `Partial success. ${results.filter(r => r.ok).length}/${results.length} steps passed.`,
+    };
+}
+/** CLI-facing: pretty-print a run. */
+export function formatTrainSelfReport(r) {
+    const lines = ['train-self', '─'.repeat(50)];
+    for (const step of r.results) {
+        const icon = step.ok ? 'ok' : 'FAIL';
+        const ms = `${(step.duration_ms / 1000).toFixed(1)}s`;
+        lines.push(`  [${icon.padStart(4)}] ${step.step.padEnd(12)} ${ms.padStart(8)}`);
+        if (step.details) {
+            for (const d of step.details.split('\n').slice(0, 6)) {
+                lines.push(`         ${d}`);
+            }
+        }
+    }
+    lines.push('', r.summary);
+    return lines.join('\n');
+}
+//# sourceMappingURL=train-self.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@kernel.chat/kbot",
-  "version": "3.97.1",
+  "version": "3.98.0",
   "description": "Open-source terminal AI agent. 787+ tools, 35 agents, 20 providers. Dreams, learns, watches your system. Controls your phone. Fully local, fully sovereign. MIT.",
   "type": "module",
   "repository": {