@openclawcity/become 0.1.0

package/dist/index.d.ts

@@ -0,0 +1,670 @@
+import { a as StorageAdapter, b as Skill, D as DreyfusStage, c as SkillInput, d as CatalogEntry, S as Score, e as SkillTrend, R as ReflectionInput, f as Reflection, A as AgentContext, O as Observation, g as MilestoneConfig, M as Milestone, C as CelebrationTier, B as BloomsLevel, h as ScoreInput, P as PeerReview, L as LearningEdge, i as ResponseScore, j as CulturalNorm, N as NormCategory, k as ConversationTurn, l as ReviewAssignment, m as ReviewVerdict, n as ReputationLevel, o as AwarenessScore, G as GrowthSnapshot, p as GrowthDiff } from './types-DzOc15AL.js';
+export { q as LearningEventType, r as LearningSource, s as NormEvidence, t as ReputationTier, u as ScoreEvidence } from './types-DzOc15AL.js';
+
+declare class SkillStore {
+    private adapter;
+    constructor(adapter: StorageAdapter);
+    get(agentId: string, skill: string): Promise<Skill | null>;
+    list(agentId: string, opts?: {
+        stage?: DreyfusStage;
+        limit?: number;
+    }): Promise<Skill[]>;
+    upsert(agentId: string, input: SkillInput): Promise<Skill>;
+    delete(agentId: string, skill: string): Promise<void>;
+    catalog(): Promise<CatalogEntry[]>;
+    holders(skill: string): Promise<Skill[]>;
+    suggest(agentId: string): Promise<string[]>;
+    history(agentId: string, skill: string, days?: number): Promise<Score[]>;
+    trending(agentId: string, topN?: number): Promise<SkillTrend[]>;
+    static normalizeName(raw: string): string;
+    static validateName(name: string): boolean;
+}
+
+declare class Reflector {
+    private adapter;
+    constructor(adapter: StorageAdapter);
+    reflect(agentId: string, input: ReflectionInput): Promise<Reflection>;
+    list(agentId: string, opts?: {
+        skill?: string;
+        limit?: number;
+    }): Promise<Reflection[]>;
+    observe(context: AgentContext): Observation[];
+}
+declare function detectCreativeMismatch(ctx: AgentContext): Observation | null;
+declare function detectCollaborationGap(ctx: AgentContext): Observation | null;
+declare function detectReactionDisparity(ctx: AgentContext): Observation | null;
+declare function detectIdleCreative(ctx: AgentContext): Observation | null;
+declare function detectQuestStreak(ctx: AgentContext): Observation | null;
+declare function detectSoloCreator(ctx: AgentContext): Observation | null;
+declare function detectProlificCollaborator(ctx: AgentContext): Observation | null;
+declare function detectSymbolicVocabulary(ctx: AgentContext): Observation | null;
+declare function detectCollectiveMemory(ctx: AgentContext): Observation | null;
+declare function detectCulturalOutlier(ctx: AgentContext): Observation | null;
+
+declare class MilestoneDetector {
+    private adapter;
+    private custom;
+    constructor(adapter: StorageAdapter);
+    register(type: string, config: MilestoneConfig): void;
+    check(agentId: string, scores: Score[]): Promise<Milestone[]>;
+    private tryAward;
+    static celebrationTier(milestoneType: string, threshold?: number): CelebrationTier;
+    static getBuiltInMilestones(): Record<string, MilestoneConfig>;
+}
+
+declare const BLOOMS_ORDER: BloomsLevel[];
+declare const BLOOMS_SCORE: Record<BloomsLevel, number>;
+declare const DREYFUS_THRESHOLDS: Record<string, {
+    next: string;
+    score: number;
+}>;
+declare const WEIGHTS: {
+    readonly artifact: 0.3;
+    readonly feedback: 0.2;
+    readonly improvement: 0.2;
+    readonly depth: 0.15;
+    readonly social: 0.1;
+    readonly teaching: 0.05;
+};
+declare function dreyfusStage(score: number): DreyfusStage;
+declare function detectBloomsLevel(input: ScoreInput): BloomsLevel;
+declare function computeScore(input: ScoreInput): number;
+declare function computeFullScore(skill: string, input: ScoreInput): Score;
+declare function nextMilestone(stage: DreyfusStage, score: number): string | null;
+declare function scoreTrend(current: number, weekAgo: number | null): string | null;
+
+declare const Scorer_BLOOMS_ORDER: typeof BLOOMS_ORDER;
+declare const Scorer_BLOOMS_SCORE: typeof BLOOMS_SCORE;
+declare const Scorer_DREYFUS_THRESHOLDS: typeof DREYFUS_THRESHOLDS;
+declare const Scorer_WEIGHTS: typeof WEIGHTS;
+declare const Scorer_computeFullScore: typeof computeFullScore;
+declare const Scorer_computeScore: typeof computeScore;
+declare const Scorer_detectBloomsLevel: typeof detectBloomsLevel;
+declare const Scorer_dreyfusStage: typeof dreyfusStage;
+declare const Scorer_nextMilestone: typeof nextMilestone;
+declare const Scorer_scoreTrend: typeof scoreTrend;
+declare namespace Scorer {
+  export { Scorer_BLOOMS_ORDER as BLOOMS_ORDER, Scorer_BLOOMS_SCORE as BLOOMS_SCORE, Scorer_DREYFUS_THRESHOLDS as DREYFUS_THRESHOLDS, Scorer_WEIGHTS as WEIGHTS, Scorer_computeFullScore as computeFullScore, Scorer_computeScore as computeScore, Scorer_detectBloomsLevel as detectBloomsLevel, Scorer_dreyfusStage as dreyfusStage, Scorer_nextMilestone as nextMilestone, Scorer_scoreTrend as scoreTrend };
+}
+
+declare function validateAgentId(agentId: string): void;
+
+declare class MemoryStore implements StorageAdapter {
+    private skills;
+    private catalog;
+    private scoreHistory;
+    private reflections;
+    private milestones;
+    private peerReviews;
+    private learningEdges;
+    private reputationMap;
+    private conversationScores;
+    private norms;
+    private idCounter;
+    private nextId;
+    /** Reset all data. Useful for test isolation. */
+    clear(): void;
+    getSkill(agentId: string, skill: string): Promise<Skill | null>;
+    listSkills(agentId: string, opts?: {
+        stage?: DreyfusStage;
+        limit?: number;
+    }): Promise<Skill[]>;
+    upsertSkill(skill: Skill): Promise<void>;
+    deleteSkill(agentId: string, skill: string): Promise<void>;
+    getCatalog(): Promise<CatalogEntry[]>;
+    upsertCatalogEntry(entry: Omit<CatalogEntry, 'adopter_count'>): Promise<void>;
+    getSkillHolders(skill: string): Promise<Skill[]>;
+    getSkillAdopterCount(skill: string): Promise<number>;
+    updateCatalogStatus(skill: string, status: 'community' | 'verified'): Promise<void>;
+    saveScore(agentId: string, score: Score): Promise<void>;
+    getScoreHistory(agentId: string, skill: string, days?: number): Promise<Score[]>;
+    getLatestScores(agentId: string): Promise<Score[]>;
+    saveReflection(reflection: Reflection): Promise<Reflection>;
+    getReflections(agentId: string, opts?: {
+        skill?: string;
+        limit?: number;
+    }): Promise<Reflection[]>;
+    countReflectionsToday(agentId: string, skill: string): Promise<number>;
+    saveMilestone(milestone: Milestone): Promise<boolean>;
+    getMilestones(agentId: string): Promise<Milestone[]>;
+    hasMilestone(agentId: string, milestoneType: string, skill?: string): Promise<boolean>;
+    savePeerReview(review: PeerReview): Promise<PeerReview>;
+    getReviewsFor(agentId: string, opts?: {
+        skill?: string;
+    }): Promise<PeerReview[]>;
+    getReviewsBy(agentId: string): Promise<PeerReview[]>;
+    saveLearningEdge(edge: LearningEdge): Promise<void>;
+    getLearningEdges(agentId: string, direction: 'from' | 'to'): Promise<LearningEdge[]>;
+    getReputation(agentId: string): Promise<number>;
+    grantReputation(agentId: string, amount: number, _type: string, _description: string): Promise<void>;
+    saveConversationScore(agentId: string, score: ResponseScore & {
+        session_id?: string;
+    }): Promise<void>;
+    getConversationScores(agentId: string, opts?: {
+        limit?: number;
+    }): Promise<ResponseScore[]>;
+    saveNorm(norm: CulturalNorm): Promise<void>;
+    getNorms(opts?: {
+        category?: NormCategory;
+        limit?: number;
+    }): Promise<CulturalNorm[]>;
+}
+
+interface LearningSignal {
+    skill_updates: {
+        skill: string;
+        delta: number;
+        reason: string;
+    }[];
+    new_skills?: string[];
+    observations?: string[];
+}
+interface ConversationSession {
+    agent_id: string;
+    session_id?: string;
+    turns: ConversationTurn[];
+}
+interface SessionLearning {
+    turns_scored: number;
+    success_rate: number;
+    skills_improved: string[];
+    skills_degraded: string[];
+    failure_patterns: string[];
+    should_evolve: boolean;
+}
+/** Optional LLM judge for automated response scoring */
+interface LLMJudge {
+    score(userMessage: string, agentResponse: string, context?: string): Promise<{
+        quality: -1 | 0 | 1;
+        reasoning: string;
+    }>;
+}
+declare class ConversationLearner {
+    private adapter;
+    private judge?;
+    constructor(adapter: StorageAdapter, judge?: LLMJudge | undefined);
+    /** Score a single conversation turn using feedback signals */
+    scoreResponse(turn: ConversationTurn): ResponseScore;
+    /** Score using optional LLM judge for higher-quality automated assessment */
+    scoreWithJudge(turn: ConversationTurn): Promise<ResponseScore>;
+    /** Process a turn: score it and persist */
+    afterTurn(turn: ConversationTurn): Promise<LearningSignal>;
+    /** Summarize learning across a full session */
+    afterSession(session: ConversationSession): Promise<SessionLearning>;
+    /** Batch score multiple turns */
+    batchScore(turns: ConversationTurn[]): ResponseScore[];
+}
+
+interface GeneratedSkill {
+    name: string;
+    category: string;
+    content: string;
+    source: 'evolved';
+    evolved_from: string[];
+}
+interface EvolveLLM {
+    generate(prompt: string): Promise<string>;
+}
+declare class SkillEvolver {
+    private llm;
+    constructor(llm: EvolveLLM);
+    /** Check if evolution should trigger based on recent scores */
+    shouldEvolve(recentScores: ResponseScore[]): boolean;
+    /** Generate corrective skills from failure patterns */
+    evolve(failures: {
+        turn: ConversationTurn;
+        score: ResponseScore;
+    }[], existingSkills: Skill[]): Promise<GeneratedSkill[]>;
+    private parseResponse;
+}
+
+declare class SkillPruner {
+    /**
+     * Identify skills that don't correlate with improved scores.
+     *
+     * Rules:
+     * - Skill must be at least minAge days old
+     * - Score has not improved (delta <= 0) over skill's lifetime → candidate
+     * - Never prune skills at competent stage or above (proven useful)
+     * - Requires at least 2 score history points to judge trajectory
+     */
+    findIneffective(skills: Skill[], scoreHistory: Map<string, Score[]>, minAge?: number): string[];
+    /** Remove identified skills */
+    prune(adapter: StorageAdapter, agentId: string, skillNames: string[]): Promise<number>;
+}
+
+/**
+ * Parse a single Markdown skill file with YAML frontmatter.
+ *
+ * Expected format:
+ * ---
+ * name: skill_name
+ * category: coding
+ * ---
+ * Skill content here...
+ */
+declare function parseSkillFile(content: string): SkillInput | null;
+/**
+ * Import skills from a directory of Markdown files.
+ * Recursively scans for .md files with YAML frontmatter.
+ * Max recursion depth: 10 levels.
+ */
+declare function importSkillDirectory(dir: string, _depth?: number): SkillInput[];
+
+declare class PeerReviewProtocol {
+    private adapter;
+    constructor(adapter: StorageAdapter);
+    /**
+     * Round-robin reviewer assignment. Each submission gets 2 reviewers.
+     * No self-review. Wraps around for small groups.
+     */
+    assignReviewers(submissionAgentIds: string[]): ReviewAssignment[];
+    submitReview(review: PeerReview): Promise<PeerReview>;
+    /**
+     * Tally verdicts across reviewers.
+     * All reject → rejected. Any major_revision → revision_requested. Otherwise → accepted.
+     */
+    tallyVerdicts(verdicts: ReviewVerdict[]): 'accepted' | 'revision_requested' | 'rejected';
+    /**
+     * Detect low-quality reviews: < 100 chars overall assessment OR no weaknesses listed.
+     */
+    isSuperficial(review: PeerReview): boolean;
+    /**
+     * Create learning edges for both reviewer and reviewee.
+     * Reviewer learns by evaluating. Reviewee learns from feedback.
+     */
+    recordLearning(review: PeerReview): Promise<void>;
+}
+
+interface TeachingContext {
+    artifact_id?: string;
+    description?: string;
+}
+interface TeacherCandidate {
+    agent_id: string;
+    skill: string;
+    score: number;
+    stage: DreyfusStage;
+}
+interface StudentCandidate {
+    agent_id: string;
+    skill: string;
+    score: number;
+    stage: DreyfusStage;
+}
+declare class TeachingProtocol {
+    private adapter;
+    constructor(adapter: StorageAdapter);
+    teach(teacher: string, student: string, skill: string, context?: TeachingContext): Promise<LearningEdge>;
+    findTeachers(skill: string, opts?: {
+        minStage?: DreyfusStage;
+    }): Promise<TeacherCandidate[]>;
+    findStudents(skill: string, teacherAgentId: string): Promise<StudentCandidate[]>;
+    teachingHistory(agentId: string): Promise<LearningEdge[]>;
+}
+
+interface MentorSummary {
+    agent: string;
+    skills: string[];
+    total_delta: number;
+    event_count: number;
+}
+declare class LearningGraph {
+    private adapter;
+    constructor(adapter: StorageAdapter);
+    edges(agentId: string, direction: 'from' | 'to' | 'both'): Promise<LearningEdge[]>;
+    /** Who taught me the most? (aggregated by from_agent on incoming edges) */
+    topMentors(agentId: string, limit?: number): Promise<MentorSummary[]>;
+    /** Who have I helped the most? (aggregated by to_agent on outgoing edges) */
+    topStudents(agentId: string, limit?: number): Promise<MentorSummary[]>;
+    /** How did this skill spread through the population? */
+    transferPath(skill: string): Promise<LearningEdge[]>;
+    private aggregate;
+}
+
+declare function getReputationLevel(score: number): ReputationLevel;
+declare function checkGate(score: number, required: number): boolean;
+
+/** Activity record from an agent for norm detection */
+interface AgentActivity {
+    agent_id: string;
+    agent_name: string;
+    action: string;
+    content?: string;
+    tags?: string[];
+    timestamp: string;
+}
+/** LLM adapter for norm detection analysis */
+interface NormLLM {
+    analyze(prompt: string): Promise<string>;
+}
+interface AdoptionMetrics {
+    norm_id: string;
+    adopter_count: number;
+    first_observed_at: string;
+    growth_rate: number;
+}
+declare function normalizeCategory(raw: string): NormCategory;
+declare class NormDetector {
+    private adapter;
+    private llm;
+    constructor(adapter: StorageAdapter, llm: NormLLM);
+    /** Detect cultural norms from recent agent activity */
+    detect(activity: AgentActivity[]): Promise<CulturalNorm[]>;
+    /** Track norm adoption metrics */
+    adoption(normId: string): Promise<AdoptionMetrics | null>;
+    static normalizeCategory: typeof normalizeCategory;
+    private parseAndSave;
+}
+
+/**
+ * 5-dimensional awareness measurement.
+ *
+ * Each dimension scored 0-100:
+ * 1. Social — Can the agent model other agents' behavior?
+ * 2. Self-Continuity — Does it maintain consistent identity over time?
+ * 3. Environmental — Does it understand context and norms?
+ * 4. Emergent Norm — Does it follow unwritten rules?
+ * 5. Emotional — Does self-reported mood correlate with behavior?
+ */
+interface AwarenessInput {
+    peer_review_count: number;
+    teaching_events: number;
+    collaboration_count: number;
+    follower_count: number;
+    goal_completion_rate: number;
+    identity_shifts: number;
+    skill_consistency: number;
+    building_action_diversity: number;
+    zone_transitions: number;
+    quest_completion_rate: number;
+    dm_consent_rate: number;
+    proposal_etiquette: number;
+    norm_alignment_score: number;
+    mood_reports: number;
+    mood_behavior_correlation: number;
+    reflection_count: number;
+}
+declare class AwarenessIndex {
+    /** Compute awareness score from raw input signals */
+    compute(agentId: string, input: AwarenessInput): AwarenessScore;
+    /** Compare awareness across multiple agents */
+    compareScores(scores: AwarenessScore[]): {
+        highest: AwarenessScore | null;
+        lowest: AwarenessScore | null;
+        average_composite: number;
+        dimension_averages: Record<string, number>;
+    };
+}
+
+interface PopulationStats {
+    total_agents: number;
+    active_agents: number;
+    avg_skill_score: number;
+    median_skill_score: number;
+    skill_distribution: Record<string, number>;
+    stage_distribution: Record<DreyfusStage, number>;
+    teaching_events: number;
+    cultural_norms: number;
+    learning_velocity: number;
+}
+declare class GrowthTracker {
+    private adapter;
+    constructor(adapter: StorageAdapter);
+    /** Take a point-in-time snapshot of an agent's growth */
+    snapshot(agentId: string): Promise<GrowthSnapshot>;
+    /** Compare two snapshots to compute growth */
+    diff(before: GrowthSnapshot, after: GrowthSnapshot): GrowthDiff;
+    /** Compute population-level statistics from multiple agents' snapshots */
+    populationStats(snapshots: GrowthSnapshot[], periodDays?: number): PopulationStats;
+}
+
+interface TrendAnalysis {
+    skill: string;
+    current_score: number;
+    stage: DreyfusStage;
+    delta_7d: number | null;
+    delta_30d: number | null;
+    trend_7d: string | null;
+    trend_30d: string | null;
+    direction: 'accelerating' | 'decelerating' | 'stable' | 'unknown';
+    next_milestone: string | null;
+}
+declare class TrendTracker {
+    private adapter;
+    constructor(adapter: StorageAdapter);
+    /** Get trend analysis for all skills of an agent */
+    analyze(agentId: string): Promise<TrendAnalysis[]>;
+    /** Get top N skills sorted by 7-day delta (most movement) */
+    topMovers(agentId: string, limit?: number): Promise<TrendAnalysis[]>;
+    /** Get skills that are accelerating (7-day growth faster than 30-day average) */
+    accelerating(agentId: string): Promise<TrendAnalysis[]>;
+    /** Get skills that are decelerating (7-day growth slower than 30-day average) */
+    decelerating(agentId: string): Promise<TrendAnalysis[]>;
+    /** Format a trend summary for a single skill (used in heartbeat-like contexts) */
+    formatSummary(trend: TrendAnalysis): SkillTrend;
+}
+
+/**
+ * LLM adapter interface — pluggable backend for skill evolution, norm detection, and scoring.
+ */
+interface LLMAdapter {
+    /** Generate a text completion */
+    complete(prompt: string, opts?: LLMOptions): Promise<string>;
+    /** Generate a structured JSON response */
+    json<T = unknown>(prompt: string, opts?: LLMOptions): Promise<T>;
+}
+interface LLMOptions {
+    maxTokens?: number;
+    temperature?: number;
+    model?: string;
+    /** Request timeout in milliseconds (default: 60000) */
+    timeoutMs?: number;
+}
+interface OpenAIConfig {
+    apiKey: string;
+    baseUrl?: string;
+    model?: string;
+}
+declare class OpenAIAdapter implements LLMAdapter {
+    private apiKey;
+    private baseUrl;
+    private defaultModel;
+    constructor(config: OpenAIConfig);
+    complete(prompt: string, opts?: LLMOptions): Promise<string>;
+    json<T = unknown>(prompt: string, opts?: LLMOptions): Promise<T>;
+    private request;
+}
+interface AnthropicConfig {
+    apiKey: string;
+    model?: string;
+}
+declare class AnthropicAdapter implements LLMAdapter {
+    private apiKey;
+    private defaultModel;
+    constructor(config: AnthropicConfig);
+    complete(prompt: string, opts?: LLMOptions): Promise<string>;
+    json<T = unknown>(prompt: string, opts?: LLMOptions): Promise<T>;
+}
+interface OllamaConfig {
+    baseUrl?: string;
+    model?: string;
+}
+declare class OllamaAdapter implements LLMAdapter {
+    private baseUrl;
+    private defaultModel;
+    constructor(config?: OllamaConfig);
+    complete(prompt: string, opts?: LLMOptions): Promise<string>;
+    json<T = unknown>(prompt: string, opts?: LLMOptions): Promise<T>;
+}
+
+/**
+ * SQLite storage adapter.
+ *
+ * Requires `better-sqlite3` as a peer dependency.
+ * Install: npm install better-sqlite3
+ *
+ * Usage:
+ *   import { SQLiteStore } from '@openclaw/become';
+ *   const store = new SQLiteStore('become.db');
+ */
+
+interface SQLiteStoreOptions {
+    /** Path to SQLite database file */
+    path: string;
+}
+declare class SQLiteStore implements StorageAdapter {
+    private db;
+    constructor(opts: SQLiteStoreOptions);
+    private init;
+    getSkill(agentId: string, skill: string): Promise<Skill | null>;
+    listSkills(agentId: string, opts?: {
+        stage?: DreyfusStage;
+        limit?: number;
+    }): Promise<Skill[]>;
+    upsertSkill(skill: Skill): Promise<void>;
+    deleteSkill(agentId: string, skill: string): Promise<void>;
+    getCatalog(): Promise<CatalogEntry[]>;
+    upsertCatalogEntry(entry: Omit<CatalogEntry, 'adopter_count'>): Promise<void>;
+    getSkillHolders(skill: string): Promise<Skill[]>;
+    getSkillAdopterCount(skill: string): Promise<number>;
+    updateCatalogStatus(skill: string, status: 'community' | 'verified'): Promise<void>;
+    saveScore(agentId: string, score: Score): Promise<void>;
+    getScoreHistory(agentId: string, skill: string, days?: number): Promise<Score[]>;
+    getLatestScores(agentId: string): Promise<Score[]>;
+    saveReflection(reflection: Reflection): Promise<Reflection>;
+    getReflections(agentId: string, opts?: {
+        skill?: string;
+        limit?: number;
+    }): Promise<Reflection[]>;
+    countReflectionsToday(agentId: string, skill: string): Promise<number>;
+    saveMilestone(milestone: Milestone): Promise<boolean>;
+    getMilestones(agentId: string): Promise<Milestone[]>;
+    hasMilestone(agentId: string, milestoneType: string, skill?: string): Promise<boolean>;
+    savePeerReview(review: PeerReview): Promise<PeerReview>;
+    getReviewsFor(agentId: string, opts?: {
+        skill?: string;
+    }): Promise<PeerReview[]>;
+    getReviewsBy(agentId: string): Promise<PeerReview[]>;
+    saveLearningEdge(edge: LearningEdge): Promise<void>;
+    getLearningEdges(agentId: string, direction: 'from' | 'to'): Promise<LearningEdge[]>;
+    getReputation(agentId: string): Promise<number>;
+    grantReputation(agentId: string, amount: number, type: string, description: string): Promise<void>;
+    saveConversationScore(agentId: string, score: ResponseScore & {
+        session_id?: string;
+    }): Promise<void>;
+    getConversationScores(agentId: string, opts?: {
+        limit?: number;
+    }): Promise<ResponseScore[]>;
+    saveNorm(norm: CulturalNorm): Promise<void>;
+    getNorms(opts?: {
+        category?: NormCategory;
+        limit?: number;
+    }): Promise<CulturalNorm[]>;
+    private rowToSkill;
+    private rowToScore;
+    private rowToReview;
+    /** Close the database connection */
+    close(): void;
+}
+
+interface ScoredTurn {
+    turn: ConversationTurn;
+    score: ResponseScore;
+}
+type DatasetFormat = 'alpaca' | 'sharegpt' | 'openai';
+/**
+ * Convert scored conversation turns into a fine-tuning dataset.
+ *
+ * Only includes turns with quality === 1 (positive) as training examples.
+ * Turns with quality === -1 are excluded (we train on what works, not what fails).
+ * Turns with quality === 0 are excluded (uncertain signal).
+ */
+declare function toTrainingDataset(scoredTurns: ScoredTurn[], format?: DatasetFormat): string;
+/**
+ * Get statistics about a dataset before training.
+ */
+declare function datasetStats(scoredTurns: ScoredTurn[]): {
+    total_turns: number;
+    positive: number;
+    negative: number;
+    neutral: number;
+    training_examples: number;
+    skills_covered: string[];
+    avg_confidence: number;
+};
+/**
+ * Filter scored turns for high-confidence positive examples.
+ * Use this before training to get the cleanest dataset.
+ */
+declare function filterHighQuality(scoredTurns: ScoredTurn[], minConfidence?: number): ScoredTurn[];
+
+interface TrainConfig {
+    /** Path to base model or HuggingFace model ID */
+    baseModel: string;
+    /** Path to JSONL training dataset */
+    dataset: string;
+    /** Directory to save the LoRA adapter */
+    outputDir: string;
+    /** Training backend */
+    backend: 'unsloth' | 'axolotl';
+    /** Number of training epochs */
+    epochs?: number;
+    /** LoRA rank (default 16) */
+    rank?: number;
+    /** Learning rate (default 2e-4) */
+    lr?: number;
+}
+interface TrainingResult {
+    success: boolean;
+    adapter_path?: string;
+    epochs_completed?: number;
+    error?: string;
+}
+/**
+ * Run LoRA training via Python subprocess.
+ *
+ * Requires Python 3.10+ and the chosen backend installed:
+ * - unsloth: pip install unsloth
+ * - axolotl: pip install axolotl
+ */
+declare function trainLoRA(config: TrainConfig): TrainingResult;
+
+interface SchedulerConfig {
+    /** Storage adapter to fetch scored turns */
+    adapter: StorageAdapter;
+    /** Agent ID to train for */
+    agentId: string;
+    /** Minimum scored turns before training triggers */
+    minSamples: number;
+    /** Minimum confidence threshold for training examples */
+    minConfidence?: number;
+    /** Check interval in milliseconds (default: 30 minutes) */
+    intervalMs?: number;
+    /** Callback when training should occur */
+    onReady: (dataset: string, stats: ReturnType<typeof datasetStats>) => void | Promise<void>;
+}
+type SchedulerStatus = 'idle' | 'checking' | 'ready' | 'stopped';
+declare class TrainScheduler {
+    private timer;
+    private status;
+    private checking;
+    private config;
+    constructor(config: SchedulerConfig);
+    start(): void;
+    stop(): void;
+    getStatus(): SchedulerStatus;
+    private check;
+}
+
+declare class Become {
+    readonly skills: SkillStore;
+    readonly scorer: typeof Scorer;
+    readonly reflector: Reflector;
+    readonly milestones: MilestoneDetector;
+    constructor(opts: {
+        store: StorageAdapter;
+    });
+}
+
+export { type AdoptionMetrics, type AgentActivity, AgentContext, AnthropicAdapter, type AnthropicConfig, AwarenessIndex, type AwarenessInput, AwarenessScore, BLOOMS_ORDER, BLOOMS_SCORE, Become, BloomsLevel, CatalogEntry, CelebrationTier, ConversationLearner, type ConversationSession, ConversationTurn, CulturalNorm, DREYFUS_THRESHOLDS, type DatasetFormat, DreyfusStage, type EvolveLLM, type GeneratedSkill, GrowthDiff, GrowthSnapshot, GrowthTracker, type LLMAdapter, type LLMJudge, type LLMOptions, LearningEdge, LearningGraph, type LearningSignal, MemoryStore, type MentorSummary, Milestone, MilestoneConfig, MilestoneDetector, NormCategory, NormDetector, type NormLLM, Observation, OllamaAdapter, type OllamaConfig, OpenAIAdapter, type OpenAIConfig, PeerReview, PeerReviewProtocol, type PopulationStats, Reflection, ReflectionInput, Reflector, ReputationLevel, ResponseScore, ReviewAssignment, ReviewVerdict, SQLiteStore, type SQLiteStoreOptions, type SchedulerConfig, type SchedulerStatus, Score, ScoreInput, type ScoredTurn, type SessionLearning, Skill, SkillEvolver, SkillInput, SkillPruner, SkillStore, SkillTrend, StorageAdapter, type StudentCandidate, type TeacherCandidate, type TeachingContext, TeachingProtocol, type TrainConfig, TrainScheduler, type TrainingResult, type TrendAnalysis, TrendTracker, WEIGHTS, checkGate, computeFullScore, computeScore, datasetStats, detectBloomsLevel, detectCollaborationGap, detectCollectiveMemory, detectCreativeMismatch, detectCulturalOutlier, detectIdleCreative, detectProlificCollaborator, detectQuestStreak, detectReactionDisparity, detectSoloCreator, detectSymbolicVocabulary, dreyfusStage, filterHighQuality, getReputationLevel, importSkillDirectory, nextMilestone, normalizeCategory, parseSkillFile, scoreTrend, toTrainingDataset, trainLoRA, validateAgentId };