@kernel.chat/kbot 3.97.4 → 3.99.0

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) {
@@ -854,7 +875,7 @@ export async function runAgent(message, options = {}) {
     // Step 2: Build context (cached — only rebuilt when inputs change)
     const matrixPrompt = options.agent ? getMatrixSystemPrompt(options.agent) : null;
     const contextSnippet = options.context ? formatContextForPrompt(options.context) : '';
-    const skillsSnippet = loadSkills(process.cwd());
+    const skillsSnippet = loadSkills(process.cwd(), message);
     const memorySnippet = getMemoryPrompt();
     const learningContext = buildFullLearningContext(message, process.cwd());
     const synthesisSnippet = getSynthesisContext(8); // Three-tier memory: reflection layer insights

package/dist/cli.js

@@ -835,6 +835,50 @@ async function main() {
             ignorePatterns,
         });
     });
+    const skillsCmd = program.command('skills').description('Manage agent skills (agentskills.io format — compatible with Claude Skills, Hermes, Copilot)');
+    skillsCmd
+        .command('list')
+        .description('List all discovered skills')
+        .action(async () => {
+        const { discoverSkillFiles } = await import('./skills-loader.js');
+        const skills = discoverSkillFiles(process.cwd());
+        if (skills.length === 0) {
+            printInfo('No skills found. Run `kbot skills import --from hermes` to import 76 Hermes skills.');
+            return;
+        }
+        printInfo(`Found ${skills.length} skill${skills.length === 1 ? '' : 's'}:\n`);
+        for (const s of skills) {
+            const desc = s.description ? ` — ${s.description.slice(0, 70)}` : '';
+            printInfo(`  ${s.name}${desc}`);
+        }
+    });
+    skillsCmd
+        .command('import')
+        .description('Import skills from an external agent (Hermes, Claude, or a custom directory)')
+        .option('--from <source>', 'Source: hermes, claude, or an absolute path', 'hermes')
+        .action(async (opts) => {
+        const { importExternalSkills } = await import('./skills-loader.js');
+        const { homedir } = await import('node:os');
+        const { join } = await import('node:path');
+        const { existsSync } = await import('node:fs');
+        const sources = {
+            hermes: join(homedir(), '.hermes', 'skills'),
+            claude: join(homedir(), '.claude', 'skills'),
+        };
+        const from = opts.from || 'hermes';
+        const src = sources[from] || from;
+        if (!existsSync(src)) {
+            printError(`Source not found: ${src}`);
+            if (from === 'hermes')
+                printInfo('Install Hermes: `ollama launch hermes --yes --model hermes3:8b`');
+            return;
+        }
+        const result = await importExternalSkills(src);
+        printSuccess(`Imported ${result.imported} skill${result.imported === 1 ? '' : 's'} from ${src}`);
+        if (result.skipped > 0)
+            printInfo(`  ${result.skipped} skipped (existing user-authored files preserved)`);
+        printInfo(`  → ${result.destination}`);
+    });
     program
         .command('doctor')
         .description('Diagnose your kbot setup — check everything is working')
@@ -3875,6 +3919,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/skills-loader.d.ts

@@ -2,16 +2,48 @@ export interface SkillFile {
     name: string;
     path: string;
     content: string;
+    description: string;
+    tags: string[];
     tokens: number;
+    /** Skill only activates when these toolsets are available (Hermes: requires_toolsets) */
+    requiresToolsets: string[];
+    /** Skill only activates when these toolsets are UNAVAILABLE (fallback path) */
+    fallbackForToolsets: string[];
+    /** OS platforms this skill supports; empty = all */
+    platforms: string[];
+    /** Related skill names */
+    relatedSkills: string[];
+    /** True for skills that ship with kbot or declare `metadata.kbot.*` — boosted in ranking */
+    native: boolean;
+}
+export interface SkillLoadContext {
+    /** Toolsets currently available — skills can require/fall-back based on these */
+    availableToolsets?: string[];
+    /** Current OS platform, e.g. 'darwin' | 'linux' | 'win32' */
+    platform?: string;
 }
 /**
- * Discover and load skill files from project and global directories.
- * Returns formatted string ready to inject into system prompt.
+ * Discover and load skill files. Returns a prompt-ready string.
+ * When `message` is provided, skills are scored for relevance and only the
+ * most relevant are included (keeps token budget tight with a large library).
  */
-export declare function loadSkills(projectRoot: string): string;
+export declare function loadSkills(projectRoot: string, message?: string, ctx?: SkillLoadContext): string;
 /**
- * Discover .md files from both project-local and global skill directories.
- * Project skills take precedence (loaded first, consume token budget first).
+ * Walk both skill roots and return every skill document found.
+ * Handles flat files (name.md) AND subdirectory layouts (cat/name/SKILL.md).
+ * Project skills take precedence over global skills with the same name.
  */
 export declare function discoverSkillFiles(projectRoot: string): SkillFile[];
+export interface ImportResult {
+    imported: number;
+    skipped: number;
+    source: string;
+    destination: string;
+}
+/**
+ * Copy (as symlinks) every SKILL.md under a foreign skills directory
+ * into ~/.kbot/skills/imported/<category>/<name>/SKILL.md.
+ * Non-destructive: existing symlinks are replaced, real files are skipped.
+ */
+export declare function importExternalSkills(sourceRoot: string): Promise<ImportResult>;
 //# sourceMappingURL=skills-loader.d.ts.map