simmer-automaton 0.3.1 → 0.4.0

package/dist/api.d.ts

@@ -10,8 +10,18 @@ export interface AutomatonState {
     halted: boolean;
     tier: string;
     horizon_days: number;
+    venue: string;
     started_at: string | null;
 }
+export interface Tunable {
+    env: string;
+    type: "number" | "string" | "boolean" | "enum";
+    default: number | string | boolean;
+    label: string;
+    range?: [number, number];
+    step?: number;
+    options?: string[];
+}
 export interface Skill {
     id: string;
     name: string;
@@ -20,6 +30,16 @@ export interface Skill {
     tags: string[];
     difficulty: string;
     enabled: boolean;
+    entrypoint?: string;
+    tunables?: Tunable[];
+    config?: Record<string, number | string | boolean>;
+    pinned?: string[];
+}
+export interface SkillOutcome {
+    skill_slug: string;
+    trades: number;
+    total_cost: number;
+    period_pnl: number;
 }
 export declare class SimmerApi {
     private baseUrl;
@@ -65,4 +85,9 @@ export declare class SimmerApi {
         cycles: Array<Record<string, unknown>>;
         total: number;
     }>;
+    setSkillConfig(slug: string, config: Record<string, number | string | boolean | string[]>): Promise<unknown>;
+    getOutcomes(since: string): Promise<{
+        outcomes: SkillOutcome[];
+        since: string;
+    }>;
 }

package/dist/api.js

@@ -60,4 +60,14 @@ export class SimmerApi {
             params.set("since", since);
         return this.request(`/api/sdk/automaton/cycles?${params}`);
     }
+    async setSkillConfig(slug, config) {
+        return this.request(`/api/sdk/automaton/skills/${encodeURIComponent(slug)}/config`, {
+            method: "POST",
+            body: JSON.stringify(config),
+        });
+    }
+    async getOutcomes(since) {
+        const params = new URLSearchParams({ since });
+        return this.request(`/api/sdk/automaton/outcomes?${params}`);
+    }
 }

package/dist/index.js

@@ -9,7 +9,7 @@
 import { SimmerApi } from "./api.js";
 import { selectSkills, tierMaxSkills } from "./bandit.js";
 import { computeTier } from "./tiers.js";
-import { generateTuningHints } from "./tuning.js";
+import { generateTuningHints, computeTuningChanges } from "./tuning.js";
 // Plugin-local state (in-memory, refreshed from API each cycle)
 let api;
 let cachedState = null;
@@ -21,6 +21,7 @@ let lastPromptCycle = -1; // Track which cycle was last issued to prevent re-run
 let currentSelectedMeta = [];
 let serviceRunning = false;
 let cycleTimer = null;
+let lastCycleTimestamp = new Date().toISOString();
 // Config defaults
 let config = {
     apiKey: "",
@@ -66,6 +67,10 @@ async function refreshState(logger) {
             cachedSkills = res.skills;
         }
         if (cachedState.initialized) {
+            // Sync venue from server state (source of truth — server enforces it)
+            if (cachedState.venue) {
+                config.venue = cachedState.venue;
+            }
             // Compute tier (totalPnl = 0 for now, will be enriched when P&L tracking is added)
             currentTier = computeTier(cachedState, 0);
             // Sync banditState from fetched skills — preserve memory for existing, seed new ones
@@ -130,10 +135,22 @@ function buildPromptContext() {
         lastPromptCycle = cycleCount;
         lines.push(`## Simmer Automaton — Cycle ${cycleCount}`);
         lines.push("");
-        const venueFlag = config.venue !== "simmer" ? ` TRADING_VENUE=${config.venue}` : "";
-        lines.push(`**ACTION: Run these skills now.**${venueFlag ? ` Set env:${venueFlag}` : ""} Use --live --quiet flags.`);
+        lines.push("**ACTION: Run these skills now** (copy-paste each command):");
+        lines.push("");
+        // Build slug → entrypoint map from cachedSkills
+        const entrypointMap = new Map(cachedSkills.map((s) => [s.id, s.entrypoint]));
         for (const m of currentSelectedMeta) {
-            lines.push(`- ${m.slug}`);
+            const entrypoint = entrypointMap.get(m.slug);
+            if (entrypoint) {
+                const skillConfig = cachedSkills.find((s) => s.id === m.slug)?.config || {};
+                const envVars = Object.entries(skillConfig).map(([k, v]) => `${k}=${v}`).join(" ");
+                const envPrefix = envVars ? `${envVars} ` : "";
+                lines.push(`- \`TRADING_VENUE=${config.venue} ${envPrefix}python ${entrypoint} --live --quiet\``);
+            }
+            else {
+                // No entrypoint in registry — bot should find the script from SKILL.md
+                lines.push(`- ${m.slug} (check SKILL.md for entrypoint)`);
+            }
         }
         lines.push("");
         lines.push("After running each skill, briefly note: trades executed, signals found, or why it was skipped.");
@@ -166,6 +183,8 @@ function buildPromptContext() {
     // --- Instructions for human-facing queries ---
     lines.push("");
     lines.push("**When your human asks about the automaton:** Report tier, budget, burn rate, which skills are running, and any tuning hints. Use `/simmer history` for recent cycle decisions. Don't dump raw data — summarize.");
+    lines.push("");
+    lines.push("**Currency formatting:** $SIM amounts must be written as `XXX $SIM` (e.g. `25.00 $SIM`, `100.00 $SIM`). NEVER write `$SIM25` or `$SIMxx` — the `$SIM` suffix goes AFTER the number. Real USDC uses `$` prefix (e.g. `$25.00`).");
     return lines.join("\n");
 }
 function formatStatus() {
@@ -221,7 +240,52 @@ export default function register(pluginApi) {
                 if (!serviceRunning)
                     return;
                 cycleCount++;
+                const cycleStarted = lastCycleTimestamp;
+                lastCycleTimestamp = new Date().toISOString();
                 await refreshState(ctx.logger);
+                // Query outcomes since last cycle and update bandit reward data
+                try {
+                    const outcomeRes = await api.getOutcomes(cycleStarted);
+                    for (const o of outcomeRes.outcomes) {
+                        const skill = banditState.find((s) => s.slug === o.skill_slug);
+                        if (skill) {
+                            skill.tradesExecutedTotal += o.trades;
+                            skill.timesRewarded += o.trades > 0 ? 1 : 0;
+                            skill.totalPnl += o.period_pnl;
+                            skill.consecutiveZeroSignals = o.trades > 0 ? 0 : skill.consecutiveZeroSignals + 1;
+                        }
+                    }
+                    if (outcomeRes.outcomes.length > 0) {
+                        ctx.logger.info(`[simmer] Outcomes: ${outcomeRes.outcomes.map((o) => `${o.skill_slug}:${o.trades}t`).join(", ")}`);
+                    }
+                }
+                catch (e) {
+                    ctx.logger.error(`[simmer] Failed to fetch outcomes: ${e}`);
+                }
+                // Apply deterministic tuning
+                let tuningChanges = [];
+                if (cycleCount >= 5) {
+                    const tunableSkills = cachedSkills
+                        .filter((s) => s.tunables && s.tunables.length > 0)
+                        .map((s) => ({
+                        slug: s.id,
+                        tunables: s.tunables,
+                        config: s.config || {},
+                        pinned: s.pinned || [],
+                    }));
+                    tuningChanges = computeTuningChanges(banditState, tunableSkills, cycleCount, cachedState?.budget_usd ?? 0);
+                    for (const change of tuningChanges) {
+                        const skill = tunableSkills.find((s) => s.slug === change.slug);
+                        if (skill) {
+                            const newConfig = { ...skill.config, [change.env]: change.newValue };
+                            api.setSkillConfig(change.slug, newConfig)
+                                .catch((e) => ctx.logger.error(`[simmer] Failed to apply config: ${e}`));
+                        }
+                    }
+                    if (tuningChanges.length > 0) {
+                        ctx.logger.info(`[simmer] Tuning: ${tuningChanges.map((c) => `${c.slug}.${c.env}: ${c.oldValue} → ${c.newValue}`).join(", ")}`);
+                    }
+                }
                 // Decay epsilon
                 config.epsilon = Math.max(config.minEpsilon, config.epsilon * config.epsilonDecay);
                 // Select skills and generate hints for this cycle
@@ -230,7 +294,7 @@ export default function register(pluginApi) {
                 currentSelectedMeta = meta;
                 const hints = generateTuningHints(banditState, cachedState?.budget_usd ?? 0);
                 // Record cycle to API (fire-and-forget — don't block the loop)
-                api.recordCycle({
+                const cycleData = {
                     cycle_num: cycleCount,
                     tier: currentTier,
                     epsilon: parseFloat(config.epsilon.toFixed(4)),
@@ -238,7 +302,11 @@ export default function register(pluginApi) {
                     tuning_hints: hints,
                     budget_usd: cachedState?.budget_usd,
                     spent_usd: cachedState?.spent_usd,
-                }).catch((e) => ctx.logger.error(`[simmer] Failed to record cycle: ${e}`));
+                };
+                if (tuningChanges.length > 0) {
+                    cycleData.config_changes = tuningChanges.map((c) => ({ slug: c.slug, env: c.env, old: c.oldValue, new: c.newValue, reason: c.reason }));
+                }
+                api.recordCycle(cycleData).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);
         },
@@ -343,8 +411,75 @@ export default function register(pluginApi) {
                     return { text: `Failed to fetch history: ${e}` };
                 }
             }
+            if (subcommand === "config") {
+                const slug = ctx.args?.trim().split(/\s+/)[1];
+                if (!slug) {
+                    return { text: "Usage: /simmer config <skill-slug>" };
+                }
+                await refreshState(logger);
+                const skill = cachedSkills.find((s) => s.id === slug);
+                if (!skill) {
+                    return { text: `Skill not found: ${slug}` };
+                }
+                if (!skill.tunables || skill.tunables.length === 0) {
+                    return { text: `${slug} has no tunables.` };
+                }
+                const pinnedSet = new Set(skill.pinned || []);
+                const lines = skill.tunables.map((t) => {
+                    const cur = (skill.config || {})[t.env] ?? t.default;
+                    const isDefault = cur === t.default;
+                    const pinLabel = pinnedSet.has(t.env) ? " [PINNED]" : "";
+                    return `  ${t.env}: ${cur}${isDefault ? "" : ` (default: ${t.default})`}${pinLabel}`;
+                });
+                return { text: `${slug} config:\n${lines.join("\n")}` };
+            }
+            if (subcommand === "tune") {
+                const parts = ctx.args?.trim().split(/\s+/) || [];
+                const slug = parts[1];
+                const envVar = parts[2];
+                const rawValue = parts[3];
+                if (!slug || !envVar || rawValue === undefined) {
+                    return { text: "Usage: /simmer tune <skill-slug> <ENV_VAR> <value>" };
+                }
+                await refreshState(logger);
+                const skill = cachedSkills.find((s) => s.id === slug);
+                if (!skill) {
+                    return { text: `Skill not found: ${slug}` };
+                }
+                // Parse value — try number, then boolean, then string
+                let parsedValue = rawValue;
+                if (rawValue === "true")
+                    parsedValue = true;
+                else if (rawValue === "false")
+                    parsedValue = false;
+                else if (!isNaN(Number(rawValue)))
+                    parsedValue = Number(rawValue);
+                const currentConfig = skill.config || {};
+                const currentPinned = new Set(skill.pinned || []);
+                currentPinned.add(envVar);
+                try {
+                    await api.setSkillConfig(slug, { ...currentConfig, [envVar]: parsedValue, _pinned: [...currentPinned] });
+                    return { text: `Set ${slug} ${envVar}=${parsedValue} (pinned — automaton won't override it).` };
+                }
+                catch (e) {
+                    return { text: `Failed to set config: ${e}` };
+                }
+            }
+            if (subcommand === "reset") {
+                const slug = ctx.args?.trim().split(/\s+/)[1];
+                if (!slug) {
+                    return { text: "Usage: /simmer reset <skill-slug>" };
+                }
+                try {
+                    await api.setSkillConfig(slug, { _pinned: [] });
+                    return { text: `Reset ${slug} to defaults. All pins cleared.` };
+                }
+                catch (e) {
+                    return { text: `Failed to reset config: ${e}` };
+                }
+            }
             return {
-                text: "Usage: /simmer [status|halt|resume|skills|history [N]|disable <slug>|enable <slug>]",
+                text: "Usage: /simmer [status|halt|resume|skills|history [N]|disable <slug>|enable <slug>|config <slug>|tune <slug> <ENV> <val>|reset <slug>]",
             };
         },
     });

package/dist/tuning.d.ts

@@ -1,12 +1,29 @@
 /**
- * Tuning hints for the Clawbot LLM.
- * Ported from automaton.py — generate_tuning_hints.
+ * Tuning engine for the automaton plugin.
+ * Two layers:
+ *   1. generateTuningHints() — text hints for the LLM prompt
+ *   2. computeTuningChanges() — deterministic config changes applied via API
  */
 import type { SkillState } from "./bandit.js";
+import type { Tunable } from "./api.js";
 export interface TuningHint {
     skill: string;
     issue: string;
     suggestion: string;
     [key: string]: unknown;
 }
+export interface ConfigChange {
+    slug: string;
+    env: string;
+    oldValue: number | string | boolean;
+    newValue: number | string | boolean;
+    reason: string;
+}
+export interface TunableSkill {
+    slug: string;
+    tunables: Tunable[];
+    config: Record<string, any>;
+    pinned: string[];
+}
 export declare function generateTuningHints(skills: SkillState[], budgetUsd: number): TuningHint[];
+export declare function computeTuningChanges(skills: SkillState[], tunableSkills: TunableSkill[], cycleCount: number, budgetUsd?: number): ConfigChange[];

package/dist/tuning.js

@@ -1,13 +1,40 @@
 /**
- * Tuning hints for the Clawbot LLM.
- * Ported from automaton.py — generate_tuning_hints.
+ * Tuning engine for the automaton plugin.
+ * Two layers:
+ *   1. generateTuningHints() — text hints for the LLM prompt
+ *   2. computeTuningChanges() — deterministic config changes applied via API
  */
+// Track last tuned cycle per skill to enforce cooldowns
+const lastTunedCycle = new Map();
+function isThresholdTunable(t) {
+    const l = t.label.toLowerCase();
+    return l.includes("threshold") || l.includes("edge") || l.includes("confidence") || l.includes("min edge") || l.includes("min split");
+}
+function isMaxBetTunable(t) {
+    const l = t.label.toLowerCase();
+    return l.includes("max bet") || l.includes("max position") || l.includes("max usd");
+}
+function isMaxTradesTunable(t) {
+    return t.env.toUpperCase().includes("MAX_TRADES");
+}
+function snapToStep(value, t) {
+    if (!t.step)
+        return value;
+    return Math.round(value / t.step) * t.step;
+}
+function clampToRange(value, t) {
+    if (!t.range)
+        return value;
+    return Math.max(t.range[0], Math.min(t.range[1], value));
+}
+function currentValue(t, config) {
+    return config[t.env] ?? t.default;
+}
 export function generateTuningHints(skills, budgetUsd) {
     const hints = [];
     for (const sk of skills) {
         if (!sk.enabled || sk.timesSelected === 0)
             continue;
-        // 1. Zero signals streak
         if (sk.consecutiveZeroSignals >= 5) {
             hints.push({
                 skill: sk.slug,
@@ -16,7 +43,6 @@ export function generateTuningHints(skills, budgetUsd) {
                 suggestion: `0 signals for ${sk.consecutiveZeroSignals} cycles — loosen thresholds or widen time windows`,
             });
         }
-        // 2. Concentrated loss
         if (sk.totalPnl < 0 && budgetUsd > 0) {
             const lossPct = (Math.abs(sk.totalPnl) / budgetUsd) * 100;
             if (lossPct > 20) {
@@ -29,7 +55,6 @@ export function generateTuningHints(skills, budgetUsd) {
                 });
             }
         }
-        // 3. Inert — finds signals but never executes
         if (sk.signalsFoundTotal > 50 && sk.tradesExecutedTotal === 0) {
             hints.push({
                 skill: sk.slug,
@@ -38,7 +63,6 @@ export function generateTuningHints(skills, budgetUsd) {
                 suggestion: `${sk.signalsFoundTotal} signals found, 0 executed — execution thresholds likely too tight`,
             });
         }
-        // 4. Win rate collapse
         if (sk.timesSelected >= 10) {
             const winRate = sk.timesRewarded / sk.timesSelected;
             if (winRate < 0.2) {
@@ -51,7 +75,6 @@ export function generateTuningHints(skills, budgetUsd) {
                 });
             }
         }
-        // 5. Safeguard dominant
         const skipCounts = sk.lastCycle?.skipCounts || {};
         const totalSkips = Object.values(skipCounts).reduce((a, b) => a + b, 0);
         const safeguardSkips = skipCounts["safeguard"] || 0;
@@ -66,3 +89,103 @@ export function generateTuningHints(skills, budgetUsd) {
     }
     return hints;
 }
+export function computeTuningChanges(skills, tunableSkills, cycleCount, budgetUsd = 0) {
+    if (cycleCount < 5)
+        return [];
+    const changes = [];
+    const skillMap = new Map(skills.map((s) => [s.slug, s]));
+    for (const ts of tunableSkills) {
+        const sk = skillMap.get(ts.slug);
+        if (!sk || !sk.enabled || sk.timesSelected === 0)
+            continue;
+        let lastTuned = lastTunedCycle.get(ts.slug) ?? 0;
+        const pinnedSet = new Set(ts.pinned);
+        // Rule 1: consecutiveZeroSignals >= 5 → widen thresholds by 20% (cooldown 10)
+        if (sk.consecutiveZeroSignals >= 5 && cycleCount - lastTuned >= 10) {
+            for (const t of ts.tunables) {
+                if (t.type !== "number" || pinnedSet.has(t.env) || !isThresholdTunable(t))
+                    continue;
+                const cur = currentValue(t, ts.config);
+                if (typeof cur !== "number")
+                    continue;
+                let newVal = cur * 0.8;
+                newVal = clampToRange(newVal, t);
+                newVal = snapToStep(newVal, t);
+                if (newVal !== cur) {
+                    changes.push({ slug: ts.slug, env: t.env, oldValue: cur, newValue: newVal, reason: `zero signals for ${sk.consecutiveZeroSignals} cycles — widening threshold` });
+                    lastTunedCycle.set(ts.slug, cycleCount);
+                    lastTuned = cycleCount;
+                }
+            }
+        }
+        // Rule 2: Skill P&L < -15% of budget → halve max bet (cooldown 10)
+        if (budgetUsd > 0 && sk.totalPnl < 0 && cycleCount - lastTuned >= 10) {
+            const lossPct = (Math.abs(sk.totalPnl) / budgetUsd) * 100;
+            if (lossPct > 15) {
+                for (const t of ts.tunables) {
+                    if (t.type !== "number" || pinnedSet.has(t.env) || !isMaxBetTunable(t))
+                        continue;
+                    if (changes.some((c) => c.slug === ts.slug && c.env === t.env))
+                        continue;
+                    const cur = currentValue(t, ts.config);
+                    if (typeof cur !== "number")
+                        continue;
+                    let newVal = cur * 0.5;
+                    newVal = clampToRange(newVal, t);
+                    newVal = snapToStep(newVal, t);
+                    if (newVal !== cur) {
+                        changes.push({ slug: ts.slug, env: t.env, oldValue: cur, newValue: newVal, reason: `P&L ${sk.totalPnl.toFixed(2)} (${lossPct.toFixed(0)}% of budget) — halving max bet` });
+                        lastTunedCycle.set(ts.slug, cycleCount);
+                        lastTuned = cycleCount;
+                    }
+                }
+            }
+        }
+        // Rule 3: Win rate < 20% over last 20 cycles → reduce max trades (cooldown 15)
+        if (sk.timesSelected >= 20 && cycleCount - lastTuned >= 15) {
+            const winRate = sk.timesRewarded / sk.timesSelected;
+            if (winRate < 0.2) {
+                for (const t of ts.tunables) {
+                    if (t.type !== "number" || pinnedSet.has(t.env) || !isMaxTradesTunable(t))
+                        continue;
+                    const cur = currentValue(t, ts.config);
+                    if (typeof cur !== "number")
+                        continue;
+                    let newVal = cur - 1;
+                    newVal = Math.max(1, newVal);
+                    newVal = clampToRange(newVal, t);
+                    newVal = snapToStep(newVal, t);
+                    if (newVal !== cur) {
+                        changes.push({ slug: ts.slug, env: t.env, oldValue: cur, newValue: newVal, reason: `win rate ${(winRate * 100).toFixed(0)}% — reducing max trades` });
+                        lastTunedCycle.set(ts.slug, cycleCount);
+                        lastTuned = cycleCount;
+                    }
+                }
+            }
+        }
+        // Rule 4: Win rate > 60% over last 20 cycles → increase max bet by 25% (cooldown 10)
+        if (sk.timesSelected >= 20 && cycleCount - lastTuned >= 10) {
+            const winRate = sk.timesRewarded / sk.timesSelected;
+            if (winRate > 0.6) {
+                for (const t of ts.tunables) {
+                    if (t.type !== "number" || pinnedSet.has(t.env) || !isMaxBetTunable(t))
+                        continue;
+                    if (changes.some((c) => c.slug === ts.slug && c.env === t.env))
+                        continue;
+                    const cur = currentValue(t, ts.config);
+                    if (typeof cur !== "number")
+                        continue;
+                    let newVal = cur * 1.25;
+                    newVal = clampToRange(newVal, t);
+                    newVal = snapToStep(newVal, t);
+                    if (newVal !== cur) {
+                        changes.push({ slug: ts.slug, env: t.env, oldValue: cur, newValue: newVal, reason: `win rate ${(winRate * 100).toFixed(0)}% — increasing max bet` });
+                        lastTunedCycle.set(ts.slug, cycleCount);
+                        lastTuned = cycleCount;
+                    }
+                }
+            }
+        }
+    }
+    return changes;
+}

package/package.json

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

package/src/api.ts

@@ -11,9 +11,20 @@ export interface AutomatonState {
   halted: boolean;
   tier: string;
   horizon_days: number;
+  venue: string;
   started_at: string | null;
 }
 
+export interface Tunable {
+  env: string;
+  type: "number" | "string" | "boolean" | "enum";
+  default: number | string | boolean;
+  label: string;
+  range?: [number, number];
+  step?: number;
+  options?: string[];
+}
+
 export interface Skill {
   id: string;
   name: string;
@@ -22,6 +33,17 @@ export interface Skill {
   tags: string[];
   difficulty: string;
   enabled: boolean;
+  entrypoint?: string;
+  tunables?: Tunable[];
+  config?: Record<string, number | string | boolean>;
+  pinned?: string[];
+}
+
+export interface SkillOutcome {
+  skill_slug: string;
+  trades: number;
+  total_cost: number;
+  period_pnl: number;
 }
 
 export class SimmerApi {
@@ -104,4 +126,16 @@ export class SimmerApi {
     if (since) params.set("since", since);
     return this.request(`/api/sdk/automaton/cycles?${params}`);
   }
+
+  async setSkillConfig(slug: string, config: Record<string, number | string | boolean | string[]>) {
+    return this.request(`/api/sdk/automaton/skills/${encodeURIComponent(slug)}/config`, {
+      method: "POST",
+      body: JSON.stringify(config),
+    });
+  }
+
+  async getOutcomes(since: string): Promise<{ outcomes: SkillOutcome[]; since: string }> {
+    const params = new URLSearchParams({ since });
+    return this.request(`/api/sdk/automaton/outcomes?${params}`);
+  }
 }

package/src/index.ts

@@ -8,10 +8,10 @@
  */
 
 import { SimmerApi } from "./api.js";
-import type { AutomatonState, Skill } from "./api.js";
+import type { AutomatonState, Skill, SkillOutcome } from "./api.js";
 import { selectSkills, tierMaxSkills, type SkillState } from "./bandit.js";
 import { computeTier, type Tier } from "./tiers.js";
-import { generateTuningHints } from "./tuning.js";
+import { generateTuningHints, computeTuningChanges, type ConfigChange } from "./tuning.js";
 
 // OpenClaw types — we declare minimal interfaces to avoid requiring the SDK as a dependency
 interface PluginApi {
@@ -42,6 +42,7 @@ let lastPromptCycle = -1; // Track which cycle was last issued to prevent re-run
 let currentSelectedMeta: Array<{ slug: string; reason: string; score: number | null }> = [];
 let serviceRunning = false;
 let cycleTimer: ReturnType<typeof setInterval> | null = null;
+let lastCycleTimestamp: string = new Date().toISOString();
 
 // Config defaults
 let config = {
@@ -81,6 +82,10 @@ async function refreshState(logger: { info: (m: string) => void; error: (m: stri
     }
 
     if (cachedState.initialized) {
+      // Sync venue from server state (source of truth — server enforces it)
+      if (cachedState.venue) {
+        config.venue = cachedState.venue;
+      }
       // Compute tier (totalPnl = 0 for now, will be enriched when P&L tracking is added)
       currentTier = computeTier(cachedState, 0);
 
@@ -90,13 +95,13 @@ async function refreshState(logger: { info: (m: string) => void; error: (m: stri
         const existing = existingBySlug.get(skill.id);
         if (existing) {
           // Preserve bandit memory, update enabled status
-          existing.enabled = (skill as any).enabled !== false;
+          existing.enabled = skill.enabled !== false;
           return existing;
         }
         // New skill — seed with zero history (unplayed gets priority)
         return {
           slug: skill.id,
-          enabled: (skill as any).enabled !== false,
+          enabled: skill.enabled !== false,
           timesSelected: 0,
           timesRewarded: 0,
           totalPnl: 0,
@@ -151,10 +156,21 @@ function buildPromptContext(): string {
     lastPromptCycle = cycleCount;
     lines.push(`## Simmer Automaton — Cycle ${cycleCount}`);
     lines.push("");
-    const venueFlag = config.venue !== "simmer" ? ` TRADING_VENUE=${config.venue}` : "";
-    lines.push(`**ACTION: Run these skills now.**${venueFlag ? ` Set env:${venueFlag}` : ""} Use --live --quiet flags.`);
+    lines.push("**ACTION: Run these skills now** (copy-paste each command):");
+    lines.push("");
+    // Build slug → entrypoint map from cachedSkills
+    const entrypointMap = new Map(cachedSkills.map((s) => [s.id, s.entrypoint]));
     for (const m of currentSelectedMeta) {
-      lines.push(`- ${m.slug}`);
+      const entrypoint = entrypointMap.get(m.slug);
+      if (entrypoint) {
+        const skillConfig = cachedSkills.find((s) => s.id === m.slug)?.config || {};
+        const envVars = Object.entries(skillConfig).map(([k, v]) => `${k}=${v}`).join(" ");
+        const envPrefix = envVars ? `${envVars} ` : "";
+        lines.push(`- \`TRADING_VENUE=${config.venue} ${envPrefix}python ${entrypoint} --live --quiet\``);
+      } else {
+        // No entrypoint in registry — bot should find the script from SKILL.md
+        lines.push(`- ${m.slug} (check SKILL.md for entrypoint)`);
+      }
     }
     lines.push("");
     lines.push("After running each skill, briefly note: trades executed, signals found, or why it was skipped.");
@@ -190,6 +206,8 @@ function buildPromptContext(): string {
   // --- Instructions for human-facing queries ---
   lines.push("");
   lines.push("**When your human asks about the automaton:** Report tier, budget, burn rate, which skills are running, and any tuning hints. Use `/simmer history` for recent cycle decisions. Don't dump raw data — summarize.");
+  lines.push("");
+  lines.push("**Currency formatting:** $SIM amounts must be written as `XXX $SIM` (e.g. `25.00 $SIM`, `100.00 $SIM`). NEVER write `$SIM25` or `$SIMxx` — the `$SIM` suffix goes AFTER the number. Real USDC uses `$` prefix (e.g. `$25.00`).");
 
   return lines.join("\n");
 }
@@ -256,8 +274,55 @@ export default function register(pluginApi: PluginApi) {
       cycleTimer = setInterval(async () => {
         if (!serviceRunning) return;
         cycleCount++;
+        const cycleStarted = lastCycleTimestamp;
+        lastCycleTimestamp = new Date().toISOString();
+
         await refreshState(ctx.logger);
 
+        // Query outcomes since last cycle and update bandit reward data
+        try {
+          const outcomeRes = await api.getOutcomes(cycleStarted);
+          for (const o of outcomeRes.outcomes) {
+            const skill = banditState.find((s) => s.slug === o.skill_slug);
+            if (skill) {
+              skill.tradesExecutedTotal += o.trades;
+              skill.timesRewarded += o.trades > 0 ? 1 : 0;
+              skill.totalPnl += o.period_pnl;
+              skill.consecutiveZeroSignals = o.trades > 0 ? 0 : skill.consecutiveZeroSignals + 1;
+            }
+          }
+          if (outcomeRes.outcomes.length > 0) {
+            ctx.logger.info(`[simmer] Outcomes: ${outcomeRes.outcomes.map((o: SkillOutcome) => `${o.skill_slug}:${o.trades}t`).join(", ")}`);
+          }
+        } catch (e) {
+          ctx.logger.error(`[simmer] Failed to fetch outcomes: ${e}`);
+        }
+
+        // Apply deterministic tuning
+        let tuningChanges: ConfigChange[] = [];
+        if (cycleCount >= 5) {
+          const tunableSkills = cachedSkills
+            .filter((s) => s.tunables && s.tunables.length > 0)
+            .map((s) => ({
+              slug: s.id,
+              tunables: s.tunables!,
+              config: s.config || {},
+              pinned: s.pinned || [],
+            }));
+          tuningChanges = computeTuningChanges(banditState, tunableSkills, cycleCount, cachedState?.budget_usd ?? 0);
+          for (const change of tuningChanges) {
+            const skill = tunableSkills.find((s) => s.slug === change.slug);
+            if (skill) {
+              const newConfig = { ...skill.config, [change.env]: change.newValue };
+              api.setSkillConfig(change.slug, newConfig)
+                .catch((e) => ctx.logger.error(`[simmer] Failed to apply config: ${e}`));
+            }
+          }
+          if (tuningChanges.length > 0) {
+            ctx.logger.info(`[simmer] Tuning: ${tuningChanges.map((c) => `${c.slug}.${c.env}: ${c.oldValue} → ${c.newValue}`).join(", ")}`);
+          }
+        }
+
         // Decay epsilon
         config.epsilon = Math.max(
           config.minEpsilon,
@@ -271,7 +336,7 @@ export default function register(pluginApi: PluginApi) {
         const hints = generateTuningHints(banditState, cachedState?.budget_usd ?? 0);
 
         // Record cycle to API (fire-and-forget — don't block the loop)
-        api.recordCycle({
+        const cycleData: Record<string, unknown> = {
           cycle_num: cycleCount,
           tier: currentTier,
           epsilon: parseFloat(config.epsilon.toFixed(4)),
@@ -279,7 +344,11 @@ export default function register(pluginApi: PluginApi) {
           tuning_hints: hints,
           budget_usd: cachedState?.budget_usd,
           spent_usd: cachedState?.spent_usd,
-        }).catch((e) => ctx.logger.error(`[simmer] Failed to record cycle: ${e}`));
+        };
+        if (tuningChanges.length > 0) {
+          cycleData.config_changes = tuningChanges.map((c) => ({ slug: c.slug, env: c.env, old: c.oldValue, new: c.newValue, reason: c.reason }));
+        }
+        api.recordCycle(cycleData as any).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`,
@@ -337,7 +406,7 @@ export default function register(pluginApi: PluginApi) {
         }
         const lines = cachedSkills.map(
           (s) => {
-            const status = (s as any).enabled === false ? " [DISABLED]" : "";
+            const status = s.enabled === false ? " [DISABLED]" : "";
             return `- ${s.name} (${s.id}) — ${s.category}, ${s.difficulty}${status}`;
           },
         );
@@ -394,8 +463,73 @@ export default function register(pluginApi: PluginApi) {
         }
       }
 
+      if (subcommand === "config") {
+        const slug = ctx.args?.trim().split(/\s+/)[1];
+        if (!slug) {
+          return { text: "Usage: /simmer config <skill-slug>" };
+        }
+        await refreshState(logger);
+        const skill = cachedSkills.find((s) => s.id === slug);
+        if (!skill) {
+          return { text: `Skill not found: ${slug}` };
+        }
+        if (!skill.tunables || skill.tunables.length === 0) {
+          return { text: `${slug} has no tunables.` };
+        }
+        const pinnedSet = new Set(skill.pinned || []);
+        const lines = skill.tunables.map((t) => {
+          const cur = (skill.config || {})[t.env] ?? t.default;
+          const isDefault = cur === t.default;
+          const pinLabel = pinnedSet.has(t.env) ? " [PINNED]" : "";
+          return `  ${t.env}: ${cur}${isDefault ? "" : ` (default: ${t.default})`}${pinLabel}`;
+        });
+        return { text: `${slug} config:\n${lines.join("\n")}` };
+      }
+
+      if (subcommand === "tune") {
+        const parts = ctx.args?.trim().split(/\s+/) || [];
+        const slug = parts[1];
+        const envVar = parts[2];
+        const rawValue = parts[3];
+        if (!slug || !envVar || rawValue === undefined) {
+          return { text: "Usage: /simmer tune <skill-slug> <ENV_VAR> <value>" };
+        }
+        await refreshState(logger);
+        const skill = cachedSkills.find((s) => s.id === slug);
+        if (!skill) {
+          return { text: `Skill not found: ${slug}` };
+        }
+        // Parse value — try number, then boolean, then string
+        let parsedValue: number | string | boolean = rawValue;
+        if (rawValue === "true") parsedValue = true;
+        else if (rawValue === "false") parsedValue = false;
+        else if (!isNaN(Number(rawValue))) parsedValue = Number(rawValue);
+        const currentConfig = skill.config || {};
+        const currentPinned = new Set(skill.pinned || []);
+        currentPinned.add(envVar);
+        try {
+          await api.setSkillConfig(slug, { ...currentConfig, [envVar]: parsedValue, _pinned: [...currentPinned] });
+          return { text: `Set ${slug} ${envVar}=${parsedValue} (pinned — automaton won't override it).` };
+        } catch (e) {
+          return { text: `Failed to set config: ${e}` };
+        }
+      }
+
+      if (subcommand === "reset") {
+        const slug = ctx.args?.trim().split(/\s+/)[1];
+        if (!slug) {
+          return { text: "Usage: /simmer reset <skill-slug>" };
+        }
+        try {
+          await api.setSkillConfig(slug, { _pinned: [] });
+          return { text: `Reset ${slug} to defaults. All pins cleared.` };
+        } catch (e) {
+          return { text: `Failed to reset config: ${e}` };
+        }
+      }
+
       return {
-        text: "Usage: /simmer [status|halt|resume|skills|history [N]|disable <slug>|enable <slug>]",
+        text: "Usage: /simmer [status|halt|resume|skills|history [N]|disable <slug>|enable <slug>|config <slug>|tune <slug> <ENV> <val>|reset <slug>]",
       };
     },
   });

package/src/tuning.ts

@@ -1,9 +1,12 @@
 /**
- * Tuning hints for the Clawbot LLM.
- * Ported from automaton.py — generate_tuning_hints.
+ * Tuning engine for the automaton plugin.
+ * Two layers:
+ *   1. generateTuningHints() — text hints for the LLM prompt
+ *   2. computeTuningChanges() — deterministic config changes applied via API
  */
 
 import type { SkillState } from "./bandit.js";
+import type { Tunable } from "./api.js";
 
 export interface TuningHint {
   skill: string;
@@ -12,6 +15,52 @@ export interface TuningHint {
   [key: string]: unknown;
 }
 
+export interface ConfigChange {
+  slug: string;
+  env: string;
+  oldValue: number | string | boolean;
+  newValue: number | string | boolean;
+  reason: string;
+}
+
+export interface TunableSkill {
+  slug: string;
+  tunables: Tunable[];
+  config: Record<string, any>;
+  pinned: string[];
+}
+
+// Track last tuned cycle per skill to enforce cooldowns
+const lastTunedCycle = new Map<string, number>();
+
+function isThresholdTunable(t: Tunable): boolean {
+  const l = t.label.toLowerCase();
+  return l.includes("threshold") || l.includes("edge") || l.includes("confidence") || l.includes("min edge") || l.includes("min split");
+}
+
+function isMaxBetTunable(t: Tunable): boolean {
+  const l = t.label.toLowerCase();
+  return l.includes("max bet") || l.includes("max position") || l.includes("max usd");
+}
+
+function isMaxTradesTunable(t: Tunable): boolean {
+  return t.env.toUpperCase().includes("MAX_TRADES");
+}
+
+function snapToStep(value: number, t: Tunable): number {
+  if (!t.step) return value;
+  return Math.round(value / t.step) * t.step;
+}
+
+function clampToRange(value: number, t: Tunable): number {
+  if (!t.range) return value;
+  return Math.max(t.range[0], Math.min(t.range[1], value));
+}
+
+function currentValue(t: Tunable, config: Record<string, any>): number | string | boolean {
+  return config[t.env] ?? t.default;
+}
+
 export function generateTuningHints(
   skills: SkillState[],
   budgetUsd: number,
@@ -21,7 +70,6 @@ export function generateTuningHints(
   for (const sk of skills) {
     if (!sk.enabled || sk.timesSelected === 0) continue;
 
-    // 1. Zero signals streak
     if (sk.consecutiveZeroSignals >= 5) {
       hints.push({
         skill: sk.slug,
@@ -31,7 +79,6 @@ export function generateTuningHints(
       });
     }
 
-    // 2. Concentrated loss
     if (sk.totalPnl < 0 && budgetUsd > 0) {
       const lossPct = (Math.abs(sk.totalPnl) / budgetUsd) * 100;
       if (lossPct > 20) {
@@ -45,7 +92,6 @@ export function generateTuningHints(
       }
     }
 
-    // 3. Inert — finds signals but never executes
     if (sk.signalsFoundTotal > 50 && sk.tradesExecutedTotal === 0) {
       hints.push({
         skill: sk.slug,
@@ -55,7 +101,6 @@ export function generateTuningHints(
       });
     }
 
-    // 4. Win rate collapse
     if (sk.timesSelected >= 10) {
       const winRate = sk.timesRewarded / sk.timesSelected;
       if (winRate < 0.2) {
@@ -69,23 +114,120 @@ export function generateTuningHints(
       }
     }
 
-    // 5. Safeguard dominant
     const skipCounts = sk.lastCycle?.skipCounts || {};
-    const totalSkips = Object.values(skipCounts).reduce(
-      (a, b) => a + b,
-      0,
-    );
+    const totalSkips = Object.values(skipCounts).reduce((a, b) => a + b, 0);
     const safeguardSkips = skipCounts["safeguard"] || 0;
     if (totalSkips >= 3 && safeguardSkips / totalSkips > 0.8) {
       hints.push({
         skill: sk.slug,
         issue: "safeguard_dominant",
         safeguard_pct: Math.round((safeguardSkips / totalSkips) * 100),
-        suggestion:
-          "Most skips are safeguard blocks — markets may be too volatile or near resolution",
+        suggestion: "Most skips are safeguard blocks — markets may be too volatile or near resolution",
       });
     }
   }
 
   return hints;
 }
+
+export function computeTuningChanges(
+  skills: SkillState[],
+  tunableSkills: TunableSkill[],
+  cycleCount: number,
+  budgetUsd = 0,
+): ConfigChange[] {
+  if (cycleCount < 5) return [];
+
+  const changes: ConfigChange[] = [];
+  const skillMap = new Map(skills.map((s) => [s.slug, s]));
+
+  for (const ts of tunableSkills) {
+    const sk = skillMap.get(ts.slug);
+    if (!sk || !sk.enabled || sk.timesSelected === 0) continue;
+
+    let lastTuned = lastTunedCycle.get(ts.slug) ?? 0;
+    const pinnedSet = new Set(ts.pinned);
+
+    // Rule 1: consecutiveZeroSignals >= 5 → widen thresholds by 20% (cooldown 10)
+    if (sk.consecutiveZeroSignals >= 5 && cycleCount - lastTuned >= 10) {
+      for (const t of ts.tunables) {
+        if (t.type !== "number" || pinnedSet.has(t.env) || !isThresholdTunable(t)) continue;
+        const cur = currentValue(t, ts.config);
+        if (typeof cur !== "number") continue;
+        let newVal = cur * 0.8;
+        newVal = clampToRange(newVal, t);
+        newVal = snapToStep(newVal, t);
+        if (newVal !== cur) {
+          changes.push({ slug: ts.slug, env: t.env, oldValue: cur, newValue: newVal, reason: `zero signals for ${sk.consecutiveZeroSignals} cycles — widening threshold` });
+          lastTunedCycle.set(ts.slug, cycleCount);
+          lastTuned = cycleCount;
+        }
+      }
+    }
+
+    // Rule 2: Skill P&L < -15% of budget → halve max bet (cooldown 10)
+    if (budgetUsd > 0 && sk.totalPnl < 0 && cycleCount - lastTuned >= 10) {
+      const lossPct = (Math.abs(sk.totalPnl) / budgetUsd) * 100;
+      if (lossPct > 15) {
+        for (const t of ts.tunables) {
+          if (t.type !== "number" || pinnedSet.has(t.env) || !isMaxBetTunable(t)) continue;
+          if (changes.some((c) => c.slug === ts.slug && c.env === t.env)) continue;
+          const cur = currentValue(t, ts.config);
+          if (typeof cur !== "number") continue;
+          let newVal = cur * 0.5;
+          newVal = clampToRange(newVal, t);
+          newVal = snapToStep(newVal, t);
+          if (newVal !== cur) {
+            changes.push({ slug: ts.slug, env: t.env, oldValue: cur, newValue: newVal, reason: `P&L ${sk.totalPnl.toFixed(2)} (${lossPct.toFixed(0)}% of budget) — halving max bet` });
+            lastTunedCycle.set(ts.slug, cycleCount);
+            lastTuned = cycleCount;
+          }
+        }
+      }
+    }
+
+    // Rule 3: Win rate < 20% over last 20 cycles → reduce max trades (cooldown 15)
+    if (sk.timesSelected >= 20 && cycleCount - lastTuned >= 15) {
+      const winRate = sk.timesRewarded / sk.timesSelected;
+      if (winRate < 0.2) {
+        for (const t of ts.tunables) {
+          if (t.type !== "number" || pinnedSet.has(t.env) || !isMaxTradesTunable(t)) continue;
+          const cur = currentValue(t, ts.config);
+          if (typeof cur !== "number") continue;
+          let newVal = cur - 1;
+          newVal = Math.max(1, newVal);
+          newVal = clampToRange(newVal, t);
+          newVal = snapToStep(newVal, t);
+          if (newVal !== cur) {
+            changes.push({ slug: ts.slug, env: t.env, oldValue: cur, newValue: newVal, reason: `win rate ${(winRate * 100).toFixed(0)}% — reducing max trades` });
+            lastTunedCycle.set(ts.slug, cycleCount);
+            lastTuned = cycleCount;
+          }
+        }
+      }
+    }
+
+    // Rule 4: Win rate > 60% over last 20 cycles → increase max bet by 25% (cooldown 10)
+    if (sk.timesSelected >= 20 && cycleCount - lastTuned >= 10) {
+      const winRate = sk.timesRewarded / sk.timesSelected;
+      if (winRate > 0.6) {
+        for (const t of ts.tunables) {
+          if (t.type !== "number" || pinnedSet.has(t.env) || !isMaxBetTunable(t)) continue;
+          if (changes.some((c) => c.slug === ts.slug && c.env === t.env)) continue;
+          const cur = currentValue(t, ts.config);
+          if (typeof cur !== "number") continue;
+          let newVal = cur * 1.25;
+          newVal = clampToRange(newVal, t);
+          newVal = snapToStep(newVal, t);
+          if (newVal !== cur) {
+            changes.push({ slug: ts.slug, env: t.env, oldValue: cur, newValue: newVal, reason: `win rate ${(winRate * 100).toFixed(0)}% — increasing max bet` });
+            lastTunedCycle.set(ts.slug, cycleCount);
+            lastTuned = cycleCount;
+          }
+        }
+      }
+    }
+  }
+
+  return changes;
+}