simmer-automaton 0.1.5 → 0.2.0

package/dist/api.d.ts

@@ -19,10 +19,7 @@ export interface Skill {
     category: string;
     tags: string[];
     difficulty: string;
-    install: string;
-    clawhub_url: string;
-    requires: string[];
-    best_when: string | null;
+    enabled: boolean;
 }
 export declare class SimmerApi {
     private baseUrl;
@@ -37,4 +34,35 @@ export declare class SimmerApi {
         skills: Skill[];
         total: number;
     }>;
+    getAutomatonSkills(): Promise<{
+        skills: Skill[];
+        total: number;
+    }>;
+    disableSkill(slug: string): Promise<unknown>;
+    enableSkill(slug: string): Promise<unknown>;
+    recordCycle(data: {
+        cycle_num: number;
+        tier: string;
+        epsilon: number;
+        selected_skills: Array<{
+            slug: string;
+            reason: string;
+            score: number | null;
+        }>;
+        tuning_hints: Array<{
+            skill: string;
+            issue: string;
+            suggestion: string;
+        }>;
+        budget_usd?: number;
+        spent_usd?: number;
+    }): Promise<{
+        id: number;
+        cycle_num: number;
+        created_at: string;
+    }>;
+    getCycles(limit?: number, since?: string): Promise<{
+        cycles: Array<Record<string, unknown>>;
+        total: number;
+    }>;
 }

package/dist/api.js

@@ -42,4 +42,22 @@ export class SimmerApi {
     async getSkills() {
         return this.request("/api/sdk/skills");
     }
+    async getAutomatonSkills() {
+        return this.request("/api/sdk/automaton/skills");
+    }
+    async disableSkill(slug) {
+        return this.request(`/api/sdk/automaton/skills/${encodeURIComponent(slug)}/disable`, { method: "POST" });
+    }
+    async enableSkill(slug) {
+        return this.request(`/api/sdk/automaton/skills/${encodeURIComponent(slug)}/enable`, { method: "POST" });
+    }
+    async recordCycle(data) {
+        return this.request("/api/sdk/automaton/cycles", { method: "POST", body: JSON.stringify(data) });
+    }
+    async getCycles(limit = 20, since) {
+        const params = new URLSearchParams({ limit: String(limit) });
+        if (since)
+            params.set("since", since);
+        return this.request(`/api/sdk/automaton/cycles?${params}`);
+    }
 }

package/dist/index.js

@@ -53,8 +53,16 @@ function loadConfig(pluginConfig) {
 async function refreshState(logger) {
     try {
         cachedState = await api.getAutomatonState();
-        const skillsRes = await api.getSkills();
-        cachedSkills = skillsRes.skills;
+        // Use automaton skills endpoint (respects per-user enable/disable prefs)
+        try {
+            const res = await api.getAutomatonSkills();
+            cachedSkills = res.skills;
+        }
+        catch {
+            // Fall back to generic skills endpoint if automaton endpoint not available
+            const res = await api.getSkills();
+            cachedSkills = res.skills;
+        }
         if (cachedState.initialized) {
             // Compute tier (totalPnl = 0 for now, will be enriched when P&L tracking is added)
             currentTier = computeTier(cachedState, 0);
@@ -166,7 +174,21 @@ export default function register(pluginApi) {
                 await refreshState(ctx.logger);
                 // Decay epsilon
                 config.epsilon = Math.max(config.minEpsilon, config.epsilon * config.epsilonDecay);
-                ctx.logger.info(`[simmer] Cycle ${cycleCount} | tier=${currentTier} | ε=${config.epsilon.toFixed(3)} | skills=${cachedSkills.length}`);
+                // Select skills and generate hints for this cycle
+                const n = tierMaxSkills(currentTier, config.maxConcurrent);
+                const { selected, meta } = selectSkills(banditState, n, currentTier, config.epsilon);
+                const hints = generateTuningHints(banditState, cachedState?.budget_usd ?? 0);
+                // Record cycle to API (fire-and-forget — don't block the loop)
+                api.recordCycle({
+                    cycle_num: cycleCount,
+                    tier: currentTier,
+                    epsilon: parseFloat(config.epsilon.toFixed(4)),
+                    selected_skills: meta.map((m) => ({ slug: m.slug, reason: m.reason, score: m.score })),
+                    tuning_hints: hints,
+                    budget_usd: cachedState?.budget_usd,
+                    spent_usd: cachedState?.spent_usd,
+                }).catch((e) => ctx.logger.error(`[simmer] Failed to record cycle: ${e}`));
+                ctx.logger.info(`[simmer] Cycle ${cycleCount} | tier=${currentTier} | ε=${config.epsilon.toFixed(3)} | selected=${selected.length} skills`);
             }, config.cycleIntervalMs);
         },
         stop: async (ctx) => {
@@ -214,11 +236,64 @@ export default function register(pluginApi) {
                 if (cachedSkills.length === 0) {
                     return { text: "No skills in registry." };
                 }
-                const lines = cachedSkills.map((s) => `- ${s.name} (${s.id}) — ${s.category}, ${s.difficulty}`);
+                const lines = cachedSkills.map((s) => {
+                    const status = s.enabled === false ? " [DISABLED]" : "";
+                    return `- ${s.name} (${s.id}) — ${s.category}, ${s.difficulty}${status}`;
+                });
                 return { text: `Skills (${cachedSkills.length}):\n${lines.join("\n")}` };
             }
+            if (subcommand === "disable") {
+                const slug = ctx.args?.trim().split(/\s+/)[1];
+                if (!slug) {
+                    return { text: "Usage: /simmer disable <skill-slug>" };
+                }
+                try {
+                    await api.disableSkill(slug);
+                    await refreshState(logger);
+                    return { text: `Disabled skill: ${slug}. It won't be selected by the automaton.` };
+                }
+                catch (e) {
+                    return { text: `Failed to disable: ${e}` };
+                }
+            }
+            if (subcommand === "enable") {
+                const slug = ctx.args?.trim().split(/\s+/)[1];
+                if (!slug) {
+                    return { text: "Usage: /simmer enable <skill-slug>" };
+                }
+                try {
+                    await api.enableSkill(slug);
+                    await refreshState(logger);
+                    return { text: `Enabled skill: ${slug}. It will be included in the automaton's skill pool.` };
+                }
+                catch (e) {
+                    return { text: `Failed to enable: ${e}` };
+                }
+            }
+            if (subcommand === "history") {
+                const limitArg = ctx.args?.trim().split(/\s+/)[1];
+                const limit = limitArg ? Math.min(parseInt(limitArg, 10) || 10, 50) : 10;
+                try {
+                    const res = await api.getCycles(limit);
+                    if (res.cycles.length === 0) {
+                        return { text: "No cycle history yet. Cycles are recorded once the automaton starts running." };
+                    }
+                    const lines = res.cycles.map((c) => {
+                        const skills = c.selected_skills || [];
+                        const skillStr = skills.length > 0
+                            ? skills.map((s) => `${s.slug} (${s.reason})`).join(", ")
+                            : "none";
+                        const eps = typeof c.epsilon === "number" ? c.epsilon.toFixed(3) : "?";
+                        return `#${c.cycle_num} | ${c.tier} | ε=${eps} | skills=[${skillStr}] | budget=${c.budget_usd ?? "?"}/${c.spent_usd ?? "?"} | ${c.created_at}`;
+                    });
+                    return { text: `Last ${res.cycles.length} cycles:\n${lines.join("\n")}` };
+                }
+                catch (e) {
+                    return { text: `Failed to fetch history: ${e}` };
+                }
+            }
             return {
-                text: "Usage: /simmer [status|halt|resume|skills]",
+                text: "Usage: /simmer [status|halt|resume|skills|history [N]|disable <slug>|enable <slug>]",
             };
         },
     });

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "simmer-automaton",
-  "version": "0.1.5",
-  "description": "Simmer Automaton plugin for OpenClaw — adaptive trading skill orchestration",
+  "version": "0.2.0",
+  "description": "Simmer Automaton plugin for OpenClaw — autonomous trading skill orchestration",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
   "scripts": {

package/src/api.ts

@@ -21,10 +21,7 @@ export interface Skill {
   category: string;
   tags: string[];
   difficulty: string;
-  install: string;
-  clawhub_url: string;
-  requires: string[];
-  best_when: string | null;
+  enabled: boolean;
 }
 
 export class SimmerApi {
@@ -74,4 +71,37 @@ export class SimmerApi {
   async getSkills(): Promise<{ skills: Skill[]; total: number }> {
     return this.request("/api/sdk/skills");
   }
+
+  async getAutomatonSkills(): Promise<{ skills: Skill[]; total: number }> {
+    return this.request("/api/sdk/automaton/skills");
+  }
+
+  async disableSkill(slug: string) {
+    return this.request(`/api/sdk/automaton/skills/${encodeURIComponent(slug)}/disable`, { method: "POST" });
+  }
+
+  async enableSkill(slug: string) {
+    return this.request(`/api/sdk/automaton/skills/${encodeURIComponent(slug)}/enable`, { method: "POST" });
+  }
+
+  async recordCycle(data: {
+    cycle_num: number;
+    tier: string;
+    epsilon: number;
+    selected_skills: Array<{ slug: string; reason: string; score: number | null }>;
+    tuning_hints: Array<{ skill: string; issue: string; suggestion: string }>;
+    budget_usd?: number;
+    spent_usd?: number;
+  }) {
+    return this.request<{ id: number; cycle_num: number; created_at: string }>(
+      "/api/sdk/automaton/cycles",
+      { method: "POST", body: JSON.stringify(data) },
+    );
+  }
+
+  async getCycles(limit = 20, since?: string): Promise<{ cycles: Array<Record<string, unknown>>; total: number }> {
+    const params = new URLSearchParams({ limit: String(limit) });
+    if (since) params.set("since", since);
+    return this.request(`/api/sdk/automaton/cycles?${params}`);
+  }
 }

package/src/index.ts

@@ -68,8 +68,15 @@ function loadConfig(pluginConfig?: Record<string, unknown>) {
 async function refreshState(logger: { info: (m: string) => void; error: (m: string) => void }) {
   try {
     cachedState = await api.getAutomatonState();
-    const skillsRes = await api.getSkills();
-    cachedSkills = skillsRes.skills;
+    // Use automaton skills endpoint (respects per-user enable/disable prefs)
+    try {
+      const res = await api.getAutomatonSkills();
+      cachedSkills = res.skills;
+    } catch {
+      // Fall back to generic skills endpoint if automaton endpoint not available
+      const res = await api.getSkills();
+      cachedSkills = res.skills;
+    }
 
     if (cachedState.initialized) {
       // Compute tier (totalPnl = 0 for now, will be enriched when P&L tracking is added)
@@ -202,8 +209,24 @@ export default function register(pluginApi: PluginApi) {
           config.epsilon * config.epsilonDecay,
         );
 
+        // Select skills and generate hints for this cycle
+        const n = tierMaxSkills(currentTier, config.maxConcurrent);
+        const { selected, meta } = selectSkills(banditState, n, currentTier, config.epsilon);
+        const hints = generateTuningHints(banditState, cachedState?.budget_usd ?? 0);
+
+        // Record cycle to API (fire-and-forget — don't block the loop)
+        api.recordCycle({
+          cycle_num: cycleCount,
+          tier: currentTier,
+          epsilon: parseFloat(config.epsilon.toFixed(4)),
+          selected_skills: meta.map((m) => ({ slug: m.slug, reason: m.reason, score: m.score })),
+          tuning_hints: hints,
+          budget_usd: cachedState?.budget_usd,
+          spent_usd: cachedState?.spent_usd,
+        }).catch((e) => ctx.logger.error(`[simmer] Failed to record cycle: ${e}`));
+
         ctx.logger.info(
-          `[simmer] Cycle ${cycleCount} | tier=${currentTier} | ε=${config.epsilon.toFixed(3)} | skills=${cachedSkills.length}`,
+          `[simmer] Cycle ${cycleCount} | tier=${currentTier} | ε=${config.epsilon.toFixed(3)} | selected=${selected.length} skills`,
         );
       }, config.cycleIntervalMs);
     },
@@ -257,13 +280,66 @@ export default function register(pluginApi: PluginApi) {
           return { text: "No skills in registry." };
         }
         const lines = cachedSkills.map(
-          (s) => `- ${s.name} (${s.id}) — ${s.category}, ${s.difficulty}`,
+          (s) => {
+            const status = (s as any).enabled === false ? " [DISABLED]" : "";
+            return `- ${s.name} (${s.id}) — ${s.category}, ${s.difficulty}${status}`;
+          },
         );
         return { text: `Skills (${cachedSkills.length}):\n${lines.join("\n")}` };
       }
 
+      if (subcommand === "disable") {
+        const slug = ctx.args?.trim().split(/\s+/)[1];
+        if (!slug) {
+          return { text: "Usage: /simmer disable <skill-slug>" };
+        }
+        try {
+          await api.disableSkill(slug);
+          await refreshState(logger);
+          return { text: `Disabled skill: ${slug}. It won't be selected by the automaton.` };
+        } catch (e) {
+          return { text: `Failed to disable: ${e}` };
+        }
+      }
+
+      if (subcommand === "enable") {
+        const slug = ctx.args?.trim().split(/\s+/)[1];
+        if (!slug) {
+          return { text: "Usage: /simmer enable <skill-slug>" };
+        }
+        try {
+          await api.enableSkill(slug);
+          await refreshState(logger);
+          return { text: `Enabled skill: ${slug}. It will be included in the automaton's skill pool.` };
+        } catch (e) {
+          return { text: `Failed to enable: ${e}` };
+        }
+      }
+
+      if (subcommand === "history") {
+        const limitArg = ctx.args?.trim().split(/\s+/)[1];
+        const limit = limitArg ? Math.min(parseInt(limitArg, 10) || 10, 50) : 10;
+        try {
+          const res = await api.getCycles(limit);
+          if (res.cycles.length === 0) {
+            return { text: "No cycle history yet. Cycles are recorded once the automaton starts running." };
+          }
+          const lines = res.cycles.map((c: Record<string, unknown>) => {
+            const skills = (c.selected_skills as Array<{ slug: string; reason: string }>) || [];
+            const skillStr = skills.length > 0
+              ? skills.map((s) => `${s.slug} (${s.reason})`).join(", ")
+              : "none";
+            const eps = typeof c.epsilon === "number" ? c.epsilon.toFixed(3) : "?";
+            return `#${c.cycle_num} | ${c.tier} | ε=${eps} | skills=[${skillStr}] | budget=${c.budget_usd ?? "?"}/${c.spent_usd ?? "?"} | ${c.created_at}`;
+          });
+          return { text: `Last ${res.cycles.length} cycles:\n${lines.join("\n")}` };
+        } catch (e) {
+          return { text: `Failed to fetch history: ${e}` };
+        }
+      }
+
       return {
-        text: "Usage: /simmer [status|halt|resume|skills]",
+        text: "Usage: /simmer [status|halt|resume|skills|history [N]|disable <slug>|enable <slug>]",
       };
     },
   });