@loom-node/amoeba 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 Loom Node Contributors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/dist/__tests__/cluster.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/__tests__/cluster.test.js

@@ -0,0 +1,54 @@
+import { describe, it, expect } from 'vitest';
+import { ClusterManager } from '../cluster.js';
+import { mockNode } from './helpers.js';
+describe('ClusterManager', () => {
+    it('adds and removes nodes', () => {
+        const cm = new ClusterManager();
+        const n = mockNode({ id: 'n1' });
+        cm.addNode(n);
+        expect(cm.nodes.size).toBe(1);
+        cm.removeNode('n1');
+        expect(cm.nodes.size).toBe(0);
+    });
+    it('computes bid score', () => {
+        const cm = new ClusterManager();
+        const n = mockNode({ id: 'n1' });
+        cm.addNode(n);
+        const bid = cm.computeBid(n, {
+            taskId: 't1', domain: 'general', description: 'test',
+            estimatedComplexity: 0.5, priority: 'normal',
+        });
+        expect(bid.score).toBeGreaterThan(0);
+        expect(bid.agentId).toBe('n1');
+    });
+    it('selectWinner returns best node', () => {
+        const cm = new ClusterManager();
+        cm.addNode(mockNode({ id: 'a' }));
+        const b = mockNode({ id: 'b' });
+        b.capabilities.scores.set('general', 0.9);
+        cm.addNode(b);
+        const winner = cm.selectWinner({
+            taskId: 't1', domain: 'general', description: 'x',
+            estimatedComplexity: 0.3, priority: 'normal',
+        });
+        expect(winner?.id).toBe('b');
+    });
+    it('returns undefined when no bids meet minimum', () => {
+        const cm = new ClusterManager({ minBids: 5 });
+        cm.addNode(mockNode({ id: 'a' }));
+        const winner = cm.selectWinner({
+            taskId: 't1', domain: 'general', description: 'x',
+            estimatedComplexity: 0.3, priority: 'normal',
+        });
+        expect(winner).toBeUndefined();
+    });
+    it('updateLoad clamps between 0 and 1', () => {
+        const cm = new ClusterManager();
+        const n = mockNode({ id: 'n1' });
+        cm.addNode(n);
+        cm.updateLoad('n1', 2);
+        expect(n.load).toBe(1);
+        cm.updateLoad('n1', -1);
+        expect(n.load).toBe(0);
+    });
+});

package/dist/__tests__/helpers.d.ts

@@ -0,0 +1,4 @@
+import type { AgentNode } from '@loom-node/core';
+export declare function mockNode(overrides: Partial<AgentNode> & {
+    id: string;
+}): AgentNode;

package/dist/__tests__/helpers.js

@@ -0,0 +1,13 @@
+export function mockNode(overrides) {
+    return {
+        depth: 0,
+        capabilities: { scores: new Map([['general', 0.5]]), tools: [], totalTasks: 0, successRate: 0 },
+        rewardHistory: [],
+        status: 'idle',
+        load: 0,
+        agent: { run: async () => ({ content: 'ok', usage: { promptTokens: 10, completionTokens: 5, totalTokens: 15 } }) },
+        lastActiveAt: Date.now(),
+        consecutiveLosses: 0,
+        ...overrides,
+    };
+}

package/dist/__tests__/lifecycle.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/__tests__/lifecycle.test.js

@@ -0,0 +1,59 @@
+import { describe, it, expect } from 'vitest';
+import { LifecycleManager } from '../lifecycle.js';
+import { ClusterManager } from '../cluster.js';
+import { ApoptosisRejectedError } from '../errors.js';
+import { mockNode } from './helpers.js';
+describe('LifecycleManager', () => {
+    it('shouldMitosis returns true for complex tasks', () => {
+        const lm = new LifecycleManager();
+        const node = mockNode({ id: 'n1' });
+        const task = {
+            taskId: 't1', domain: 'general', description: 'complex',
+            estimatedComplexity: 0.9, priority: 'normal',
+        };
+        expect(lm.shouldMitosis(node, task)).toBe(true);
+    });
+    it('shouldMitosis returns false at max depth', () => {
+        const lm = new LifecycleManager();
+        const node = mockNode({ id: 'n1', depth: 3 });
+        const task = {
+            taskId: 't1', domain: 'general', description: 'complex',
+            estimatedComplexity: 0.9, priority: 'normal',
+        };
+        expect(lm.shouldMitosis(node, task)).toBe(false);
+    });
+    it('checkHealth returns healthy for good node', () => {
+        const lm = new LifecycleManager();
+        const node = mockNode({ id: 'n1' });
+        const report = lm.checkHealth(node);
+        expect(report.status).toBe('healthy');
+        expect(report.recommendation).toBe('keep');
+    });
+    it('checkHealth returns dying for idle node', () => {
+        const lm = new LifecycleManager();
+        const node = mockNode({ id: 'n1', lastActiveAt: Date.now() - 600_000 });
+        const report = lm.checkHealth(node);
+        expect(report.status).toBe('dying');
+        expect(report.recommendation).toBe('recycle');
+    });
+    it('apoptosis throws when at min nodes', () => {
+        const lm = new LifecycleManager();
+        const cm = new ClusterManager();
+        cm.addNode(mockNode({ id: 'a' }));
+        cm.addNode(mockNode({ id: 'b' }));
+        const dying = cm.nodes.get('a');
+        expect(() => lm.apoptosis(dying, cm)).toThrow(ApoptosisRejectedError);
+    });
+    it('apoptosis removes node and merges capabilities', () => {
+        const lm = new LifecycleManager();
+        const cm = new ClusterManager();
+        cm.addNode(mockNode({ id: 'a' }));
+        cm.addNode(mockNode({ id: 'b' }));
+        cm.addNode(mockNode({ id: 'c' }));
+        const dying = cm.nodes.get('a');
+        dying.capabilities.scores.set('coding', 0.8);
+        lm.apoptosis(dying, cm);
+        expect(cm.nodes.size).toBe(2);
+        expect(cm.nodes.has('a')).toBe(false);
+    });
+});

package/dist/__tests__/reward-bus.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/__tests__/reward-bus.test.js

@@ -0,0 +1,40 @@
+import { describe, it, expect } from 'vitest';
+import { RewardBus } from '../reward-bus.js';
+import { mockNode } from './helpers.js';
+describe('RewardBus', () => {
+    const task = {
+        taskId: 't1', domain: 'general', description: 'test',
+        estimatedComplexity: 0.5, priority: 'normal',
+    };
+    const result = {
+        taskId: 't1', agentId: 'n1', content: 'done',
+        success: true, tokenCost: 100, errorCount: 0, durationMs: 500,
+    };
+    it('evaluates and updates node capability', async () => {
+        const bus = new RewardBus();
+        const node = mockNode({ id: 'n1' });
+        const reward = await bus.evaluate(node, task, result);
+        expect(reward).toBeGreaterThan(0);
+        expect(node.rewardHistory).toHaveLength(1);
+        expect(node.capabilities.totalTasks).toBe(1);
+    });
+    it('failed task yields lower reward', async () => {
+        const bus = new RewardBus();
+        const n1 = mockNode({ id: 'n1' });
+        const n2 = mockNode({ id: 'n2' });
+        const good = await bus.evaluate(n1, task, result);
+        const bad = await bus.evaluate(n2, task, { ...result, success: false, errorCount: 2 });
+        expect(good).toBeGreaterThan(bad);
+    });
+    it('decayInactive reduces scores over time', () => {
+        const bus = new RewardBus();
+        const node = mockNode({ id: 'n1' });
+        node.capabilities.scores.set('general', 0.8);
+        node.rewardHistory.push({
+            taskId: 't', reward: 0.8, domain: 'general',
+            tokenCost: 100, timestamp: Date.now() - 3 * 86_400_000,
+        });
+        bus.decayInactive(node);
+        expect(node.capabilities.scores.get('general')).toBeLessThan(0.8);
+    });
+});

package/dist/amoeba-loop.d.ts

@@ -0,0 +1,41 @@
+import type { AgentEvent, LoopStrategy, LoopContext, Skill, LLMProvider } from '@loom-node/core';
+import type { ClusterManager } from './cluster.js';
+import type { RewardBus } from './reward-bus.js';
+import type { LifecycleManager, AgentFactory } from './lifecycle.js';
+import type { TaskPlanner } from './planner.js';
+import type { SkillNodeRegistry } from './skill-registry.js';
+import type { AmoebaRuntime } from './runtime.js';
+export interface AmoebaLoopConfig {
+    cluster: ClusterManager;
+    rewardBus: RewardBus;
+    lifecycle: LifecycleManager;
+    planner: TaskPlanner;
+    skillRegistry: SkillNodeRegistry;
+    llm: LLMProvider;
+    agentFactory?: AgentFactory;
+    runtime?: AmoebaRuntime;
+    skillEvolver?: Skill;
+    complexityLlmThreshold?: number;
+    evolutionRewardThreshold?: number;
+    evolutionWindow?: number;
+}
+export declare class AmoebaLoop implements LoopStrategy {
+    private readonly config;
+    readonly name = "amoeba";
+    private calibrationMap;
+    constructor(config: AmoebaLoopConfig);
+    execute(ctx: LoopContext): AsyncGenerator<AgentEvent>;
+    private sense;
+    private heuristicComplexity;
+    private llmComplexity;
+    private detectDomains;
+    private match;
+    private scaleAndExecute;
+    private buildEnrichedPrompt;
+    private evaluateAndAdapt;
+    private deriveActualComplexity;
+    private recordCalibration;
+    private calibrate;
+    private shouldEvolveSkill;
+    private triggerSkillEvolution;
+}

package/dist/amoeba-loop.js

@@ -0,0 +1,256 @@
+import { skillToNode } from './skill-node.js';
+import { AuctionNoWinnerError } from './errors.js';
+export class AmoebaLoop {
+    config;
+    name = 'amoeba';
+    calibrationMap = new Map();
+    constructor(config) {
+        this.config = config;
+    }
+    async *execute(ctx) {
+        const startTime = Date.now();
+        const totalUsage = { promptTokens: 0, completionTokens: 0, totalTokens: 0 };
+        const userMsg = [...ctx.messages].reverse().find((m) => m.role === 'user');
+        const raw = userMsg?.content ?? '';
+        const input = typeof raw === 'string' ? raw : '';
+        // Phase 1: SENSE
+        const spec = await this.sense(input);
+        yield { type: 'text-delta', content: `[Sense] complexity=${spec.task.estimatedComplexity.toFixed(2)} domains=[${spec.domainHints}]\n` };
+        // Phase 2: MATCH
+        const { winner, tier } = await this.match(spec, input);
+        if (!winner) {
+            yield { type: 'error', error: new AuctionNoWinnerError(spec.task.taskId), recoverable: false };
+            yield { type: 'done', content: '', usage: totalUsage, steps: 1, durationMs: Date.now() - startTime };
+            return;
+        }
+        yield { type: 'text-delta', content: `[Match] winner=${winner.id} tier=${tier}\n` };
+        // Phase 3+4: SCALE + EXECUTE
+        const result = await this.scaleAndExecute(winner, spec, input);
+        totalUsage.totalTokens += result.tokenCost;
+        yield { type: 'text-delta', content: result.content };
+        // Phase 5+6: EVALUATE + ADAPT
+        const adaptInfo = await this.evaluateAndAdapt(winner, spec, result);
+        yield { type: 'text-delta', content: `\n[Adapt] reward=${adaptInfo.reward.toFixed(2)} evolved=${adaptInfo.evolved} recycled=${adaptInfo.recycled}\n` };
+        yield { type: 'done', content: result.content, usage: totalUsage, steps: 1, durationMs: Date.now() - startTime };
+    }
+    // ── Phase 1: SENSE ──
+    async sense(input) {
+        const threshold = this.config.complexityLlmThreshold ?? 200;
+        const estimate = input.length < threshold
+            ? this.heuristicComplexity(input)
+            : await this.llmComplexity(input);
+        const calibrated = this.calibrate(estimate);
+        const task = {
+            taskId: `amoeba-${Date.now()}`,
+            domain: calibrated.domains[0] ?? 'general',
+            description: input,
+            estimatedComplexity: calibrated.score,
+            priority: 'normal',
+            tokenBudget: calibrated.score < 0.4 ? 2048 : calibrated.score < 0.7 ? 4096 : 8192,
+        };
+        return { task, objective: input, domainHints: calibrated.domains };
+    }
+    heuristicComplexity(input) {
+        const words = input.split(/\s+/).length;
+        const sentences = (input.match(/[.!?。！？]/g) ?? []).length;
+        const hasList = /\d+[.)]|[-*•]/.test(input);
+        const domains = this.detectDomains(input);
+        let score = Math.min(words / 200, 0.5);
+        if (sentences > 2)
+            score += 0.15;
+        if (hasList)
+            score += 0.1;
+        if (domains.length > 2)
+            score += 0.15;
+        return { score: Math.min(score, 1), domains, method: 'heuristic' };
+    }
+    async llmComplexity(input) {
+        try {
+            const result = await this.config.llm.complete({
+                messages: [{
+                        role: 'user',
+                        content: `Assess this task. Reply ONLY with JSON: {"score":0.0-1.0,"domains":["..."],"reasoning":"..."}\n\nTask: ${input}`,
+                    }],
+                temperature: 0,
+                maxTokens: 128,
+            });
+            const match = result.content.match(/\{[\s\S]*\}/);
+            if (match) {
+                const obj = JSON.parse(match[0]);
+                return {
+                    score: Math.max(0, Math.min(1, obj.score ?? 0.5)),
+                    domains: obj.domains ?? ['general'],
+                    reasoning: obj.reasoning,
+                    method: 'llm',
+                };
+            }
+        }
+        catch { /* fall through */ }
+        return this.heuristicComplexity(input);
+    }
+    detectDomains(input) {
+        const lower = input.toLowerCase();
+        const domainKeywords = {
+            code: ['code', 'function', 'bug', 'api', 'implement', 'refactor'],
+            data: ['data', 'database', 'query', 'sql', 'schema'],
+            writing: ['write', 'draft', 'essay', 'article', 'document'],
+            math: ['calculate', 'equation', 'formula', 'math', 'statistics'],
+            research: ['research', 'analyze', 'compare', 'evaluate', 'study'],
+        };
+        const found = [];
+        for (const [domain, kws] of Object.entries(domainKeywords)) {
+            if (kws.some(k => lower.includes(k)))
+                found.push(domain);
+        }
+        return found.length > 0 ? found : ['general'];
+    }
+    // ── Phase 2: MATCH ──
+    async match(spec, input) {
+        // Tier 1: auction across loaded nodes
+        const auctionWinner = this.config.cluster.selectWinner(spec.task);
+        if (auctionWinner)
+            return { winner: auctionWinner, tier: 1 };
+        // Tier 2: scan unloaded skill catalog
+        const skillMatch = await this.config.skillRegistry.findMatch(input);
+        if (skillMatch) {
+            const node = this.config.runtime
+                ? this.config.runtime.loadSkill(skillMatch.skill)
+                : (() => { const n = skillToNode(skillMatch.skill, this.config.llm); this.config.cluster.addNode(n); this.config.skillRegistry.markLoaded(skillMatch.skill.name); return n; })();
+            return { winner: node, tier: 2 };
+        }
+        // Tier 3: skill evolution via LLM (opt-in)
+        if (this.config.skillEvolver?.tools?.[0]) {
+            try {
+                const res = await this.config.skillEvolver.tools[0].execute({ task: input }, {});
+                const r = res;
+                if (r.success && r.nodeId) {
+                    const node = this.config.cluster.nodes.get(r.nodeId);
+                    if (node)
+                        return { winner: node, tier: 3 };
+                }
+            }
+            catch { /* tier 3 failed, fall through */ }
+        }
+        return { winner: undefined, tier: 1 };
+    }
+    // ── Phase 3+4: SCALE + EXECUTE ──
+    async scaleAndExecute(winner, spec, input) {
+        const complexity = spec.task.estimatedComplexity;
+        winner.status = 'busy';
+        winner.lastActiveAt = Date.now();
+        this.config.cluster.updateLoad(winner.id, 0.8);
+        try {
+            if (complexity > 0.7 && this.config.lifecycle.shouldMitosis(winner, spec.task)) {
+                return await this.config.lifecycle.mitosis(winner, spec.task, this.config.planner, this.config.cluster, this.config.rewardBus, this.config.agentFactory, spec, this.config.runtime);
+            }
+            const prompt = complexity >= 0.4 ? this.buildEnrichedPrompt(spec) : input;
+            const start = Date.now();
+            const done = await winner.agent.run(prompt);
+            return {
+                taskId: spec.task.taskId, agentId: winner.id,
+                content: done.content, success: true,
+                tokenCost: done.usage.totalTokens, errorCount: 0,
+                durationMs: Date.now() - start,
+            };
+        }
+        catch {
+            return {
+                taskId: spec.task.taskId, agentId: winner.id,
+                content: '', success: false, tokenCost: 0, errorCount: 1, durationMs: 0,
+            };
+        }
+        finally {
+            winner.status = 'idle';
+            this.config.cluster.updateLoad(winner.id, 0);
+        }
+    }
+    buildEnrichedPrompt(spec) {
+        let prompt = `Objective: ${spec.objective}`;
+        if (spec.outputFormat)
+            prompt += `\nOutput format: ${spec.outputFormat}`;
+        if (spec.boundaries)
+            prompt += `\nConstraints: ${spec.boundaries}`;
+        if (spec.toolGuidance)
+            prompt += `\nTool guidance: ${spec.toolGuidance}`;
+        return prompt;
+    }
+    // ── Phase 5+6: EVALUATE + ADAPT ──
+    async evaluateAndAdapt(winner, spec, result) {
+        // EVALUATE
+        const reward = await this.config.rewardBus.evaluate(winner, spec.task, result);
+        // ADAPT: consecutiveLosses
+        if (reward < 0.5) {
+            winner.consecutiveLosses++;
+        }
+        else {
+            winner.consecutiveLosses = 0;
+        }
+        // ADAPT: health check → apoptosis
+        let recycled = false;
+        const health = this.config.lifecycle.checkHealth(winner);
+        if (health.recommendation === 'recycle') {
+            try {
+                this.config.lifecycle.apoptosis(winner, this.config.cluster);
+                recycled = true;
+            }
+            catch { /* rejected, skip */ }
+        }
+        // ADAPT: complexity calibration
+        const actual = this.deriveActualComplexity(result);
+        this.recordCalibration(spec.task.domain, spec.task.estimatedComplexity, actual);
+        // ADAPT: skill evolution bridge
+        let evolved = false;
+        if (this.shouldEvolveSkill(winner)) {
+            evolved = await this.triggerSkillEvolution(winner, spec);
+        }
+        // ADAPT: decay inactive
+        this.config.rewardBus.decayInactive(winner);
+        return { reward, evolved, recycled };
+    }
+    // ── Helpers: calibration ──
+    deriveActualComplexity(result) {
+        const tokenRatio = Math.min(result.tokenCost / 8192, 1);
+        const durationRatio = Math.min(result.durationMs / 30000, 1);
+        return tokenRatio * 0.6 + durationRatio * 0.4;
+    }
+    recordCalibration(domain, estimated, actual) {
+        const entry = this.calibrationMap.get(domain) ?? { bias: 0, count: 0 };
+        entry.bias = 0.3 * (actual - estimated) + 0.7 * entry.bias;
+        entry.count++;
+        this.calibrationMap.set(domain, entry);
+    }
+    calibrate(estimate) {
+        const domain = estimate.domains[0] ?? 'general';
+        const entry = this.calibrationMap.get(domain);
+        if (!entry || entry.count < 3)
+            return estimate;
+        return { ...estimate, score: Math.max(0, Math.min(1, estimate.score + entry.bias)) };
+    }
+    // ── Helpers: skill evolution bridge ──
+    shouldEvolveSkill(node) {
+        if (!this.config.skillEvolver)
+            return false;
+        if (!node.id.startsWith('skill:'))
+            return false;
+        const window = this.config.evolutionWindow ?? 5;
+        const threshold = this.config.evolutionRewardThreshold ?? 0.35;
+        const recent = node.rewardHistory.slice(-window);
+        if (recent.length < window)
+            return false;
+        const avg = recent.reduce((s, r) => s + r.reward, 0) / recent.length;
+        return avg < threshold;
+    }
+    async triggerSkillEvolution(node, spec) {
+        const tool = this.config.skillEvolver?.tools?.[0];
+        if (!tool)
+            return false;
+        try {
+            const skillName = node.id.replace('skill:', '');
+            await tool.execute({ task: spec.objective, existingSkill: skillName, feedback: 'Low reward — needs improvement' }, {});
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+}

package/dist/cluster-provider.d.ts

@@ -0,0 +1,9 @@
+import type { ContextProvider, ContextFragment } from '@loom-node/core';
+import type { ClusterManager } from './cluster.js';
+export declare class ClusterProvider implements ContextProvider {
+    private cluster;
+    private agentId;
+    readonly source: "cluster";
+    constructor(cluster: ClusterManager, agentId: string);
+    provide(query: string, budget: number): Promise<ContextFragment[]>;
+}

package/dist/cluster-provider.js

@@ -0,0 +1,39 @@
+export class ClusterProvider {
+    cluster;
+    agentId;
+    source = 'cluster';
+    constructor(cluster, agentId) {
+        this.cluster = cluster;
+        this.agentId = agentId;
+    }
+    async provide(query, budget) {
+        const fragments = [];
+        const self = this.cluster.nodes.get(this.agentId);
+        if (!self)
+            return fragments;
+        const capLines = [...self.capabilities.scores.entries()]
+            .sort((a, b) => b[1] - a[1])
+            .map(([d, s]) => `${d}: ${s.toFixed(2)}`)
+            .join(', ');
+        const capText = `My capabilities: ${capLines}. Success rate: ${(self.capabilities.successRate * 100).toFixed(0)}%`;
+        fragments.push({ source: 'cluster', content: capText, tokens: estimateTokens(capText), relevance: 0.8, metadata: { type: 'self-capability' } });
+        const peers = [...this.cluster.nodes.values()].filter(n => n.id !== this.agentId);
+        if (peers.length > 0) {
+            const peerText = `Cluster: ${peers.length} peers. ` + peers.slice(0, 5)
+                .map(p => `${p.id}(${p.status}, load:${p.load.toFixed(1)})`)
+                .join(', ');
+            fragments.push({ source: 'cluster', content: peerText, tokens: estimateTokens(peerText), relevance: 0.5, metadata: { type: 'cluster-state' } });
+        }
+        const recent = self.rewardHistory.slice(-5);
+        if (recent.length > 0) {
+            const avg = recent.reduce((s, r) => s + r.reward, 0) / recent.length;
+            const rewardText = `Recent reward avg: ${avg.toFixed(2)} over ${recent.length} tasks`;
+            fragments.push({ source: 'cluster', content: rewardText, tokens: estimateTokens(rewardText), relevance: 0.6, metadata: { type: 'reward-history' } });
+        }
+        let total = 0;
+        return fragments.filter(f => { total += f.tokens; return total <= budget; });
+    }
+}
+function estimateTokens(text) {
+    return Math.ceil(text.length / 4);
+}

package/dist/cluster.d.ts

@@ -0,0 +1,18 @@
+import type { AgentNode, TaskAd, Bid } from '@loom-node/core';
+export interface AuctionConfig {
+    bidTimeoutMs: number;
+    minBids: number;
+    fallbackStrategy: 'random' | 'reject';
+}
+export declare class ClusterManager {
+    readonly nodes: Map<string, AgentNode>;
+    private auctionConfig;
+    constructor(config?: Partial<AuctionConfig>);
+    addNode(node: AgentNode): void;
+    removeNode(id: string): void;
+    computeBid(node: AgentNode, task: TaskAd): Bid;
+    collectBids(task: TaskAd): Bid[];
+    selectWinner(task: TaskAd): AgentNode | undefined;
+    findIdle(): AgentNode | undefined;
+    updateLoad(nodeId: string, load: number): void;
+}

package/dist/cluster.js

@@ -0,0 +1,68 @@
+const DEFAULT_AUCTION = {
+    bidTimeoutMs: 2000,
+    minBids: 1,
+    fallbackStrategy: 'reject',
+};
+export class ClusterManager {
+    nodes = new Map();
+    auctionConfig;
+    constructor(config) {
+        this.auctionConfig = { ...DEFAULT_AUCTION, ...config };
+    }
+    addNode(node) {
+        this.nodes.set(node.id, node);
+    }
+    removeNode(id) {
+        this.nodes.delete(id);
+    }
+    computeBid(node, task) {
+        const capabilityMatch = node.capabilities.scores.get(task.domain) ?? 0;
+        const availability = node.status === 'idle' ? 1 - node.load : 0;
+        const historySuccess = node.capabilities.successRate;
+        const tools = task.requiredTools ?? [];
+        const toolCoverage = tools.length === 0
+            ? 1
+            : tools.filter(t => node.capabilities.tools.includes(t)).length / tools.length;
+        const score = capabilityMatch * 0.4 + availability * 0.25 + historySuccess * 0.2 + toolCoverage * 0.15;
+        return {
+            agentId: node.id,
+            taskId: task.taskId,
+            score,
+            breakdown: { capabilityMatch, availability, historySuccess, toolCoverage },
+            estimatedTokens: task.tokenBudget ?? 4096,
+        };
+    }
+    collectBids(task) {
+        const bids = [];
+        for (const node of this.nodes.values()) {
+            if (node.status !== 'idle' && node.status !== 'busy')
+                continue;
+            const bid = this.computeBid(node, task);
+            if (bid.score > 0)
+                bids.push(bid);
+        }
+        return bids.sort((a, b) => b.score - a.score);
+    }
+    selectWinner(task) {
+        const bids = this.collectBids(task);
+        if (bids.length < this.auctionConfig.minBids) {
+            if (this.auctionConfig.fallbackStrategy === 'random') {
+                return this.findIdle();
+            }
+            return undefined;
+        }
+        return this.nodes.get(bids[0].agentId);
+    }
+    findIdle() {
+        for (const node of this.nodes.values()) {
+            if (node.status === 'idle')
+                return node;
+        }
+        return undefined;
+    }
+    updateLoad(nodeId, load) {
+        const node = this.nodes.get(nodeId);
+        if (node)
+            node.load = Math.max(0, Math.min(1, load));
+    }
+}

package/dist/errors.d.ts

@@ -0,0 +1,12 @@
+import { LoomError } from '@loom-node/core';
+export declare class AuctionNoWinnerError extends LoomError {
+    constructor(taskId: string);
+}
+export declare class MitosisError extends LoomError {
+    readonly parentId: string;
+    constructor(parentId: string, message: string, cause?: Error);
+}
+export declare class ApoptosisRejectedError extends LoomError {
+    readonly nodeId: string;
+    constructor(nodeId: string, reason: string);
+}