@loom-node/amoeba 0.1.0

package/dist/errors.js

@@ -0,0 +1,23 @@
+import { LoomError } from '@loom-node/core';
+export class AuctionNoWinnerError extends LoomError {
+    constructor(taskId) {
+        super('AUCTION_NO_WINNER', `No agent won auction for task ${taskId}`);
+        this.name = 'AuctionNoWinnerError';
+    }
+}
+export class MitosisError extends LoomError {
+    parentId;
+    constructor(parentId, message, cause) {
+        super('MITOSIS_FAILED', message, cause);
+        this.name = 'MitosisError';
+        this.parentId = parentId;
+    }
+}
+export class ApoptosisRejectedError extends LoomError {
+    nodeId;
+    constructor(nodeId, reason) {
+        super('APOPTOSIS_REJECTED', `Cannot recycle node ${nodeId}: ${reason}`);
+        this.name = 'ApoptosisRejectedError';
+        this.nodeId = nodeId;
+    }
+}

package/dist/index.d.ts

@@ -0,0 +1,22 @@
+export { RewardBus } from './reward-bus.js';
+export type { RewardConfig } from './reward-bus.js';
+export { TaskPlanner } from './planner.js';
+export type { PlannerConfig } from './planner.js';
+export { ClusterManager } from './cluster.js';
+export type { AuctionConfig } from './cluster.js';
+export { LifecycleManager } from './lifecycle.js';
+export type { MitosisConfig, ApoptosisConfig, LifecycleConfig, HealthReport, HealthStatus, AgentFactory } from './lifecycle.js';
+export { ClusterProvider } from './cluster-provider.js';
+export { PlanStrategy } from './plan-strategy.js';
+export { OrchestrateStrategy } from './orchestrate-strategy.js';
+export { AmoebaRuntime } from './runtime.js';
+export type { AmoebaRuntimeConfig } from './runtime.js';
+export { AuctionNoWinnerError, MitosisError, ApoptosisRejectedError } from './errors.js';
+export { skillToNode } from './skill-node.js';
+export { SkillNodeRegistry } from './skill-registry.js';
+export { createSkillEvolver } from './skill-evolver.js';
+export type { SkillDiscoverer } from './orchestrate-strategy.js';
+export { AmoebaLoop } from './amoeba-loop.js';
+export type { AmoebaLoopConfig } from './amoeba-loop.js';
+export { MitosisScratchpad } from './mitosis-scratchpad.js';
+export { MitosisContextProvider } from './mitosis-provider.js';

package/dist/index.js

@@ -0,0 +1,15 @@
+export { RewardBus } from './reward-bus.js';
+export { TaskPlanner } from './planner.js';
+export { ClusterManager } from './cluster.js';
+export { LifecycleManager } from './lifecycle.js';
+export { ClusterProvider } from './cluster-provider.js';
+export { PlanStrategy } from './plan-strategy.js';
+export { OrchestrateStrategy } from './orchestrate-strategy.js';
+export { AmoebaRuntime } from './runtime.js';
+export { AuctionNoWinnerError, MitosisError, ApoptosisRejectedError } from './errors.js';
+export { skillToNode } from './skill-node.js';
+export { SkillNodeRegistry } from './skill-registry.js';
+export { createSkillEvolver } from './skill-evolver.js';
+export { AmoebaLoop } from './amoeba-loop.js';
+export { MitosisScratchpad } from './mitosis-scratchpad.js';
+export { MitosisContextProvider } from './mitosis-provider.js';

package/dist/lifecycle.d.ts

@@ -0,0 +1,42 @@
+import type { AgentNode, TaskAd, TaskResult, TaskSpec, MitosisContext } from '@loom-node/core';
+import type { Agent } from '@loom-node/core';
+import type { ClusterManager } from './cluster.js';
+import type { TaskPlanner } from './planner.js';
+import type { RewardBus } from './reward-bus.js';
+import type { AmoebaRuntime } from './runtime.js';
+export type AgentFactory = (domain: string, context?: MitosisContext) => Agent;
+export interface MitosisConfig {
+    complexityThreshold: number;
+    maxChildren: number;
+    maxDepth: number;
+}
+export interface ApoptosisConfig {
+    minNodes: number;
+    maxConsecutiveLosses: number;
+    minRewardThreshold: number;
+    maxIdleMs: number;
+    rewardWindow: number;
+}
+export interface LifecycleConfig {
+    mitosis: MitosisConfig;
+    apoptosis: ApoptosisConfig;
+}
+export type HealthStatus = 'healthy' | 'warning' | 'dying';
+export interface HealthReport {
+    nodeId: string;
+    status: HealthStatus;
+    recentAvgReward: number;
+    idleMs: number;
+    recommendation: 'keep' | 'merge' | 'recycle';
+}
+export declare class LifecycleManager {
+    private readonly config;
+    constructor(config?: Partial<LifecycleConfig>);
+    shouldMitosis(node: AgentNode, task: TaskAd): boolean;
+    mitosis(parent: AgentNode, task: TaskAd, planner: TaskPlanner, cluster: ClusterManager, rewardBus: RewardBus, agentFactory?: AgentFactory, taskSpec?: TaskSpec, runtime?: AmoebaRuntime): Promise<TaskResult>;
+    private buildChildPrompt;
+    checkHealth(node: AgentNode): HealthReport;
+    findMergeTarget(dying: AgentNode, cluster: ClusterManager): AgentNode | undefined;
+    mergeCapabilities(dying: AgentNode, target: AgentNode): void;
+    apoptosis(dying: AgentNode, cluster: ClusterManager): boolean;
+}

package/dist/lifecycle.js

@@ -0,0 +1,171 @@
+import { ApoptosisRejectedError } from './errors.js';
+import { MitosisScratchpad } from './mitosis-scratchpad.js';
+const DEFAULTS = {
+    mitosis: { complexityThreshold: 0.6, maxChildren: 4, maxDepth: 2 },
+    apoptosis: { minNodes: 2, maxConsecutiveLosses: 20, minRewardThreshold: 0.3, maxIdleMs: 300_000, rewardWindow: 10 },
+};
+export class LifecycleManager {
+    config;
+    constructor(config) {
+        this.config = {
+            mitosis: { ...DEFAULTS.mitosis, ...config?.mitosis },
+            apoptosis: { ...DEFAULTS.apoptosis, ...config?.apoptosis },
+        };
+    }
+    shouldMitosis(node, task) {
+        if (node.depth >= this.config.mitosis.maxDepth)
+            return false;
+        return task.estimatedComplexity > this.config.mitosis.complexityThreshold;
+    }
+    async mitosis(parent, task, planner, cluster, rewardBus, agentFactory, taskSpec, runtime) {
+        parent.status = 'splitting';
+        const subtasks = await planner.decompose(task);
+        const limited = subtasks.slice(0, this.config.mitosis.maxChildren);
+        const scratchpad = new MitosisScratchpad();
+        const spec = taskSpec ?? { task, objective: task.description, domainHints: [task.domain] };
+        const executor = async (sub) => {
+            sub.resolvedInputs = scratchpad.readDependencies(sub.dependencies);
+            const subTask = {
+                taskId: sub.id, domain: sub.domain, description: sub.description,
+                estimatedComplexity: task.estimatedComplexity / limited.length,
+                priority: task.priority,
+            };
+            const winner = cluster.selectWinner(subTask);
+            let node;
+            if (winner) {
+                node = winner;
+            }
+            else if (agentFactory) {
+                const childId = `child-${parent.id}-${sub.id}`;
+                const mitosisCtx = {
+                    parentTaskSpec: spec, subtask: sub, scratchpad, parentTools: parent.capabilities.tools,
+                    context: runtime?.buildContextFor(childId, { mitosisCtx: undefined }),
+                    memory: runtime?.getMemory(),
+                };
+                // Re-assign context after mitosisCtx is created (self-reference)
+                mitosisCtx.context = runtime?.buildContextFor(childId, { mitosisCtx });
+                const child = agentFactory(sub.domain, mitosisCtx);
+                node = {
+                    id: childId,
+                    depth: parent.depth + 1,
+                    capabilities: {
+                        scores: new Map([[sub.domain, 0.5]]),
+                        tools: [...parent.capabilities.tools], totalTasks: 0, successRate: 0,
+                    },
+                    rewardHistory: [], status: 'idle', load: 0,
+                    agent: child, lastActiveAt: Date.now(), consecutiveLosses: 0,
+                };
+                cluster.addNode(node);
+            }
+            else {
+                node = parent;
+            }
+            node.status = 'busy';
+            const start = Date.now();
+            const prompt = this.buildChildPrompt(sub, spec);
+            const result = await node.agent.run(prompt);
+            const taskResult = {
+                taskId: sub.id, agentId: node.id, content: result.content,
+                success: true, tokenCost: result.usage.totalTokens,
+                errorCount: 0, durationMs: Date.now() - start,
+            };
+            scratchpad.write(sub.id, taskResult);
+            await rewardBus.evaluate(node, subTask, taskResult);
+            node.status = 'idle';
+            return taskResult;
+        };
+        const results = await planner.executeDAG(limited, executor);
+        const content = await planner.aggregate(task, results);
+        parent.status = 'idle';
+        return {
+            taskId: task.taskId, agentId: parent.id, content, success: results.every(r => r.success),
+            tokenCost: results.reduce((s, r) => s + r.tokenCost, 0),
+            errorCount: results.reduce((s, r) => s + r.errorCount, 0),
+            durationMs: results.reduce((s, r) => s + r.durationMs, 0),
+            metadata: {
+                keyFindings: results.flatMap(r => r.metadata?.keyFindings ?? []).slice(0, 5),
+                toolsUsed: [...new Set(results.flatMap(r => r.metadata?.toolsUsed ?? []))],
+                summary: content.slice(0, 500),
+                confidence: results.reduce((s, r) => s + (r.metadata?.confidence ?? 0.5), 0) / results.length,
+            },
+        };
+    }
+    buildChildPrompt(sub, spec) {
+        let prompt = sub.description;
+        if (spec.outputFormat)
+            prompt += `\nOutput format: ${spec.outputFormat}`;
+        if (spec.boundaries)
+            prompt += `\nConstraints: ${spec.boundaries}`;
+        if (sub.resolvedInputs && Object.keys(sub.resolvedInputs).length > 0) {
+            prompt += '\nContext from prior tasks:\n' +
+                Object.entries(sub.resolvedInputs).map(([id, s]) => `[${id}]: ${s}`).join('\n');
+        }
+        return prompt;
+    }
+    checkHealth(node) {
+        const cfg = this.config.apoptosis;
+        const now = Date.now();
+        const idleMs = now - node.lastActiveAt;
+        const recent = node.rewardHistory.slice(-cfg.rewardWindow);
+        const recentAvgReward = recent.length > 0
+            ? recent.reduce((s, r) => s + r.reward, 0) / recent.length
+            : 0.5;
+        if (node.consecutiveLosses >= cfg.maxConsecutiveLosses
+            || recentAvgReward < cfg.minRewardThreshold
+            || idleMs > cfg.maxIdleMs) {
+            return { nodeId: node.id, status: 'dying', recentAvgReward, idleMs, recommendation: 'recycle' };
+        }
+        if (node.consecutiveLosses >= cfg.maxConsecutiveLosses / 2
+            || recentAvgReward < cfg.minRewardThreshold * 1.5) {
+            return { nodeId: node.id, status: 'warning', recentAvgReward, idleMs, recommendation: 'merge' };
+        }
+        return { nodeId: node.id, status: 'healthy', recentAvgReward, idleMs, recommendation: 'keep' };
+    }
+    findMergeTarget(dying, cluster) {
+        let best;
+        let bestScore = -1;
+        for (const node of cluster.nodes.values()) {
+            if (node.id === dying.id)
+                continue;
+            let complementarity = 0;
+            for (const [domain, score] of dying.capabilities.scores) {
+                const ts = node.capabilities.scores.get(domain) ?? 0;
+                if (score > ts)
+                    complementarity += score - ts;
+            }
+            const s = complementarity * (1 - node.load * 0.5);
+            if (s > bestScore) {
+                bestScore = s;
+                best = node;
+            }
+        }
+        return best;
+    }
+    mergeCapabilities(dying, target) {
+        const dw = dying.capabilities.totalTasks;
+        const tw = target.capabilities.totalTasks;
+        const total = dw + tw || 1;
+        for (const [domain, ds] of dying.capabilities.scores) {
+            const ts = target.capabilities.scores.get(domain) ?? 0;
+            target.capabilities.scores.set(domain, (ds * dw + ts * tw) / total);
+        }
+        for (const tool of dying.capabilities.tools) {
+            if (!target.capabilities.tools.includes(tool))
+                target.capabilities.tools.push(tool);
+        }
+    }
+    apoptosis(dying, cluster) {
+        if (cluster.nodes.size <= this.config.apoptosis.minNodes) {
+            throw new ApoptosisRejectedError(dying.id, 'cluster at minimum node count');
+        }
+        if (dying.status === 'busy') {
+            throw new ApoptosisRejectedError(dying.id, 'node is busy');
+        }
+        dying.status = 'dying';
+        const target = this.findMergeTarget(dying, cluster);
+        if (target)
+            this.mergeCapabilities(dying, target);
+        cluster.removeNode(dying.id);
+        return true;
+    }
+}

package/dist/mitosis-provider.d.ts

@@ -0,0 +1,10 @@
+import type { ContextProvider, ContextFragment, TaskSpec, SubTask, IScratchpad } from '@loom-node/core';
+export declare class MitosisContextProvider implements ContextProvider {
+    private parentSpec;
+    private subtask;
+    private scratchpad;
+    readonly source: "mitosis";
+    constructor(parentSpec: Pick<TaskSpec, 'objective' | 'outputFormat' | 'boundaries' | 'toolGuidance'>, subtask: SubTask, scratchpad: IScratchpad);
+    provide(_query: string, budget: number): Promise<ContextFragment[]>;
+    private buildGuidance;
+}

package/dist/mitosis-provider.js

@@ -0,0 +1,61 @@
+function estimateTokens(text) {
+    return Math.ceil(text.length / 4);
+}
+export class MitosisContextProvider {
+    parentSpec;
+    subtask;
+    scratchpad;
+    source = 'mitosis';
+    constructor(parentSpec, subtask, scratchpad) {
+        this.parentSpec = parentSpec;
+        this.subtask = subtask;
+        this.scratchpad = scratchpad;
+    }
+    async provide(_query, budget) {
+        const fragments = [];
+        let used = 0;
+        // Fragment 1: Parent guidance (high relevance)
+        const guidance = this.buildGuidance();
+        if (guidance) {
+            const tokens = estimateTokens(guidance);
+            if (used + tokens <= budget) {
+                fragments.push({ source: 'mitosis', content: guidance, tokens, relevance: 0.95, metadata: { type: 'parent-guidance' } });
+                used += tokens;
+            }
+        }
+        // Fragment 2: Dependency results (just-in-time from scratchpad)
+        if (this.subtask.dependencies.length > 0) {
+            const deps = this.scratchpad.readDependencies(this.subtask.dependencies);
+            const entries = Object.entries(deps);
+            if (entries.length > 0) {
+                const depText = entries.map(([id, summary]) => `[${id}]: ${summary}`).join('\n');
+                const tokens = estimateTokens(depText);
+                if (used + tokens <= budget) {
+                    fragments.push({ source: 'mitosis', content: depText, tokens, relevance: 0.9, metadata: { type: 'dependency-results' } });
+                    used += tokens;
+                }
+            }
+        }
+        // Fragment 3: Sibling awareness (lower relevance, progressive disclosure)
+        const all = this.scratchpad.readAll();
+        const siblingIds = Object.keys(all).filter(id => id !== this.subtask.id && !this.subtask.dependencies.includes(id));
+        if (siblingIds.length > 0) {
+            const sibText = `Completed siblings: ${siblingIds.join(', ')}`;
+            const tokens = estimateTokens(sibText);
+            if (used + tokens <= budget) {
+                fragments.push({ source: 'mitosis', content: sibText, tokens, relevance: 0.4, metadata: { type: 'sibling-awareness' } });
+            }
+        }
+        return fragments;
+    }
+    buildGuidance() {
+        const parts = [];
+        if (this.parentSpec.outputFormat)
+            parts.push(`Output format: ${this.parentSpec.outputFormat}`);
+        if (this.parentSpec.boundaries)
+            parts.push(`Constraints: ${this.parentSpec.boundaries}`);
+        if (this.parentSpec.toolGuidance)
+            parts.push(`Tool guidance: ${this.parentSpec.toolGuidance}`);
+        return parts.length > 0 ? parts.join('\n') : undefined;
+    }
+}

package/dist/mitosis-scratchpad.d.ts

@@ -0,0 +1,8 @@
+import type { TaskResult, IScratchpad } from '@loom-node/core';
+export declare class MitosisScratchpad implements IScratchpad {
+    private entries;
+    write(taskId: string, result: TaskResult): void;
+    readDependencies(depIds: string[]): Record<string, string>;
+    readAll(): Record<string, string>;
+    private condense;
+}

package/dist/mitosis-scratchpad.js

@@ -0,0 +1,23 @@
+export class MitosisScratchpad {
+    entries = new Map();
+    write(taskId, result) {
+        this.entries.set(taskId, result.metadata?.summary ?? this.condense(result.content));
+    }
+    readDependencies(depIds) {
+        const out = {};
+        for (const id of depIds) {
+            const entry = this.entries.get(id);
+            if (entry)
+                out[id] = entry;
+        }
+        return out;
+    }
+    readAll() {
+        return Object.fromEntries(this.entries);
+    }
+    condense(content) {
+        if (content.length <= 800)
+            return content;
+        return content.slice(0, 780) + '... [truncated]';
+    }
+}

package/dist/orchestrate-strategy.d.ts

@@ -0,0 +1,21 @@
+import type { AgentEvent } from '@loom-node/core';
+import type { LoopStrategy, LoopContext } from '@loom-node/core';
+import type { AgentNode } from '@loom-node/core';
+import type { ClusterManager } from './cluster.js';
+import type { RewardBus } from './reward-bus.js';
+import type { AgentFactory, LifecycleManager } from './lifecycle.js';
+import type { TaskPlanner } from './planner.js';
+import type { AmoebaRuntime } from './runtime.js';
+export type SkillDiscoverer = (input: string) => Promise<AgentNode | undefined>;
+export declare class OrchestrateStrategy implements LoopStrategy {
+    private cluster;
+    private rewardBus;
+    private lifecycle;
+    private planner;
+    private agentFactory?;
+    private discoverSkill?;
+    private runtime?;
+    readonly name = "orchestrate";
+    constructor(cluster: ClusterManager, rewardBus: RewardBus, lifecycle: LifecycleManager, planner: TaskPlanner, agentFactory?: AgentFactory | undefined, discoverSkill?: SkillDiscoverer | undefined, runtime?: AmoebaRuntime | undefined);
+    execute(ctx: LoopContext): AsyncGenerator<AgentEvent>;
+}

package/dist/orchestrate-strategy.js

@@ -0,0 +1,78 @@
+import { AuctionNoWinnerError, MitosisError } from './errors.js';
+export class OrchestrateStrategy {
+    cluster;
+    rewardBus;
+    lifecycle;
+    planner;
+    agentFactory;
+    discoverSkill;
+    runtime;
+    name = 'orchestrate';
+    constructor(cluster, rewardBus, lifecycle, planner, agentFactory, discoverSkill, runtime) {
+        this.cluster = cluster;
+        this.rewardBus = rewardBus;
+        this.lifecycle = lifecycle;
+        this.planner = planner;
+        this.agentFactory = agentFactory;
+        this.discoverSkill = discoverSkill;
+        this.runtime = runtime;
+    }
+    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 : '';
+        const task = {
+            taskId: `orch-${Date.now()}`, domain: 'general', description: input,
+            estimatedComplexity: 0.5, priority: 'normal',
+        };
+        yield { type: 'step-start', step: 0, totalSteps: 2 };
+        // Auction: select best agent, or discover a skill-node
+        let winner = this.cluster.selectWinner(task);
+        if (!winner && this.discoverSkill) {
+            const discovered = await this.discoverSkill(input);
+            if (discovered) {
+                winner = discovered;
+                yield { type: 'text-delta', content: `[Orchestrate] Skill discovered: ${discovered.id}\n` };
+            }
+        }
+        if (!winner) {
+            yield { type: 'error', error: new AuctionNoWinnerError(task.taskId), recoverable: false };
+            yield { type: 'done', content: '', usage: totalUsage, steps: 1, durationMs: Date.now() - startTime };
+            return;
+        }
+        yield { type: 'text-delta', content: `[Orchestrate] Winner: ${winner.id}\n` };
+        // Check mitosis
+        if (this.lifecycle.shouldMitosis(winner, task)) {
+            yield { type: 'text-delta', content: '[Orchestrate] Mitosis triggered\n' };
+            try {
+                const result = await this.lifecycle.mitosis(winner, task, this.planner, this.cluster, this.rewardBus, this.agentFactory, { task, objective: input, domainHints: [task.domain] }, this.runtime);
+                totalUsage.totalTokens += result.tokenCost;
+                yield { type: 'text-delta', content: result.content };
+                yield { type: 'step-end', step: 0, reason: 'complete' };
+                yield { type: 'done', content: result.content, usage: totalUsage, steps: 1, durationMs: Date.now() - startTime };
+            }
+            catch (err) {
+                const me = new MitosisError(winner.id, 'Mitosis failed', err instanceof Error ? err : undefined);
+                yield { type: 'error', error: me, recoverable: true };
+                yield { type: 'done', content: '', usage: totalUsage, steps: 1, durationMs: Date.now() - startTime };
+            }
+            return;
+        }
+        // Direct execution
+        winner.status = 'busy';
+        const start = Date.now();
+        const done = await winner.agent.run(input);
+        const result = {
+            taskId: task.taskId, agentId: winner.id, content: done.content,
+            success: true, tokenCost: done.usage.totalTokens, errorCount: 0, durationMs: Date.now() - start,
+        };
+        await this.rewardBus.evaluate(winner, task, result);
+        winner.status = 'idle';
+        winner.lastActiveAt = Date.now();
+        yield { type: 'step-end', step: 0, reason: 'complete' };
+        yield { type: 'text-delta', content: done.content };
+        yield { type: 'done', content: done.content, usage: done.usage, steps: 1, durationMs: Date.now() - startTime };
+    }
+}

package/dist/plan-strategy.d.ts

@@ -0,0 +1,9 @@
+import type { AgentEvent } from '@loom-node/core';
+import type { LoopStrategy, LoopContext } from '@loom-node/core';
+import type { TaskPlanner } from './planner.js';
+export declare class PlanStrategy implements LoopStrategy {
+    private planner;
+    readonly name = "plan";
+    constructor(planner: TaskPlanner);
+    execute(ctx: LoopContext): AsyncGenerator<AgentEvent>;
+}

package/dist/plan-strategy.js

@@ -0,0 +1,39 @@
+export class PlanStrategy {
+    planner;
+    name = 'plan';
+    constructor(planner) {
+        this.planner = planner;
+    }
+    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 : '';
+        yield { type: 'step-start', step: 0, totalSteps: 3 };
+        // Step 1: Decompose
+        const task = { taskId: `plan-${Date.now()}`, domain: 'general', description: input, estimatedComplexity: 0.7, priority: 'normal' };
+        const subtasks = await this.planner.decompose(task);
+        yield { type: 'text-delta', content: `[Plan] Decomposed into ${subtasks.length} subtasks\n` };
+        yield { type: 'step-end', step: 0, reason: 'complete' };
+        // Step 2: Execute DAG
+        yield { type: 'step-start', step: 1, totalSteps: 3 };
+        const results = await this.planner.executeDAG(subtasks, async (sub) => {
+            const res = await ctx.provider.complete({ messages: [...ctx.messages, { role: 'user', content: sub.description }] });
+            accUsage(totalUsage, res.usage);
+            return { taskId: sub.id, agentId: 'self', content: res.content, success: true, tokenCost: res.usage.totalTokens, errorCount: 0, durationMs: 0 };
+        });
+        yield { type: 'step-end', step: 1, reason: 'complete' };
+        // Step 3: Aggregate
+        yield { type: 'step-start', step: 2, totalSteps: 3 };
+        const content = await this.planner.aggregate(task, results);
+        yield { type: 'text-delta', content };
+        yield { type: 'step-end', step: 2, reason: 'complete' };
+        yield { type: 'done', content, usage: totalUsage, steps: 3, durationMs: Date.now() - startTime };
+    }
+}
+function accUsage(t, d) {
+    t.promptTokens += d.promptTokens;
+    t.completionTokens += d.completionTokens;
+    t.totalTokens += d.totalTokens;
+}

package/dist/planner.d.ts

@@ -0,0 +1,14 @@
+import type { LLMProvider, SubTask, TaskAd, TaskResult } from '@loom-node/core';
+export interface PlannerConfig {
+    llm: LLMProvider;
+    maxSubTasks: number;
+    aggregation: 'llm' | 'concat';
+}
+export declare class TaskPlanner {
+    private readonly config;
+    constructor(config: Pick<PlannerConfig, 'llm'> & Partial<PlannerConfig>);
+    decompose(task: TaskAd): Promise<SubTask[]>;
+    executeDAG(subtasks: SubTask[], executor: (sub: SubTask) => Promise<TaskResult>): Promise<TaskResult[]>;
+    aggregate(task: TaskAd, results: TaskResult[]): Promise<string>;
+    private parseSubTasks;
+}

package/dist/planner.js

@@ -0,0 +1,64 @@
+const DEFAULT_CONFIG = {
+    maxSubTasks: 6,
+    aggregation: 'llm',
+};
+export class TaskPlanner {
+    config;
+    constructor(config) {
+        this.config = { ...DEFAULT_CONFIG, ...config };
+    }
+    async decompose(task) {
+        const result = await this.config.llm.complete({
+            messages: [
+                { role: 'system', content: DECOMPOSE_PROMPT },
+                { role: 'user', content: `Task: ${task.description}\nDomain: ${task.domain}\nComplexity: ${task.estimatedComplexity}` },
+            ],
+            temperature: 0.2,
+        });
+        return this.parseSubTasks(result.content, task.taskId);
+    }
+    async executeDAG(subtasks, executor) {
+        const done = new Map();
+        const pending = new Set(subtasks.map(s => s.id));
+        while (pending.size > 0) {
+            const ready = subtasks.filter(s => pending.has(s.id) && s.dependencies.every(d => done.has(d)));
+            if (ready.length === 0)
+                throw new Error('Cycle detected in subtask DAG');
+            const results = await Promise.all(ready.map(s => executor(s)));
+            for (let i = 0; i < ready.length; i++) {
+                done.set(ready[i].id, results[i]);
+                pending.delete(ready[i].id);
+            }
+        }
+        return subtasks.map(s => done.get(s.id));
+    }
+    async aggregate(task, results) {
+        if (this.config.aggregation === 'concat') {
+            return results.map(r => r.content).join('\n\n');
+        }
+        const summary = results.map((r, i) => `[SubTask ${i + 1}] ${r.success ? '✓' : '✗'}\n${r.content}`).join('\n---\n');
+        const res = await this.config.llm.complete({
+            messages: [
+                { role: 'system', content: 'Synthesize the sub-task results into a coherent final answer.' },
+                { role: 'user', content: `Original task: ${task.description}\n\nResults:\n${summary}` },
+            ],
+        });
+        return res.content;
+    }
+    parseSubTasks(raw, parentTaskId) {
+        const match = raw.match(/\[[\s\S]*\]/);
+        if (!match)
+            return [];
+        const arr = JSON.parse(match[0]);
+        return arr.slice(0, this.config.maxSubTasks).map((item, i) => ({
+            id: item.id ?? `${parentTaskId}-sub-${i}`,
+            parentTaskId,
+            description: item.description,
+            domain: item.domain ?? 'general',
+            dependencies: item.dependencies ?? [],
+        }));
+    }
+}
+const DECOMPOSE_PROMPT = `You are a task planner. Decompose the given task into independent sub-tasks.
+Output a JSON array where each element has: id, description, domain, dependencies (array of other sub-task ids).
+Minimize dependencies to maximize parallelism. Output ONLY the JSON array.`;

package/dist/reward-bus.d.ts

@@ -0,0 +1,28 @@
+import type { AgentNode, TaskAd, TaskResult, RewardSignal } from '@loom-node/core';
+export interface RewardConfig {
+    strategy: 'rule' | 'hybrid';
+    llmJudgeInterval: number;
+    weights: {
+        quality: number;
+        efficiency: number;
+        reliability: number;
+    };
+    ema: {
+        alpha: number;
+        decayRate: number;
+    };
+}
+export declare class RewardBus {
+    private readonly config;
+    private evalCount;
+    private bias;
+    private llmJudge?;
+    constructor(config?: Partial<RewardConfig>);
+    setLLMJudge(judge: (task: TaskAd, result: TaskResult) => Promise<RewardSignal>): void;
+    evaluate(node: AgentNode, task: TaskAd, result: TaskResult): Promise<number>;
+    decayInactive(node: AgentNode): void;
+    private computeSignal;
+    private ruleSignal;
+    private computeReward;
+    private updateCapability;
+}