@kernel.chat/kbot 3.97.4 → 3.99.0

package/dist/train-cycle.js

@@ -0,0 +1,230 @@
+// train-cycle — on-policy distillation loop (DeepSeek-R1 Distill pattern).
+//
+// Loop:
+//   1. Sample N prompts from held-out pool (~/.kbot/teacher/prompts.jsonl)
+//   2. Student (local model) generates response
+//   3. Teacher (Claude) grades; if bad, teacher writes a corrected response
+//   4. Pairs go back into ~/.kbot/teacher/corrections.jsonl
+//   5. Optionally retrain via train-self --mode default (with corrections merged)
+//
+// Designed to run as a weekly cron or on-demand.
+import { existsSync, readFileSync, appendFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { homedir } from 'node:os';
+function readPrompts(file) {
+    if (!existsSync(file))
+        return [];
+    return readFileSync(file, 'utf-8')
+        .split('\n')
+        .filter(l => l.trim())
+        .map(l => { try {
+        return JSON.parse(l);
+    }
+    catch {
+        return null;
+    } })
+        .filter((x) => x !== null && typeof x.prompt === 'string');
+}
+/** Auto-harvest prompts from teacher/traces.jsonl (user messages) if no explicit file. */
+function harvestPrompts(limit = 200) {
+    const traceFile = join(homedir(), '.kbot', 'teacher', 'traces.jsonl');
+    if (!existsSync(traceFile))
+        return [];
+    const lines = readFileSync(traceFile, 'utf-8').split('\n').filter(l => l.trim());
+    const out = [];
+    for (const line of lines.slice(-limit * 2)) {
+        try {
+            const t = JSON.parse(line);
+            const msgs = t.messages;
+            const firstUser = msgs?.find(m => m.role === 'user');
+            if (firstUser && firstUser.content.length > 20 && firstUser.content.length < 2000) {
+                out.push({ prompt: firstUser.content, system: t.system });
+            }
+            if (out.length >= limit)
+                break;
+        }
+        catch { /* skip */ }
+    }
+    return out;
+}
+async function callOllama(model, system, prompt) {
+    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: 0.2 },
+        }),
+        signal: AbortSignal.timeout(300_000),
+    });
+    if (!res.ok)
+        throw new Error(`Ollama HTTP ${res.status}`);
+    const data = await res.json();
+    return data.message?.content || '';
+}
+async function callAnthropicGrade(apiKey, teacherModel, system, prompt, studentResponse) {
+    const gradePrompt = `You are grading a student AI's response. Score 0.0–1.0 based on correctness, completeness, and helpfulness.
+
+If the response scores below 0.6, provide a corrected response.
+
+Return ONLY valid JSON in this exact shape:
+{"score": <number>, "rationale": "<one sentence>", "correction": "<corrected response or empty string>"}
+
+ORIGINAL PROMPT:
+${prompt.slice(0, 4000)}
+
+STUDENT RESPONSE:
+${studentResponse.slice(0, 6000)}`;
+    const res = await fetch('https://api.anthropic.com/v1/messages', {
+        method: 'POST',
+        headers: {
+            'Content-Type': 'application/json',
+            'x-api-key': apiKey,
+            'anthropic-version': '2023-06-01',
+        },
+        body: JSON.stringify({
+            model: teacherModel,
+            max_tokens: 4096,
+            system: system || 'You are a strict code/AI grader.',
+            messages: [{ role: 'user', content: gradePrompt }],
+        }),
+        signal: AbortSignal.timeout(120_000),
+    });
+    if (!res.ok)
+        throw new Error(`Anthropic HTTP ${res.status}`);
+    const data = await res.json();
+    const text = (data.content || []).filter(b => b.type === 'text').map(b => b.text).join('');
+    // Extract JSON from response
+    const jsonMatch = text.match(/\{[\s\S]*\}/);
+    if (!jsonMatch)
+        return { score: 0, rationale: 'no JSON in response', correction: undefined };
+    try {
+        const parsed = JSON.parse(jsonMatch[0]);
+        return {
+            score: typeof parsed.score === 'number' ? parsed.score : 0,
+            rationale: parsed.rationale || '',
+            correction: parsed.correction || undefined,
+        };
+    }
+    catch {
+        return { score: 0, rationale: 'JSON parse failed', correction: undefined };
+    }
+}
+export async function runCycle(opts = {}) {
+    const studentModel = opts.studentModel ?? 'kernel-coder:latest';
+    const teacherProvider = opts.teacherProvider ?? 'anthropic';
+    const teacherModel = opts.teacherModel ?? 'claude-opus-4-6';
+    const promptsFile = opts.promptsFile ?? join(homedir(), '.kbot', 'teacher', 'prompts.jsonl');
+    const correctionsFile = opts.corrections ?? join(homedir(), '.kbot', 'teacher', 'corrections.jsonl');
+    const samples = opts.samples ?? 50;
+    const threshold = opts.passThreshold ?? 0.6;
+    let prompts = readPrompts(promptsFile);
+    if (prompts.length === 0)
+        prompts = harvestPrompts(samples * 3);
+    if (prompts.length === 0) {
+        return {
+            sampled: 0, passed: 0, corrected: 0, skipped: 0,
+            corrections_file: correctionsFile,
+        };
+    }
+    // Shuffle + take N
+    prompts = prompts.sort(() => Math.random() - 0.5).slice(0, samples);
+    let passed = 0, corrected = 0, skipped = 0;
+    // Pull teacher API key
+    let teacherKey = '';
+    if (teacherProvider === 'anthropic') {
+        teacherKey = process.env.ANTHROPIC_API_KEY || '';
+        if (!teacherKey) {
+            try {
+                const cfg = JSON.parse(readFileSync(join(homedir(), '.kbot', 'config.json'), 'utf-8'));
+                teacherKey = cfg.anthropic_api_key || cfg.anthropicApiKey || '';
+            }
+            catch { /* no config */ }
+        }
+        if (!teacherKey)
+            throw new Error('No Anthropic API key for teacher. Set ANTHROPIC_API_KEY or run `kbot auth`.');
+    }
+    for (const p of prompts) {
+        try {
+            const studentResp = await callOllama(studentModel, p.system || '', p.prompt);
+            if (!studentResp || studentResp.length < 20) {
+                skipped++;
+                continue;
+            }
+            if (opts.dryRun) {
+                passed++;
+                continue;
+            }
+            const grade = await callAnthropicGrade(teacherKey, teacherModel, p.system || '', p.prompt, studentResp);
+            if (grade.score >= threshold) {
+                passed++;
+                // Keep good student responses as training examples too
+                appendFileSync(correctionsFile, JSON.stringify({
+                    messages: [
+                        ...(p.system ? [{ role: 'system', content: p.system }] : []),
+                        { role: 'user', content: p.prompt },
+                        { role: 'assistant', content: studentResp },
+                    ],
+                    _score: grade.score,
+                    _source: 'student_passed',
+                }) + '\n');
+            }
+            else if (grade.correction) {
+                corrected++;
+                appendFileSync(correctionsFile, JSON.stringify({
+                    messages: [
+                        ...(p.system ? [{ role: 'system', content: p.system }] : []),
+                        { role: 'user', content: p.prompt },
+                        { role: 'assistant', content: grade.correction },
+                    ],
+                    _score: 1.0,
+                    _source: 'teacher_corrected',
+                    _student_score: grade.score,
+                    _rationale: grade.rationale,
+                }) + '\n');
+            }
+            else {
+                skipped++;
+            }
+        }
+        catch {
+            skipped++;
+        }
+    }
+    let retrainSummary;
+    if (opts.retrain && !opts.dryRun) {
+        const { trainSelf, formatTrainSelfReport } = await import('./train-self.js');
+        // Merge corrections into next dataset: curator picks them up from ~/.kbot/teacher/
+        const r = await trainSelf({ mode: 'default' });
+        retrainSummary = formatTrainSelfReport(r);
+    }
+    return {
+        sampled: prompts.length,
+        passed,
+        corrected,
+        skipped,
+        corrections_file: correctionsFile,
+        retrain_summary: retrainSummary,
+    };
+}
+export function formatCycleReport(r) {
+    const lines = [
+        'train-cycle',
+        '─'.repeat(40),
+        `  Sampled:      ${r.sampled}`,
+        `  Passed:       ${r.passed}  (student got it right)`,
+        `  Corrected:    ${r.corrected}  (teacher rewrote)`,
+        `  Skipped:      ${r.skipped}`,
+        `  Corrections:  ${r.corrections_file}`,
+    ];
+    if (r.retrain_summary) {
+        lines.push('', 'Retrain:', r.retrain_summary);
+    }
+    return lines.join('\n');
+}
+//# sourceMappingURL=train-cycle.js.map

package/dist/train-grpo.d.ts

@@ -0,0 +1,68 @@
+export type Verifier = {
+    kind: 'build-pass';
+    cwd: string;
+    cmd: string;
+} | {
+    kind: 'test-pass';
+    cwd: string;
+    cmd: string;
+} | {
+    kind: 'lint-pass';
+    cwd: string;
+    cmd: string;
+} | {
+    kind: 'regex-match';
+    pattern: string;
+    flags?: string;
+} | {
+    kind: 'json-valid';
+    requireKeys?: string[];
+} | {
+    kind: 'custom';
+    script: string;
+};
+export interface GrpoPrompt {
+    id?: string;
+    prompt: string;
+    system?: string;
+    verifier: Verifier;
+    tags?: string[];
+}
+export interface GrpoOptions {
+    studentModel?: string;
+    prompts: GrpoPrompt[];
+    groupSize?: number;
+    iters?: number;
+    learningRate?: number;
+    klBeta?: number;
+    outputDir?: string;
+    runnerCmd?: string;
+    dryRun?: boolean;
+}
+export interface RolloutResult {
+    prompt_id: string;
+    completions: Array<{
+        text: string;
+        reward: number;
+        verifier_ok: boolean;
+    }>;
+    advantage: number[];
+}
+export interface GrpoResult {
+    ok: boolean;
+    output_dir: string;
+    rollouts: RolloutResult[];
+    iterations_run: number;
+    mean_reward: number;
+    log: string;
+}
+/** Apply a verifier to a completion. Returns { ok, reward ∈ [0,1] }. */
+export declare function verify(v: Verifier, completion: string): Promise<{
+    ok: boolean;
+    reward: number;
+}>;
+export declare function runGrpoRollouts(opts: GrpoOptions): Promise<GrpoResult>;
+/** Default verifier suite for kbot: regex + JSON validity on common code gen. */
+export declare const DEFAULT_VERIFIER_SUITE: GrpoPrompt[];
+export declare function formatGrpoReport(r: GrpoResult): string;
+//# sourceMappingURL=train-grpo.d.ts.map

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