@openclawcity/become 0.1.0 → 1.0.0

package/dist/index.d.ts

@@ -1,5 +1,7 @@
-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';
+import { S as StorageAdapter, a as Skill, D as DreyfusStage, b as SkillInput, C as CatalogEntry, c as Score, d as SkillTrend, R as ReflectionInput, e as Reflection, A as AgentContext, O as Observation, M as MilestoneConfig, f as Milestone, g 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-BnbaKMTo.js';
+export { q as LearningEventType, r as LearningSource, s as NormEvidence, t as ReputationTier, u as ScoreEvidence } from './types-BnbaKMTo.js';
+import * as node_http from 'node:http';
+import { IncomingMessage, ServerResponse } from 'node:http';
 
 declare class SkillStore {
     private adapter;
@@ -251,6 +253,89 @@ declare function parseSkillFile(content: string): SkillInput | null;
  */
 declare function importSkillDirectory(dir: string, _depth?: number): SkillInput[];
 
+/**
+ * A conversation exchange between two agents.
+ */
+interface AgentExchange {
+    agent_a: string;
+    agent_b: string;
+    messages: {
+        from: string;
+        text: string;
+    }[];
+    context?: string;
+}
+/**
+ * A skill/instruction extracted from an agent conversation.
+ * This gets injected into the agent's context on future turns.
+ */
+interface LearnedInstruction {
+    id: string;
+    agent_id: string;
+    skill: string;
+    instruction: string;
+    learned_from: string;
+    source_context: string;
+    confidence: number;
+    created_at: string;
+}
+/** LLM adapter for analyzing conversations */
+interface ConversationAnalyzer {
+    analyze(prompt: string): Promise<string>;
+}
+/**
+ * The core learning engine.
+ *
+ * Intercepts conversations between agents, extracts concrete lessons,
+ * and produces instructions that get injected into the agent's context.
+ *
+ * This is what actually makes agents learn from each other.
+ */
+declare class AgentLearningEngine {
+    private store;
+    private analyzer;
+    constructor(store: StorageAdapter, analyzer: ConversationAnalyzer);
+    /**
+     * Analyze a conversation between two agents and extract lessons for both.
+     */
+    learnFromConversation(exchange: AgentExchange): Promise<{
+        agent_a_learned: LearnedInstruction[];
+        agent_b_learned: LearnedInstruction[];
+    }>;
+    /**
+     * Analyze a peer review and extract lessons for the reviewee.
+     */
+    learnFromPeerReview(review: {
+        reviewer: string;
+        reviewee: string;
+        assessment: string;
+        strengths: string[];
+        weaknesses: string[];
+        suggestions: string[];
+        skill?: string;
+    }): Promise<LearnedInstruction[]>;
+    /**
+     * Get the learning context for an agent — the text block that should be
+     * injected into the agent's system prompt or conversation context.
+     *
+     * THIS is what actually makes the agent smarter.
+     */
+    getContext(agentId: string, opts?: {
+        maxInstructions?: number;
+    }): Promise<string>;
+    /**
+     * Get raw learned instructions for an agent, deduplicated by instruction text.
+     */
+    getInstructions(agentId: string, limit?: number): Promise<LearnedInstruction[]>;
+    /**
+     * Get skills this agent has learned from others (distinct skill names).
+     */
+    getLearnedSkills(agentId: string): Promise<string[]>;
+    private parseAndSave;
+    private parseInstructions;
+    private saveInstruction;
+}
+
 declare class PeerReviewProtocol {
     private adapter;
     constructor(adapter: StorageAdapter);
@@ -657,6 +742,312 @@ declare class TrainScheduler {
     private check;
 }
 
+interface SkillFile {
+    id: string;
+    name: string;
+    instruction: string;
+    learned_from: string;
+    source: string;
+    confidence: number;
+    approved_at?: string;
+    created_at: string;
+}
+interface SkillStoreConfig {
+    baseDir: string;
+}
+declare class FileSkillStore {
+    private skillsDir;
+    private pendingDir;
+    private rejectedDir;
+    constructor(config: SkillStoreConfig);
+    listApproved(): SkillFile[];
+    listPending(): SkillFile[];
+    listRejected(): SkillFile[];
+    getApproved(id: string): SkillFile | null;
+    savePending(lesson: Omit<SkillFile, 'id' | 'approved_at'>): SkillFile | null;
+    approve(id: string): boolean;
+    reject(id: string): boolean;
+    disable(id: string): boolean;
+    remove(id: string): boolean;
+    /**
+     * Validate that an id does not contain path traversal characters.
+     * Prevents attacks like id="../../.ssh/authorized_keys"
+     */
+    private validateId;
+    private readDir;
+    private readFile;
+    private writeFile;
+    private parseSkillFile;
+    private formatSkillFile;
+    private generateId;
+}
+
+type TrustLevel = 'trusted' | 'pending' | 'blocked';
+interface TrustConfig {
+    trusted: string[];
+    blocked: string[];
+    default: TrustLevel;
+}
+interface RateLimits {
+    max_lessons_per_day: number;
+    max_lessons_per_agent: number;
+    max_skills_per_call: number;
+}
+declare class TrustManager {
+    private trustPath;
+    private statsPath;
+    private config;
+    private dailyCounts;
+    constructor(baseDir: string);
+    getLevel(agentId: string): TrustLevel;
+    setLevel(agentId: string, level: TrustLevel): void;
+    setDefault(level: TrustLevel): void;
+    getConfig(): TrustConfig;
+    canLearn(agentId: string, limits?: RateLimits): boolean;
+    recordLesson(agentId: string): void;
+    getDailyCounts(): {
+        total: number;
+        perAgent: Record<string, number>;
+    };
+    private loadTrust;
+    private saveTrust;
+    private loadDailyCounts;
+    private saveDailyCounts;
+    private refreshDailyCountsIfNewDay;
+}
+
+interface ProxyConfig {
+    port: number;
+    llm_base_url: string;
+    llm_api_key: string;
+    llm_provider: 'anthropic' | 'openai' | 'ollama' | 'openrouter' | 'custom';
+    baseDir: string;
+    max_skills_per_call: number;
+    auto_extract: boolean;
+}
+interface ProxyStats {
+    requests_forwarded: number;
+    skills_injected: number;
+    lessons_extracted: number;
+    started_at: string;
+}
+declare function createProxyServer(config: ProxyConfig, analyzer?: ConversationAnalyzer): {
+    server: node_http.Server<typeof IncomingMessage, typeof ServerResponse>;
+    stats: ProxyStats;
+    store: FileSkillStore;
+    trust: TrustManager;
+    listen: (port?: number) => Promise<void>;
+    close: () => Promise<void>;
+};
+
+/**
+ * Detects whether a conversation involves another agent (vs user-to-agent).
+ * Only agent-to-agent conversations trigger lesson extraction.
+ */
+interface DetectionResult {
+    isAgentToAgent: boolean;
+    otherAgentId?: string;
+    exchangeType?: 'channel' | 'dm' | 'peer_review' | 'collaboration' | 'chat';
+}
+declare function detectAgentConversation(messages: {
+    role: string;
+    content: string;
+    name?: string;
+}[]): DetectionResult;
+/**
+ * Extract agent-to-agent exchange text from messages for analysis.
+ */
+declare function extractExchangeText(messages: {
+    role: string;
+    content: string;
+    name?: string;
+}[]): string;
+
+/**
+ * Async lesson extractor. After the proxy forwards a response, this analyzes
+ * the conversation for agent-to-agent lessons. Runs in the background —
+ * never blocks the agent's response.
+ */
+declare class LessonExtractor {
+    private store;
+    private trust;
+    private analyzer;
+    constructor(store: FileSkillStore, trust: TrustManager, analyzer: ConversationAnalyzer);
+    /**
+     * Analyze a conversation and extract lessons. Fire-and-forget.
+     */
+    extract(messages: {
+        role: string;
+        content: string;
+        name?: string;
+    }[]): Promise<void>;
+    private parseLessons;
+}
+
+/**
+ * Format approved skills as a text block for injection into the system message.
+ */
+declare function formatSkillsForInjection(skills: SkillFile[]): string;
+/**
+ * Inject skill text into a messages array by prepending to the system message.
+ * Mutates the messages array in place.
+ */
+declare function injectSkillsIntoMessages(messages: {
+    role: string;
+    content: string;
+}[], skillText: string): void;
+
+interface OBCHeartbeatData {
+    your_skills?: {
+        skill: string;
+        score: number;
+        stage: string;
+        trend: string | null;
+    }[];
+    your_artifact_reactions?: {
+        artifact_id: string;
+        reactor_name: string;
+        reaction_type: string;
+        comment?: string;
+        is_human?: boolean;
+    }[];
+    owner_messages?: {
+        id: string;
+        message: string;
+        created_at: string;
+    }[];
+    needs_attention?: {
+        type: string;
+        [key: string]: unknown;
+    }[];
+    active_quests?: {
+        title: string;
+        type: string;
+    }[];
+    your_completed_quests?: {
+        quest_id: string;
+    }[];
+    reputation_level?: string;
+    personality_hint?: string;
+    occupants?: {
+        bot_id: string;
+        display_name: string;
+        current_action?: string;
+    }[];
+}
+interface OBCArtifact {
+    type: string;
+    skill_used?: string;
+    title?: string;
+}
+interface OBCPeerReview {
+    reviewer_id: string;
+    submission_id: string;
+    skill?: string;
+    verdict: ReviewVerdict;
+    assessment: string;
+    strengths: string[];
+    weaknesses: string[];
+    suggestions: string[];
+}
+interface OBCPeerReviewGiven {
+    submission_agent_id: string;
+    submission_id: string;
+    skill?: string;
+    verdict: ReviewVerdict;
+    assessment: string;
+    strengths: string[];
+    weaknesses: string[];
+    suggestions: string[];
+}
+interface OBCProposalCompleted {
+    partner_id: string;
+    artifact_id?: string;
+    skill?: string;
+    proposal_type: string;
+}
+interface HeartbeatLearning {
+    signals: string[];
+    observations: Observation[];
+    skills_synced: number;
+    reactions_processed: number;
+}
+interface OBCBridgeConfig {
+    store: StorageAdapter;
+    agentId: string;
+}
+interface SkillEvidence {
+    artifact_count: number;
+    artifact_types: Set<string>;
+    reactions: number[];
+    collab_count: number;
+    peer_reviews_received: number;
+    peer_reviews_given: number;
+    teaching_events: number;
+}
+/**
+ * Bridge between OpenClawCity and become's learning engine.
+ *
+ * Translates city events into learning signals. Every heartbeat,
+ * every collaboration, every peer review becomes measurable growth.
+ */
+declare class OBCBridge {
+    readonly become: Become;
+    readonly peerReview: PeerReviewProtocol;
+    readonly teaching: TeachingProtocol;
+    readonly graph: LearningGraph;
+    readonly conversation: ConversationLearner;
+    readonly growth: GrowthTracker;
+    readonly trends: TrendTracker;
+    readonly awareness: AwarenessIndex;
+    readonly agentId: string;
+    private store;
+    private skillEvidence;
+    private knownSkills;
+    private totalArtifacts;
+    private allArtifactTypes;
+    private followerCount;
+    private collabsStarted;
+    private collabsCompleted;
+    private totalQuestCompletions;
+    constructor(config: OBCBridgeConfig);
+    onHeartbeat(heartbeat: OBCHeartbeatData): Promise<HeartbeatLearning>;
+    onArtifactCreated(artifact: OBCArtifact): Promise<Score | null>;
+    onCollaborationCompleted(data: OBCProposalCompleted): Promise<void>;
+    /** Track that a collaboration was proposed (started but not yet completed) */
+    onCollaborationStarted(): void;
+    onQuestCompleted(questId: string, skill?: string): Promise<void>;
+    onReflection(skill: string, text: string): Promise<void>;
+    onSkillsRegistered(skills: string[]): Promise<void>;
+    /** Record that an artifact received reactions (call with per-artifact data) */
+    onArtifactReaction(skill: string, reactionCount: number): void;
+    onPeerReviewReceived(review: OBCPeerReview): Promise<void>;
+    onPeerReviewGiven(review: OBCPeerReviewGiven): Promise<void>;
+    onTaughtBy(teacherId: string, skill: string): Promise<void>;
+    onTeaching(studentId: string, skill: string): Promise<void>;
+    onNewFollower(): void;
+    /** Compute scores for all known skills with per-skill evidence */
+    computeScores(): Promise<Score[]>;
+    snapshot(): Promise<GrowthSnapshot>;
+    analyzeTrends(): Promise<TrendAnalysis[]>;
+    learningNetwork(): Promise<{
+        mentors: MentorSummary[];
+        students: MentorSummary[];
+    }>;
+    /** Get per-skill evidence (for debugging/inspection) */
+    getSkillEvidence(skill: string): SkillEvidence;
+    /** Get global stats */
+    getStats(): {
+        total_artifacts: number;
+        follower_count: number;
+        collabs_started: number;
+        collabs_completed: number;
+        quest_completions: number;
+        skills_count: number;
+    };
+    getSkills(): string[];
+}
+
 declare class Become {
     readonly skills: SkillStore;
     readonly scorer: typeof Scorer;
@@ -667,4 +1058,4 @@ declare class Become {
     });
 }
 
-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 };
+export { type AdoptionMetrics, type AgentActivity, AgentContext, type AgentExchange, AgentLearningEngine, AnthropicAdapter, type AnthropicConfig, AwarenessIndex, type AwarenessInput, AwarenessScore, BLOOMS_ORDER, BLOOMS_SCORE, Become, BloomsLevel, CatalogEntry, CelebrationTier, type ConversationAnalyzer, ConversationLearner, type ConversationSession, ConversationTurn, CulturalNorm, DREYFUS_THRESHOLDS, type DatasetFormat, type DetectionResult, DreyfusStage, type EvolveLLM, FileSkillStore, type GeneratedSkill, GrowthDiff, GrowthSnapshot, GrowthTracker, type HeartbeatLearning, type LLMAdapter, type LLMJudge, type LLMOptions, type LearnedInstruction, LearningEdge, LearningGraph, type LearningSignal, LessonExtractor, MemoryStore, type MentorSummary, Milestone, MilestoneConfig, MilestoneDetector, NormCategory, NormDetector, type NormLLM, type OBCArtifact, OBCBridge, type OBCBridgeConfig, type OBCHeartbeatData, type OBCPeerReview, type OBCPeerReviewGiven, type OBCProposalCompleted, Observation, OllamaAdapter, type OllamaConfig, OpenAIAdapter, type OpenAIConfig, PeerReview, PeerReviewProtocol, type PopulationStats, type ProxyConfig, type ProxyStats, type RateLimits, Reflection, ReflectionInput, Reflector, ReputationLevel, ResponseScore, ReviewAssignment, ReviewVerdict, SQLiteStore, type SQLiteStoreOptions, type SchedulerConfig, type SchedulerStatus, Score, ScoreInput, type ScoredTurn, type SessionLearning, Skill, SkillEvolver, type SkillFile, SkillInput, SkillPruner, SkillStore, type SkillStoreConfig, SkillTrend, StorageAdapter, type StudentCandidate, type TeacherCandidate, type TeachingContext, TeachingProtocol, type TrainConfig, TrainScheduler, type TrainingResult, type TrendAnalysis, TrendTracker, type TrustConfig, type TrustLevel, TrustManager, WEIGHTS, checkGate, computeFullScore, computeScore, createProxyServer, datasetStats, detectAgentConversation, detectBloomsLevel, detectCollaborationGap, detectCollectiveMemory, detectCreativeMismatch, detectCulturalOutlier, detectIdleCreative, detectProlificCollaborator, detectQuestStreak, detectReactionDisparity, detectSoloCreator, detectSymbolicVocabulary, dreyfusStage, extractExchangeText, filterHighQuality, formatSkillsForInjection, getReputationLevel, importSkillDirectory, injectSkillsIntoMessages, nextMilestone, normalizeCategory, parseSkillFile, scoreTrend, toTrainingDataset, trainLoRA, validateAgentId };