@loom-node/amoeba 0.1.0

package/dist/reward-bus.js

@@ -0,0 +1,68 @@
+const DEFAULT_CONFIG = {
+    strategy: 'rule',
+    llmJudgeInterval: 10,
+    weights: { quality: 0.5, efficiency: 0.3, reliability: 0.2 },
+    ema: { alpha: 0.3, decayRate: 0.95 },
+};
+export class RewardBus {
+    config;
+    evalCount = 0;
+    bias = 0;
+    llmJudge;
+    constructor(config) {
+        this.config = { ...DEFAULT_CONFIG, ...config };
+    }
+    setLLMJudge(judge) {
+        this.llmJudge = judge;
+    }
+    async evaluate(node, task, result) {
+        const signal = await this.computeSignal(task, result);
+        const reward = this.computeReward(signal);
+        this.updateCapability(node, task.domain, reward);
+        node.rewardHistory.push({
+            taskId: task.taskId, reward, domain: task.domain,
+            tokenCost: result.tokenCost, timestamp: Date.now(),
+        });
+        return reward;
+    }
+    decayInactive(node) {
+        const now = Date.now();
+        for (const [domain, score] of node.capabilities.scores) {
+            const last = [...node.rewardHistory].reverse().find(r => r.domain === domain);
+            const days = (now - (last?.timestamp ?? 0)) / 86_400_000;
+            if (days > 1) {
+                node.capabilities.scores.set(domain, score * (this.config.ema.decayRate ** days));
+            }
+        }
+    }
+    async computeSignal(task, result) {
+        const rule = this.ruleSignal(task, result);
+        if (this.config.strategy === 'hybrid' && this.llmJudge && ++this.evalCount % this.config.llmJudgeInterval === 0) {
+            const llm = await this.llmJudge(task, result);
+            this.bias = llm.quality - rule.quality;
+            return llm;
+        }
+        rule.quality = clamp(rule.quality + this.bias);
+        return rule;
+    }
+    ruleSignal(task, result) {
+        const budget = task.tokenBudget ?? 4096;
+        return {
+            quality: result.success ? 0.7 : 0.0,
+            efficiency: 1 - Math.min(result.tokenCost / budget, 1),
+            reliability: result.errorCount === 0 ? 1.0 : 0.0,
+        };
+    }
+    computeReward(s) {
+        const w = this.config.weights;
+        return s.quality * w.quality + s.efficiency * w.efficiency + s.reliability * w.reliability;
+    }
+    updateCapability(node, domain, reward) {
+        const α = this.config.ema.alpha;
+        const current = node.capabilities.scores.get(domain) ?? 0.5;
+        node.capabilities.scores.set(domain, α * reward + (1 - α) * current);
+        node.capabilities.totalTasks++;
+        node.capabilities.successRate = α * (reward > 0.5 ? 1 : 0) + (1 - α) * node.capabilities.successRate;
+    }
+}
+function clamp(v) { return Math.max(0, Math.min(1, v)); }

package/dist/runtime.d.ts

@@ -0,0 +1,64 @@
+import type { AgentNode, LLMProvider, Skill, MitosisContext, ContextProvider, ContextOrchestrator, MemoryManager } from '@loom-node/core';
+import { Agent } from '@loom-node/core';
+import { ClusterManager } from './cluster.js';
+import type { AuctionConfig } from './cluster.js';
+import { RewardBus } from './reward-bus.js';
+import type { RewardConfig } from './reward-bus.js';
+import { TaskPlanner } from './planner.js';
+import type { PlannerConfig } from './planner.js';
+import { LifecycleManager } from './lifecycle.js';
+import type { LifecycleConfig } from './lifecycle.js';
+import { ClusterProvider } from './cluster-provider.js';
+import { PlanStrategy } from './plan-strategy.js';
+import { OrchestrateStrategy } from './orchestrate-strategy.js';
+import { AmoebaLoop } from './amoeba-loop.js';
+import type { AmoebaLoopConfig } from './amoeba-loop.js';
+import { SkillNodeRegistry } from './skill-registry.js';
+export type AgentFactory = (domain: string, context?: MitosisContext) => Agent;
+export interface AmoebaRuntimeConfig {
+    llm: LLMProvider;
+    agentFactory?: AgentFactory;
+    skills?: Skill[];
+    auction?: Partial<AuctionConfig>;
+    reward?: Partial<RewardConfig>;
+    planner?: Partial<Omit<PlannerConfig, 'llm'>>;
+    lifecycle?: Partial<LifecycleConfig>;
+    healthCheckIntervalMs?: number;
+    memory?: MemoryManager;
+    contextProviders?: ContextProvider[];
+    contextWindow?: number;
+}
+export declare class AmoebaRuntime {
+    readonly cluster: ClusterManager;
+    readonly rewardBus: RewardBus;
+    readonly planner: TaskPlanner;
+    readonly lifecycle: LifecycleManager;
+    readonly agentFactory?: AgentFactory;
+    readonly skillRegistry: SkillNodeRegistry;
+    private readonly llm;
+    private readonly _memory?;
+    private readonly sharedProviders;
+    private readonly contextWindow;
+    private healthTimer?;
+    constructor(config: AmoebaRuntimeConfig);
+    addNode(node: AgentNode): void;
+    createNode(agent: Agent, opts?: {
+        id?: string;
+        domain?: string;
+        tools?: string[];
+    }): AgentNode;
+    getMemory(): MemoryManager | undefined;
+    buildContextFor(agentId: string, opts?: {
+        mitosisCtx?: MitosisContext;
+    }): ContextOrchestrator | undefined;
+    /** Load a skill as an active node in the cluster */
+    loadSkill(skill: Skill): AgentNode;
+    /** Discover and lazy-load a matching skill when auction finds no good candidate */
+    discoverSkill(input: string, minScore?: number): Promise<AgentNode | undefined>;
+    providerFor(agentId: string): ClusterProvider;
+    planStrategy(): PlanStrategy;
+    orchestrateStrategy(): OrchestrateStrategy;
+    amoebaLoop(opts?: Partial<Pick<AmoebaLoopConfig, 'skillEvolver' | 'complexityLlmThreshold' | 'evolutionRewardThreshold' | 'evolutionWindow'>>): AmoebaLoop;
+    healthCheck(): void;
+    dispose(): void;
+}

package/dist/runtime.js

@@ -0,0 +1,139 @@
+import { ContextOrchestratorImpl } from '@loom-node/core';
+import { ClusterManager } from './cluster.js';
+import { RewardBus } from './reward-bus.js';
+import { TaskPlanner } from './planner.js';
+import { LifecycleManager } from './lifecycle.js';
+import { ClusterProvider } from './cluster-provider.js';
+import { PlanStrategy } from './plan-strategy.js';
+import { OrchestrateStrategy } from './orchestrate-strategy.js';
+import { AmoebaLoop } from './amoeba-loop.js';
+import { SkillNodeRegistry } from './skill-registry.js';
+import { skillToNode } from './skill-node.js';
+import { MitosisContextProvider } from './mitosis-provider.js';
+export class AmoebaRuntime {
+    cluster;
+    rewardBus;
+    planner;
+    lifecycle;
+    agentFactory;
+    skillRegistry;
+    llm;
+    _memory;
+    sharedProviders;
+    contextWindow;
+    healthTimer;
+    constructor(config) {
+        this.llm = config.llm;
+        this.cluster = new ClusterManager(config.auction);
+        this.rewardBus = new RewardBus(config.reward);
+        this.planner = new TaskPlanner({ llm: config.llm, ...config.planner });
+        this.lifecycle = new LifecycleManager(config.lifecycle);
+        this.agentFactory = config.agentFactory;
+        this.skillRegistry = new SkillNodeRegistry();
+        this._memory = config.memory;
+        this.sharedProviders = config.contextProviders ?? [];
+        this.contextWindow = config.contextWindow ?? 128_000;
+        if (config.skills)
+            this.skillRegistry.registerAll(config.skills);
+        if (config.healthCheckIntervalMs) {
+            this.healthTimer = setInterval(() => this.healthCheck(), config.healthCheckIntervalMs);
+        }
+    }
+    addNode(node) {
+        this.cluster.addNode(node);
+    }
+    createNode(agent, opts) {
+        const node = {
+            id: opts?.id ?? `node-${Date.now()}-${Math.random().toString(36).slice(2, 6)}`,
+            depth: 0,
+            capabilities: {
+                scores: new Map(opts?.domain ? [[opts.domain, 0.5]] : [['general', 0.5]]),
+                tools: opts?.tools ?? [],
+                totalTasks: 0,
+                successRate: 0,
+            },
+            rewardHistory: [],
+            status: 'idle',
+            load: 0,
+            agent,
+            lastActiveAt: Date.now(),
+            consecutiveLosses: 0,
+        };
+        this.cluster.addNode(node);
+        return node;
+    }
+    getMemory() {
+        return this._memory;
+    }
+    buildContextFor(agentId, opts) {
+        const providers = [
+            new ClusterProvider(this.cluster, agentId),
+            ...this.sharedProviders,
+        ];
+        if (opts?.mitosisCtx) {
+            const mc = opts.mitosisCtx;
+            providers.push(new MitosisContextProvider(mc.parentTaskSpec, mc.subtask, mc.scratchpad));
+        }
+        const orchestrator = new ContextOrchestratorImpl({
+            contextWindow: this.contextWindow,
+            outputReserveRatio: 0.25,
+        });
+        for (const p of providers)
+            orchestrator.register(p);
+        return orchestrator;
+    }
+    /** Load a skill as an active node in the cluster */
+    loadSkill(skill) {
+        const nodeId = `skill:${skill.name}`;
+        const context = this.buildContextFor(nodeId);
+        const node = skillToNode(skill, this.llm, { context, memory: this._memory });
+        this.cluster.addNode(node);
+        this.skillRegistry.markLoaded(skill.name);
+        return node;
+    }
+    /** Discover and lazy-load a matching skill when auction finds no good candidate */
+    async discoverSkill(input, minScore = 0.3) {
+        const match = await this.skillRegistry.findMatch(input, minScore);
+        if (!match)
+            return undefined;
+        return this.loadSkill(match.skill);
+    }
+    providerFor(agentId) {
+        return new ClusterProvider(this.cluster, agentId);
+    }
+    planStrategy() {
+        return new PlanStrategy(this.planner);
+    }
+    orchestrateStrategy() {
+        return new OrchestrateStrategy(this.cluster, this.rewardBus, this.lifecycle, this.planner, this.agentFactory, (input) => this.discoverSkill(input), this);
+    }
+    amoebaLoop(opts) {
+        return new AmoebaLoop({
+            cluster: this.cluster,
+            rewardBus: this.rewardBus,
+            lifecycle: this.lifecycle,
+            planner: this.planner,
+            skillRegistry: this.skillRegistry,
+            llm: this.llm,
+            agentFactory: this.agentFactory,
+            runtime: this,
+            ...opts,
+        });
+    }
+    healthCheck() {
+        for (const node of this.cluster.nodes.values()) {
+            const report = this.lifecycle.checkHealth(node);
+            if (report.recommendation === 'recycle') {
+                try {
+                    this.lifecycle.apoptosis(node, this.cluster);
+                }
+                catch { /* rejected, skip */ }
+            }
+            this.rewardBus.decayInactive(node);
+        }
+    }
+    dispose() {
+        if (this.healthTimer)
+            clearInterval(this.healthTimer);
+    }
+}

package/dist/skill-evolver.d.ts

@@ -0,0 +1,7 @@
+import type { Skill, LLMProvider } from '@loom-node/core';
+import type { AmoebaRuntime } from './runtime.js';
+/**
+ * Creates a meta-skill that can generate/modify other skills via LLM.
+ * User opt-in: load this skill into the runtime to enable skill evolution.
+ */
+export declare function createSkillEvolver(llm: LLMProvider, runtime: AmoebaRuntime): Skill;

package/dist/skill-evolver.js

@@ -0,0 +1,89 @@
+const EVOLVE_PROMPT = `You are a skill architect. Given a task description and optional feedback about an existing skill's performance, generate or modify a skill definition.
+
+Output ONLY valid JSON with this structure:
+{
+  "name": "skill-name",
+  "description": "what this skill does",
+  "instructions": "system prompt for the skill agent",
+  "keywords": ["trigger", "keywords"]
+}`;
+/**
+ * Creates a meta-skill that can generate/modify other skills via LLM.
+ * User opt-in: load this skill into the runtime to enable skill evolution.
+ */
+export function createSkillEvolver(llm, runtime) {
+    const evolveTool = {
+        name: 'evolve_skill',
+        description: 'Create or modify a skill based on task requirements and feedback',
+        parameters: {
+            parse: (input) => input,
+            toJsonSchema: () => ({
+                type: 'object',
+                properties: {
+                    task: { type: 'string', description: 'Task description that needs a skill' },
+                    existingSkill: { type: 'string', description: 'Name of existing skill to modify' },
+                    feedback: { type: 'string', description: 'Performance feedback for modification' },
+                },
+                required: ['task'],
+            }),
+        },
+        execute: async (input) => {
+            const messages = buildEvolveMessages(input, runtime);
+            const result = await llm.complete({ messages, temperature: 0.3, maxTokens: 512 });
+            const def = parseSkillDef(result.content);
+            if (!def)
+                return { success: false, error: 'Failed to parse skill definition' };
+            const skill = {
+                name: def.name,
+                description: def.description,
+                instructions: def.instructions,
+                activationLevel: 'on-demand',
+                trigger: { type: 'keyword', keywords: def.keywords },
+                priority: 0.5,
+            };
+            runtime.skillRegistry.register(skill);
+            const node = runtime.loadSkill(skill);
+            return { success: true, skillName: def.name, nodeId: node.id };
+        },
+    };
+    return {
+        name: 'skill-evolver',
+        description: 'Meta-skill that creates and modifies other skills based on task needs',
+        instructions: 'You can create new skills or modify existing ones. Use the evolve_skill tool when a task needs a specialized skill that does not exist.',
+        activationLevel: 'on-demand',
+        tools: [evolveTool],
+        trigger: { type: 'keyword', keywords: ['create skill', 'new skill', 'modify skill', 'evolve'] },
+        priority: 0.3,
+    };
+}
+function buildEvolveMessages(input, runtime) {
+    let content = EVOLVE_PROMPT + '\n\nTask: ' + input.task;
+    if (input.existingSkill) {
+        const existing = runtime.skillRegistry.get(input.existingSkill);
+        if (existing) {
+            content += `\n\nExisting skill "${existing.name}": ${existing.instructions}`;
+        }
+    }
+    if (input.feedback)
+        content += '\n\nFeedback: ' + input.feedback;
+    return [{ role: 'user', content }];
+}
+function parseSkillDef(text) {
+    try {
+        const match = text.match(/\{[\s\S]*\}/);
+        if (!match)
+            return null;
+        const obj = JSON.parse(match[0]);
+        if (!obj.name || !obj.instructions)
+            return null;
+        return {
+            name: obj.name,
+            description: obj.description ?? obj.name,
+            instructions: obj.instructions,
+            keywords: obj.keywords ?? [obj.name],
+        };
+    }
+    catch {
+        return null;
+    }
+}

package/dist/skill-node.d.ts

@@ -0,0 +1,11 @@
+import type { Skill, AgentNode, LLMProvider, ContextOrchestrator, MemoryManager } from '@loom-node/core';
+/**
+ * Convert a Skill into an AgentNode.
+ * Trigger keywords/patterns seed initial capability scores.
+ */
+export declare function skillToNode(skill: Skill, provider: LLMProvider, opts?: {
+    parentId?: string;
+    depth?: number;
+    context?: ContextOrchestrator;
+    memory?: MemoryManager;
+}): AgentNode;

package/dist/skill-node.js

@@ -0,0 +1,41 @@
+import { Agent } from '@loom-node/core';
+/**
+ * Convert a Skill into an AgentNode.
+ * Trigger keywords/patterns seed initial capability scores.
+ */
+export function skillToNode(skill, provider, opts) {
+    const agent = new Agent({
+        name: `skill:${skill.name}`,
+        provider,
+        systemPrompt: skill.instructions,
+        tools: skill.tools,
+        memory: opts?.memory,
+        context: opts?.context,
+    });
+    const scores = new Map();
+    if (skill.trigger?.type === 'keyword') {
+        for (const kw of skill.trigger.keywords)
+            scores.set(kw, 0.6);
+    }
+    if (skill.trigger?.type === 'semantic') {
+        scores.set(skill.trigger.description, 0.6);
+    }
+    scores.set(skill.name, 0.7);
+    return {
+        id: `skill:${skill.name}`,
+        parentId: opts?.parentId,
+        depth: opts?.depth ?? 0,
+        capabilities: {
+            scores,
+            tools: (skill.tools ?? []).map(t => t.name),
+            totalTasks: 0,
+            successRate: 0,
+        },
+        rewardHistory: [],
+        status: 'idle',
+        load: 0,
+        agent,
+        lastActiveAt: Date.now(),
+        consecutiveLosses: 0,
+    };
+}

package/dist/skill-registry.d.ts

@@ -0,0 +1,18 @@
+import type { Skill, SkillActivation } from '@loom-node/core';
+/**
+ * Catalog of available-but-not-loaded skills.
+ * Matches tasks against skill triggers for lazy activation.
+ */
+export declare class SkillNodeRegistry {
+    private catalog;
+    private loaded;
+    register(skill: Skill): void;
+    registerAll(skills: Skill[]): void;
+    markLoaded(name: string): void;
+    isLoaded(name: string): boolean;
+    get(name: string): Skill | undefined;
+    /** Find best matching unloaded skill for a task description */
+    findMatch(input: string, minScore?: number): Promise<SkillActivation | undefined>;
+    get size(): number;
+    get unloadedCount(): number;
+}

package/dist/skill-registry.js

@@ -0,0 +1,71 @@
+/**
+ * Catalog of available-but-not-loaded skills.
+ * Matches tasks against skill triggers for lazy activation.
+ */
+export class SkillNodeRegistry {
+    catalog = new Map();
+    loaded = new Set();
+    register(skill) {
+        this.catalog.set(skill.name, skill);
+    }
+    registerAll(skills) {
+        for (const s of skills)
+            this.register(s);
+    }
+    markLoaded(name) {
+        this.loaded.add(name);
+    }
+    isLoaded(name) {
+        return this.loaded.has(name);
+    }
+    get(name) {
+        return this.catalog.get(name);
+    }
+    /** Find best matching unloaded skill for a task description */
+    async findMatch(input, minScore = 0.3) {
+        const candidates = [];
+        for (const skill of this.catalog.values()) {
+            if (this.loaded.has(skill.name))
+                continue;
+            const act = await matchSkill(skill, input);
+            if (act && act.score >= minScore)
+                candidates.push(act);
+        }
+        if (candidates.length === 0)
+            return undefined;
+        candidates.sort((a, b) => b.score - a.score);
+        return candidates[0];
+    }
+    get size() { return this.catalog.size; }
+    get unloadedCount() { return this.catalog.size - this.loaded.size; }
+}
+/** Inline trigger matching — no dependency on @loom-node/skills */
+async function matchSkill(skill, input) {
+    if (!skill.trigger) {
+        return { skill, score: skill.priority ?? 0, reason: 'no-trigger' };
+    }
+    const t = skill.trigger;
+    const lower = input.toLowerCase();
+    if (t.type === 'keyword') {
+        const matched = t.keywords.filter(k => lower.includes(k.toLowerCase()));
+        if (matched.length === 0)
+            return null;
+        if (t.matchAll && matched.length < t.keywords.length)
+            return null;
+        const score = (skill.priority ?? 0.5) * (matched.length / t.keywords.length);
+        return { skill, score, reason: `keywords: ${matched.join(', ')}` };
+    }
+    if (t.type === 'pattern') {
+        if (!new RegExp(t.pattern, 'i').test(input))
+            return null;
+        return { skill, score: skill.priority ?? 0.8, reason: `pattern: ${t.pattern}` };
+    }
+    if (t.type === 'semantic') {
+        return { skill, score: t.threshold ?? 0.7, reason: `semantic: ${t.description}` };
+    }
+    if (t.type === 'custom') {
+        const ok = await t.match(input);
+        return ok ? { skill, score: skill.priority ?? 1, reason: 'custom' } : null;
+    }
+    return null;
+}

package/package.json

@@ -0,0 +1,27 @@
+{
+  "name": "@loom-node/amoeba",
+  "version": "0.1.0",
+  "type": "module",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
+    }
+  },
+  "files": [
+    "dist"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "license": "MIT",
+  "dependencies": {
+    "@loom-node/core": "0.1.0"
+  },
+  "scripts": {
+    "build": "tsc -b",
+    "clean": "rm -rf dist .tsbuildinfo"
+  }
+}