@loom-node/amoeba 0.1.0 → 0.1.1

package/dist/amoeba-loop.d.ts

@@ -25,11 +25,13 @@ export declare class AmoebaLoop implements LoopStrategy {
     private calibrationMap;
     constructor(config: AmoebaLoopConfig);
     execute(ctx: LoopContext): AsyncGenerator<AgentEvent>;
-    private sense;
-    private heuristicComplexity;
-    private llmComplexity;
-    private detectDomains;
-    private match;
+    private senseAndMatch;
+    /** Collect name+description from loaded nodes and unloaded catalog */
+    private collectSkillDescriptions;
+    /** Single LLM call: estimate complexity + select best skill */
+    private llmSenseAndMatch;
+    /** Resolve a skill name to a loaded node, lazy-loading if needed */
+    private resolveSkillNode;
     private scaleAndExecute;
     private buildEnrichedPrompt;
     private evaluateAndAdapt;

package/dist/amoeba-loop.js

@@ -13,17 +13,15 @@ export class AmoebaLoop {
         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);
+        // Phase 1+2: SENSE + MATCH (combined LLM semantic selection, à la Claude Code progressive disclosure)
+        const { spec, winner } = await this.senseAndMatch(input);
+        yield { type: 'text-delta', content: `complexity=${spec.task.estimatedComplexity.toFixed(2)} domains=${spec.domainHints.join(',')} ` };
         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` };
+        yield { type: 'text-delta', content: `winner=${winner.id} ` };
         // Phase 3+4: SCALE + EXECUTE
         const result = await this.scaleAndExecute(winner, spec, input);
         totalUsage.totalTokens += result.tokenCost;
@@ -33,105 +31,86 @@ export class AmoebaLoop {
         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,
+    // ── Phase 1+2: SENSE + MATCH (Claude Code-style LLM semantic selection) ──
+    async senseAndMatch(input) {
+        // Collect all available skill descriptions (progressive disclosure L1: name + description)
+        const skillDescriptions = this.collectSkillDescriptions();
+        const { complexity, selectedSkill, domains } = await this.llmSenseAndMatch(input, skillDescriptions);
+        const calibrated = this.calibrate({ score: complexity, domains, method: 'llm' });
+        const spec = {
+            task: {
+                taskId: `amoeba-${Date.now()}`,
+                domain: selectedSkill ?? 'general',
+                description: input,
+                estimatedComplexity: calibrated.score,
+                priority: 'normal',
+                tokenBudget: calibrated.score < 0.4 ? 2048 : calibrated.score < 0.7 ? 4096 : 8192,
+            },
+            objective: input,
+            domainHints: calibrated.domains,
         };
-        return { task, objective: input, domainHints: calibrated.domains };
+        // Find or load the selected skill node
+        const winner = selectedSkill ? this.resolveSkillNode(selectedSkill) : this.config.cluster.findIdle();
+        return { spec, winner };
     }
-    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' };
+    /** Collect name+description from loaded nodes and unloaded catalog */
+    collectSkillDescriptions() {
+        const fromNodes = [...this.config.cluster.nodes.values()]
+            .filter(n => n.id.startsWith('skill:'))
+            .map(n => {
+            const skillName = n.id.replace('skill:', '');
+            const skill = this.config.skillRegistry.get(skillName);
+            return { name: skillName, description: skill?.description ?? skillName };
+        });
+        const loadedNames = new Set(fromNodes.map(n => n.name));
+        const fromCatalog = this.config.skillRegistry.describeAll()
+            .filter(s => !loadedNames.has(s.name));
+        return [...fromNodes, ...fromCatalog];
     }
-    async llmComplexity(input) {
+    /** Single LLM call: estimate complexity + select best skill */
+    async llmSenseAndMatch(input, skills) {
+        const skillList = skills.map(s => `- ${s.name}: ${s.description}`).join('\n');
         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}`,
+                        content: `You are a task router. Given available skills and a task, select the BEST skill and assess complexity.\n\nAvailable skills:\n${skillList}\n\nReply ONLY with JSON: {"skill":"<name>","complexity":0.0-1.0,"domains":["..."]}\n\nTask: ${input}`,
                     }],
                 temperature: 0,
                 maxTokens: 128,
             });
-            const match = result.content.match(/\{[\s\S]*\}/);
-            if (match) {
-                const obj = JSON.parse(match[0]);
+            const m = result.content.match(/\{[\s\S]*\}/);
+            if (m) {
+                const obj = JSON.parse(m[0]);
+                const name = typeof obj.skill === 'string' ? obj.skill.trim().toLowerCase() : null;
+                const matched = skills.find(s => s.name === name);
                 return {
-                    score: Math.max(0, Math.min(1, obj.score ?? 0.5)),
+                    complexity: Math.max(0, Math.min(1, obj.complexity ?? 0.5)),
+                    selectedSkill: matched?.name ?? null,
                     domains: obj.domains ?? ['general'],
-                    reasoning: obj.reasoning,
-                    method: 'llm',
                 };
             }
         }
         catch { /* fall through */ }
-        return this.heuristicComplexity(input);
+        return { complexity: 0.5, selectedSkill: skills[0]?.name ?? null, domains: ['general'] };
     }
-    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 */ }
+    /** Resolve a skill name to a loaded node, lazy-loading if needed */
+    resolveSkillNode(skillName) {
+        const nodeId = `skill:${skillName}`;
+        const existing = this.config.cluster.nodes.get(nodeId);
+        if (existing && existing.status !== 'dying')
+            return existing;
+        // Lazy load from catalog
+        const skill = this.config.skillRegistry.get(skillName);
+        if (skill) {
+            if (this.config.runtime)
+                return this.config.runtime.loadSkill(skill);
+            const node = skillToNode(skill, this.config.llm);
+            this.config.cluster.addNode(node);
+            this.config.skillRegistry.markLoaded(skill.name);
+            return node;
         }
-        return { winner: undefined, tier: 1 };
+        return undefined;
     }
     // ── Phase 3+4: SCALE + EXECUTE ──
     async scaleAndExecute(winner, spec, input) {

package/dist/skill-registry.d.ts

@@ -13,6 +13,11 @@ export declare class SkillNodeRegistry {
     get(name: string): Skill | undefined;
     /** Find best matching unloaded skill for a task description */
     findMatch(input: string, minScore?: number): Promise<SkillActivation | undefined>;
+    /** Return name+description of ALL skills (for LLM semantic matching) */
+    describeAll(): {
+        name: string;
+        description: string;
+    }[];
     get size(): number;
     get unloadedCount(): number;
 }

package/dist/skill-registry.js

@@ -36,6 +36,10 @@ export class SkillNodeRegistry {
         candidates.sort((a, b) => b.score - a.score);
         return candidates[0];
     }
+    /** Return name+description of ALL skills (for LLM semantic matching) */
+    describeAll() {
+        return [...this.catalog.values()].map(s => ({ name: s.name, description: s.description }));
+    }
     get size() { return this.catalog.size; }
     get unloadedCount() { return this.catalog.size - this.loaded.size; }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@loom-node/amoeba",
-  "version": "0.1.0",
+  "version": "0.1.1",
   "type": "module",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -18,7 +18,7 @@
   },
   "license": "MIT",
   "dependencies": {
-    "@loom-node/core": "0.1.0"
+    "@loom-node/core": "0.1.1"
   },
   "scripts": {
     "build": "tsc -b",