@kernel.chat/kbot 3.97.4 → 3.98.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) {

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

package/dist/tools/idempotency-check.d.ts

@@ -0,0 +1,2 @@
+export declare function registerIdempotencyTools(): void;
+//# sourceMappingURL=idempotency-check.d.ts.map

package/dist/tools/idempotency-check.js

@@ -0,0 +1,31 @@
+// kbot Idempotency Check Tool — Prevent duplicate actions
+// This tool verifies if a task has already been executed to avoid unintended side effects.
+import { registerTool } from './index.js';
+export function registerIdempotencyTools() {
+    registerTool({
+        name: 'idempotency_check',
+        description: 'Checks if an action has already been performed based on a unique identifier. Returns true if the action has been done, false otherwise.',
+        parameters: {
+            identifier: { type: 'string', description: 'Unique identifier for the action', required: true },
+        },
+        tier: 'free',
+        async execute(args) {
+            const identifier = String(args.identifier);
+            // Simulate a database check (replace with actual DB query)
+            const hasRun = await simulateDatabaseCheck(identifier);
+            if (hasRun) {
+                return 'true';
+            }
+            else {
+                return 'false';
+            }
+        },
+    });
+}
+async function simulateDatabaseCheck(identifier) {
+    // Replace with actual database query logic
+    // This is a placeholder for demonstration purposes
+    console.log(`Simulating database check for identifier: ${identifier}`);
+    return false; // Assume not run for now
+}
+//# sourceMappingURL=idempotency-check.js.map

package/dist/tools/schedule-persistence.d.ts

@@ -0,0 +1,2 @@
+export declare function registerSchedulePersistenceTools(): void;
+//# sourceMappingURL=schedule-persistence.d.ts.map

package/dist/tools/schedule-persistence.js

@@ -0,0 +1,19 @@
+// kbot Schedule Persistence Tool — Reliable task scheduling
+import { registerTool } from './index.js';
+export function registerSchedulePersistenceTools() {
+    registerTool({
+        name: 'schedule_persist',
+        description: 'Persistently stores and retrieves schedules, ensuring tasks are executed even after interruptions.',
+        parameters: {
+            schedule: { type: 'string', description: 'The schedule to persist (JSON format)', required: true },
+        },
+        tier: 'pro',
+        async execute(args) {
+            const schedule = JSON.parse(String(args.schedule));
+            // Placeholder for persistence logic (replace with actual implementation)
+            console.log(`Persisting schedule: ${JSON.stringify(schedule)}`);
+            return 'Schedule persisted (implementation placeholder)';
+        },
+    });
+}
+//# sourceMappingURL=schedule-persistence.js.map

package/dist/train-agent-trace.d.ts

@@ -0,0 +1,29 @@
+export declare const TOOL_TOKENS: {
+    readonly think_open: "<think>";
+    readonly think_close: "</think>";
+    readonly tool_open: "<tool>";
+    readonly tool_close: "</tool>";
+    readonly args_open: "<args>";
+    readonly args_close: "</args>";
+    readonly result_open: "<result>";
+    readonly result_close: "</result>";
+    readonly answer_open: "<answer>";
+    readonly answer_close: "</answer>";
+};
+export interface AgentTraceOptions {
+    input?: string;
+    output?: string;
+    minTools?: number;
+    maxResultLen?: number;
+    verifiedOnly?: boolean;
+}
+export interface AgentTraceResult {
+    output: string;
+    trajectories: number;
+    examples: number;
+    skipped_no_tools: number;
+    skipped_errors: number;
+}
+export declare function formatAgentTraces(opts?: AgentTraceOptions): AgentTraceResult;
+export declare function formatAgentTraceReport(r: AgentTraceResult): string;
+//# sourceMappingURL=train-agent-trace.d.ts.map

package/dist/train-agent-trace.js

@@ -0,0 +1,141 @@
+// train-agent-trace — reformat multi-turn tool-use sessions into training examples
+// with explicit tool tokens. Used by train-self --mode agent-trace.
+//
+// Output format (one example per completed trajectory):
+//   {"messages": [
+//     {"role":"user","content":"..."},
+//     {"role":"assistant","content":"<think>...</think><tool>name</tool><args>{...}</args>"},
+//     {"role":"tool","content":"<result>...</result>"},
+//     {"role":"assistant","content":"<think>...</think><answer>...</answer>"}
+//   ]}
+//
+// Tool tokens we inject:
+//   <think>...</think>   — reasoning
+//   <tool>name</tool>    — tool selected
+//   <args>{...}</args>   — JSON arguments
+//   <result>...</result> — tool output (truncated)
+//   <answer>...</answer> — final assistant turn
+import { existsSync, readFileSync, writeFileSync, appendFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { homedir } from 'node:os';
+export const TOOL_TOKENS = {
+    think_open: '<think>', think_close: '</think>',
+    tool_open: '<tool>', tool_close: '</tool>',
+    args_open: '<args>', args_close: '</args>',
+    result_open: '<result>', result_close: '</result>',
+    answer_open: '<answer>', answer_close: '</answer>',
+};
+function truncate(s, n) {
+    if (s.length <= n)
+        return s;
+    return s.slice(0, n) + ` …[+${s.length - n} chars]`;
+}
+/** Build an assistant turn with think + tool call tokens. */
+function assistantToolTurn(thinking, toolName, args) {
+    const thinkPart = thinking
+        ? `${TOOL_TOKENS.think_open}${thinking.trim()}${TOOL_TOKENS.think_close}\n`
+        : '';
+    const argsJson = JSON.stringify(args);
+    return `${thinkPart}${TOOL_TOKENS.tool_open}${toolName}${TOOL_TOKENS.tool_close}\n${TOOL_TOKENS.args_open}${argsJson}${TOOL_TOKENS.args_close}`;
+}
+/** Build a tool-result turn. */
+function toolResultTurn(result, maxLen) {
+    return `${TOOL_TOKENS.result_open}${truncate(result, maxLen)}${TOOL_TOKENS.result_close}`;
+}
+/** Build the final assistant answer turn. */
+function answerTurn(thinking, content) {
+    const thinkPart = thinking
+        ? `${TOOL_TOKENS.think_open}${thinking.trim()}${TOOL_TOKENS.think_close}\n`
+        : '';
+    return `${thinkPart}${TOOL_TOKENS.answer_open}${content.trim()}${TOOL_TOKENS.answer_close}`;
+}
+/** Convert one teacher trace into an agent-trace example. */
+function formatTrace(t, maxResult) {
+    const toolCalls = t.response.tool_calls || [];
+    if (toolCalls.length === 0)
+        return null;
+    const messages = [];
+    // Seed with conversation context (excluding the final assistant turn)
+    for (const m of t.messages) {
+        if (m.role === 'user' || m.role === 'system') {
+            messages.push({ role: m.role, content: m.content });
+        }
+    }
+    // Inject assistant tool-call turn
+    const firstCall = toolCalls[0];
+    messages.push({
+        role: 'assistant',
+        content: assistantToolTurn(t.response.thinking || '', firstCall.name, firstCall.arguments),
+    });
+    // We don't have the actual tool result in teacher traces — synthesize a placeholder
+    // that the model can learn to parse. In production, the tool executor would fill this
+    // when replaying recorded sessions.
+    messages.push({
+        role: 'tool',
+        content: toolResultTurn('[result from ' + firstCall.name + ']', maxResult),
+    });
+    // Final answer
+    messages.push({
+        role: 'assistant',
+        content: answerTurn('', t.response.content),
+    });
+    return {
+        messages,
+        _tool_count: toolCalls.length,
+        _trace_id: t.id,
+    };
+}
+export function formatAgentTraces(opts = {}) {
+    const input = opts.input ?? join(homedir(), '.kbot', 'teacher', 'traces.jsonl');
+    const output = opts.output ?? join(homedir(), '.kbot', 'teacher', 'dataset-agent-trace.jsonl');
+    const minTools = opts.minTools ?? 1;
+    const maxResult = opts.maxResultLen ?? 1200;
+    const result = {
+        output,
+        trajectories: 0,
+        examples: 0,
+        skipped_no_tools: 0,
+        skipped_errors: 0,
+    };
+    if (!existsSync(input))
+        return result;
+    // Truncate output
+    writeFileSync(output, '');
+    const lines = readFileSync(input, 'utf-8').split('\n').filter(l => l.trim());
+    for (const line of lines) {
+        try {
+            const t = JSON.parse(line);
+            result.trajectories++;
+            if (opts.verifiedOnly && !t.outcome?.verified) {
+                result.skipped_errors++;
+                continue;
+            }
+            const toolCount = t.response.tool_calls?.length || 0;
+            if (toolCount < minTools) {
+                result.skipped_no_tools++;
+                continue;
+            }
+            const ex = formatTrace(t, maxResult);
+            if (ex) {
+                appendFileSync(output, JSON.stringify(ex) + '\n');
+                result.examples++;
+            }
+        }
+        catch {
+            result.skipped_errors++;
+        }
+    }
+    return result;
+}
+export function formatAgentTraceReport(r) {
+    return [
+        'agent-trace formatter',
+        '─'.repeat(40),
+        `  Output:             ${r.output}`,
+        `  Trajectories seen:  ${r.trajectories}`,
+        `  Examples emitted:   ${r.examples}`,
+        `  Skipped (no tools): ${r.skipped_no_tools}`,
+        `  Skipped (errors):   ${r.skipped_errors}`,
+    ].join('\n');
+}
+//# sourceMappingURL=train-agent-trace.js.map

package/dist/train-curate.d.ts

@@ -0,0 +1,25 @@
+export type CurateMode = 'default' | 'reasoning' | 'agent-trace' | 'code-only';
+export interface CurateOptions {
+    sources?: string[];
+    output?: string;
+    mode?: CurateMode;
+    maxExamples?: number;
+    minScore?: number;
+    minResponseLen?: number;
+    maxResponseLen?: number;
+    dedupe?: boolean;
+}
+export interface CurateResult {
+    output: string;
+    total_examined: number;
+    kept: number;
+    rejected: number;
+    duplicates: number;
+    mean_score: number;
+    by_source: Record<string, number>;
+}
+/** Run the curator end-to-end. Returns a report. */
+export declare function curate(opts?: CurateOptions): CurateResult;
+/** Format as a human-readable report */
+export declare function formatCurateReport(r: CurateResult): string;
+//# sourceMappingURL=train-curate.d.ts.map