simmer-automaton 0.6.8 → 0.7.1

package/dist/api.d.ts

@@ -99,9 +99,16 @@ export interface BriefingResponse {
         latest: string;
         message: string;
     } | null;
+    skill_updates: Array<{
+        slug: string;
+        current: string;
+        latest: string;
+        message: string;
+    }> | null;
 }
 export interface SkillOutcome {
     skill_slug: string;
+    venue: string;
     trades: number;
     total_cost: number;
     period_pnl: number;
@@ -155,7 +162,7 @@ export declare class SimmerApi {
         outcomes: SkillOutcome[];
         since: string;
     }>;
-    getBriefing(): Promise<BriefingResponse>;
+    getBriefing(skillVersions?: Record<string, string>): Promise<BriefingResponse>;
     getPositions(): Promise<{
         positions: PositionsPosition[];
     }>;
@@ -174,9 +181,29 @@ export declare class SimmerApi {
             new: any;
             reason: string;
         }>;
+        epsilon?: number;
+        bandit_arms?: BanditArmState[];
     }): Promise<{
         ok: boolean;
         active_skills: string[];
         cycle_number: number;
     }>;
+    getBanditState(): Promise<{
+        epsilon: number;
+        cycle_count: number;
+        arms: BanditArmState[];
+    } | null>;
+    resetBanditState(): Promise<void>;
+}
+/** Serialized form of a bandit arm written to / read from the API. */
+export interface BanditArmState {
+    slug: string;
+    enabled: boolean;
+    timesSelected: number;
+    timesRewarded: number;
+    totalPnl: number;
+    consecutiveZeroSignals: number;
+    signalsFoundTotal: number;
+    tradesExecutedTotal: number;
+    ewmRoc: number;
 }

package/dist/api.js

@@ -70,8 +70,13 @@ export class SimmerApi {
         const params = new URLSearchParams({ since });
         return this.request(`/api/sdk/automaton/outcomes?${params}`);
     }
-    async getBriefing() {
-        return this.request("/api/sdk/briefing");
+    async getBriefing(skillVersions) {
+        let url = "/api/sdk/briefing";
+        if (skillVersions && Object.keys(skillVersions).length > 0) {
+            const params = new URLSearchParams({ skill_versions: JSON.stringify(skillVersions) });
+            url += `?${params}`;
+        }
+        return this.request(url);
     }
     async getPositions() {
         return this.request("/api/sdk/positions?status=active");
@@ -82,4 +87,20 @@ export class SimmerApi {
             body: JSON.stringify(data),
         });
     }
+    async getBanditState() {
+        try {
+            return await this.request("/api/sdk/automaton/bandit-state");
+        }
+        catch {
+            return null;
+        }
+    }
+    async resetBanditState() {
+        try {
+            await this.request("/api/sdk/automaton/bandit-state", { method: "DELETE" });
+        }
+        catch {
+            // Best-effort — don't block re-init if this fails
+        }
+    }
 }

package/dist/bandit.d.ts

@@ -11,10 +11,15 @@ export interface SkillState {
     consecutiveZeroSignals: number;
     signalsFoundTotal: number;
     tradesExecutedTotal: number;
+    /** Exponentially weighted return-on-capital (period_pnl / total_cost per cycle).
+     *  Alpha=0.1 gives ~7-cycle half-life. Primary bandit arm score. */
+    ewmRoc: number;
     lastCycle?: {
         skipCounts?: Record<string, number>;
     };
 }
+/** EWM decay factor. Alpha=0.1 → ~7-cycle half-life. */
+export declare const EWM_ALPHA = 0.1;
 export interface SelectionMeta {
     slug: string;
     reason: string;

package/dist/bandit.js

@@ -2,15 +2,19 @@
  * Epsilon-greedy bandit for skill selection.
  * Ported from automaton.py — select_skills, _avg_reward, tier_max_skills, tier_effective_epsilon.
  */
+/** EWM decay factor. Alpha=0.1 → ~7-cycle half-life. */
+export const EWM_ALPHA = 0.1;
 function avgReward(skill) {
     if (skill.timesSelected === 0)
         return Infinity;
-    // Use P&L as primary signal. When P&L is unavailable (0), fall back to
-    // trade execution rate as bootstrap — a skill that finds and executes trades
-    // is better than one that finds nothing.
-    if (skill.totalPnl !== 0)
-        return skill.totalPnl / skill.timesSelected;
-    return skill.tradesExecutedTotal / skill.timesSelected;
+    // Primary: exponentially weighted return-on-capital. Normalizes for position
+    // size and decays stale regime data (~7-cycle half-life at alpha=0.1).
+    if (skill.ewmRoc !== 0)
+        return skill.ewmRoc;
+    // Bootstrap: a skill that executes trades at all beats one that finds nothing.
+    if (skill.tradesExecutedTotal > 0)
+        return 0.001;
+    return 0;
 }
 export function tierMaxSkills(tier, maxConcurrent) {
     if (tier === "thriving" || tier === "normal")

package/dist/index.js

@@ -7,7 +7,7 @@
  * API enforces hard spending limits on every trade.
  */
 import { SimmerApi } from "./api.js";
-import { selectSkills, tierMaxSkills } from "./bandit.js";
+import { selectSkills, tierMaxSkills, EWM_ALPHA } from "./bandit.js";
 import { computeTier } from "./tiers.js";
 import { generateTuningHints, computeTuningChanges } from "./tuning.js";
 // Plugin-local state (in-memory, refreshed from API each cycle)
@@ -18,6 +18,9 @@ let cachedSkills = [];
 let banditState = [];
 let currentTier = "normal";
 let cycleCount = 0;
+let lastUpdateCheckCycle = 0;
+const UPDATE_CHECK_INTERVAL = 50; // cycles between version checks
+const INSTALL_TIMEOUT_MS = 30_000; // 30s per skill install
 let currentSelectedMeta = [];
 let lastExecutionResults = [];
 let cachedPortfolio = null;
@@ -34,7 +37,7 @@ let config = {
     epsilonDecay: 0.995,
     minEpsilon: 0.05,
     maxConcurrent: 2,
-    venue: "simmer",
+    venue: "sim",
 };
 function loadConfig(pluginConfig) {
     if (!pluginConfig)
@@ -75,9 +78,12 @@ async function refreshState(logger) {
                 if (lastKnownStartedAt !== null) {
                     logger.info(`[simmer] Detected re-init (started_at changed) — resetting cycle counter and bandit state`);
                     cycleCount = 0;
+                    config.epsilon = 0.2;
                     banditState = [];
                     currentSelectedMeta = [];
                     lastCycleTimestamp = new Date().toISOString();
+                    // Delete persisted bandit state so the next startup doesn't restore stale arms
+                    api.resetBanditState().catch((e) => logger.warn(`[simmer] Failed to reset bandit state: ${e}`));
                 }
                 lastKnownStartedAt = cachedState.started_at;
             }
@@ -102,6 +108,7 @@ async function refreshState(logger) {
                     timesSelected: 0,
                     timesRewarded: 0,
                     totalPnl: 0,
+                    ewmRoc: 0,
                     consecutiveZeroSignals: 0,
                     signalsFoundTotal: 0,
                     tradesExecutedTotal: 0,
@@ -115,7 +122,7 @@ async function refreshState(logger) {
 }
 function fmtCurrency(amount) {
     const val = amount.toFixed(2);
-    return config.venue === "simmer" ? `${val} $SIM` : `$${val}`;
+    return (config.venue === "sim" || config.venue === "simmer") ? `${val} $SIM` : `$${val}`;
 }
 function buildPromptContext() {
     if (!cachedState || !cachedState.initialized) {
@@ -216,9 +223,73 @@ function formatStatus() {
         `Cycles: ${cycleCount}`,
         `Skills available: ${cachedSkills.length}`,
     ];
+    if (cachedPortfolio) {
+        const pnlStr = cachedPortfolio.totalPnl >= 0
+            ? `+${fmtCurrency(cachedPortfolio.totalPnl)}`
+            : fmtCurrency(cachedPortfolio.totalPnl);
+        lines.push(`Positions: ${cachedPortfolio.positionCount} open | P&L: ${pnlStr} | Recent trades: ${cachedPortfolio.recentTradeCount}`);
+        const top = cachedPortfolio.positions.slice(0, 3);
+        for (const p of top) {
+            const pnl = p.pnl >= 0 ? `+${fmtCurrency(p.pnl)}` : fmtCurrency(p.pnl);
+            lines.push(`  · ${p.question.slice(0, 55)} | ${p.side} | ${pnl}`);
+        }
+        if (cachedPortfolio.positions.length > 3) {
+            lines.push(`  · ...and ${cachedPortfolio.positions.length - 3} more (use /simmer portfolio for full list)`);
+        }
+    }
     return lines.join("\n");
 }
 // =============================================================================
+// Skill auto-update — keep installed skills at latest ClawHub version
+// =============================================================================
+/**
+ * Read installed skill versions from SKILL.md frontmatter.
+ * Returns { slug: version } for skills that have a parseable version.
+ */
+function getLocalSkillVersions(workspaceDir) {
+    const fs = require("fs");
+    const cwd = workspaceDir || process.cwd();
+    const versions = {};
+    for (const skill of cachedSkills) {
+        const slug = skill.id;
+        try {
+            const skillMd = fs.readFileSync(`${cwd}/skills/${slug}/SKILL.md`, "utf-8");
+            const versionMatch = skillMd.match(/^\s*version:\s*["']?([^"'\n]+)["']?/m);
+            if (versionMatch) {
+                versions[slug] = versionMatch[1].trim();
+            }
+        }
+        catch {
+            // Skill not installed locally or no SKILL.md — skip
+        }
+    }
+    return versions;
+}
+/**
+ * Check for outdated skills and auto-install updates.
+ * Uses the skill_updates from the most recent briefing response.
+ */
+async function checkAndUpdateSkills(skillUpdates, workspaceDir, logger) {
+    if (!runtime || skillUpdates.length === 0)
+        return;
+    const cwd = workspaceDir || process.cwd();
+    logger.info(`[simmer] ${skillUpdates.length} skill update(s) available: ${skillUpdates.map((u) => `${u.slug} ${u.current}→${u.latest}`).join(", ")}`);
+    for (const update of skillUpdates) {
+        try {
+            const result = await runtime.system.runCommandWithTimeout(["npx", "clawhub@latest", "install", update.slug, "--force"], { timeoutMs: INSTALL_TIMEOUT_MS, cwd });
+            if (result.code === 0) {
+                logger.info(`[simmer] Updated ${update.slug} to ${update.latest}`);
+            }
+            else {
+                logger.warn(`[simmer] Failed to update ${update.slug}: exit ${result.code} — ${result.stderr.slice(0, 200)}`);
+            }
+        }
+        catch (e) {
+            logger.warn(`[simmer] Failed to update ${update.slug}: ${e}`);
+        }
+    }
+}
+// =============================================================================
 // Skill execution — deterministic, no LLM in the loop
 // =============================================================================
 async function executeSkills(selectedSlugs, workspaceDir, logger) {
@@ -324,8 +395,49 @@ export default function register(pluginApi) {
         start: async (ctx) => {
             ctx.logger.info("[simmer] Automaton service starting");
             serviceRunning = true;
-            // Initial state fetch
+            // Initial state fetch (seeds banditState with current skills)
             await refreshState(ctx.logger);
+            // Restore persisted bandit arm statistics — overwrite in-memory state seeded above.
+            // This lets the bandit resume learning after a plugin restart without starting cold.
+            try {
+                const saved = await api.getBanditState();
+                if (saved && saved.arms.length > 0) {
+                    const savedBySlug = new Map(saved.arms.map((a) => [a.slug, a]));
+                    banditState = banditState.map((arm) => {
+                        const s = savedBySlug.get(arm.slug);
+                        if (s) {
+                            // Restore learned stats; keep live enabled status from skills registry
+                            return {
+                                ...s,
+                                enabled: arm.enabled,
+                            };
+                        }
+                        return arm; // new skill not in saved state — start fresh
+                    });
+                    config.epsilon = saved.epsilon;
+                    cycleCount = saved.cycle_count;
+                    ctx.logger.info(`[simmer] Restored bandit state: ${saved.arms.length} arms, ε=${saved.epsilon.toFixed(3)}, cycle=${saved.cycle_count}`);
+                }
+                else {
+                    ctx.logger.info("[simmer] No saved bandit state — starting fresh");
+                }
+            }
+            catch (e) {
+                ctx.logger.warn(`[simmer] Failed to restore bandit state: ${e}`);
+            }
+            // Check for skill updates on startup
+            try {
+                const skillVersions = getLocalSkillVersions(ctx.workspaceDir);
+                if (Object.keys(skillVersions).length > 0) {
+                    const briefing = await api.getBriefing(skillVersions);
+                    if (briefing.skill_updates && briefing.skill_updates.length > 0) {
+                        await checkAndUpdateSkills(briefing.skill_updates, ctx.workspaceDir, ctx.logger);
+                    }
+                }
+            }
+            catch (e) {
+                ctx.logger.warn(`[simmer] Startup skill update check failed: ${e}`);
+            }
             // Periodic refresh
             cycleTimer = setInterval(async () => {
                 if (!serviceRunning)
@@ -336,20 +448,26 @@ export default function register(pluginApi) {
                 lastCycleTimestamp = new Date().toISOString();
                 await refreshState(ctx.logger);
                 // Query outcomes since last cycle and update bandit reward data
+                // Filter to outcomes matching this plugin's configured venue
                 try {
                     const outcomeRes = await api.getOutcomes(cycleStarted);
-                    for (const o of outcomeRes.outcomes) {
+                    const venueOutcomes = outcomeRes.outcomes.filter((o) => o.venue === config.venue);
+                    for (const o of venueOutcomes) {
                         const skill = banditState.find((s) => s.slug === o.skill_slug);
                         if (skill) {
                             skill.tradesExecutedTotal += o.trades;
-                            skill.timesRewarded += o.trades > 0 ? 1 : 0;
+                            // Return-on-capital for this cycle (0 if no cost data)
+                            const roc = o.total_cost > 0 ? o.period_pnl / o.total_cost : 0;
+                            // Exponentially weighted RoC — decays stale data (~7-cycle half-life)
+                            skill.ewmRoc = EWM_ALPHA * roc + (1 - EWM_ALPHA) * skill.ewmRoc;
+                            skill.timesRewarded += roc > 0 ? 1 : 0;
                             skill.totalPnl += o.period_pnl;
                             skill.consecutiveZeroSignals = o.trades > 0 ? 0 : skill.consecutiveZeroSignals + 1;
                         }
                     }
                     // Skills that were selected last cycle but had zero trades won't appear in outcomes
                     // (GROUP BY only returns rows with trades). Increment consecutiveZeroSignals for them.
-                    const outcomeSkillSlugs = new Set(outcomeRes.outcomes.map((o) => o.skill_slug));
+                    const outcomeSkillSlugs = new Set(venueOutcomes.map((o) => o.skill_slug));
                     for (const m of currentSelectedMeta) {
                         if (!outcomeSkillSlugs.has(m.slug)) {
                             const skill = banditState.find((s) => s.slug === m.slug);
@@ -358,8 +476,8 @@ export default function register(pluginApi) {
                             }
                         }
                     }
-                    if (outcomeRes.outcomes.length > 0) {
-                        ctx.logger.info(`[simmer] Outcomes: ${outcomeRes.outcomes.map((o) => `${o.skill_slug}:${o.trades}t`).join(", ")}`);
+                    if (venueOutcomes.length > 0) {
+                        ctx.logger.info(`[simmer] Outcomes (${config.venue}): ${venueOutcomes.map((o) => `${o.skill_slug}:${o.trades}t/$${o.period_pnl.toFixed(2)}pnl`).join(", ")}`);
                     }
                 }
                 catch (e) {
@@ -403,6 +521,19 @@ export default function register(pluginApi) {
                         cycle_number: thisCycleNumber,
                         selection_meta: meta.map((m) => ({ slug: m.slug, reason: m.reason, score: m.score })),
                         config_changes: configChangesPayload,
+                        // Bandit persistence — write current arm stats so restarts resume where we left off
+                        epsilon: parseFloat(config.epsilon.toFixed(6)),
+                        bandit_arms: banditState.map((s) => ({
+                            slug: s.slug,
+                            enabled: s.enabled,
+                            timesSelected: s.timesSelected,
+                            timesRewarded: s.timesRewarded,
+                            totalPnl: s.totalPnl,
+                            consecutiveZeroSignals: s.consecutiveZeroSignals,
+                            signalsFoundTotal: s.signalsFoundTotal,
+                            tradesExecutedTotal: s.tradesExecutedTotal,
+                            ewmRoc: s.ewmRoc,
+                        })),
                     });
                 }
                 catch (e) {
@@ -423,8 +554,9 @@ export default function register(pluginApi) {
                 }
                 // Fetch portfolio snapshot for prompt context
                 try {
-                    const briefing = await api.getBriefing();
-                    const venue = briefing.venues?.simmer;
+                    const skillVersions = getLocalSkillVersions(ctx.workspaceDir);
+                    const briefing = await api.getBriefing(skillVersions);
+                    const venue = briefing.venues?.[config.venue];
                     const attentionPositions = venue?.positions_needing_attention || [];
                     cachedPortfolio = {
                         totalPnl: briefing.performance?.total_pnl ?? 0,
@@ -432,6 +564,12 @@ export default function register(pluginApi) {
                         positions: attentionPositions,
                         recentTradeCount: 0,
                     };
+                    // Periodic skill auto-update
+                    if (briefing.skill_updates && briefing.skill_updates.length > 0 &&
+                        thisCycleNumber - lastUpdateCheckCycle >= UPDATE_CHECK_INTERVAL) {
+                        lastUpdateCheckCycle = thisCycleNumber;
+                        await checkAndUpdateSkills(briefing.skill_updates, ctx.workspaceDir, ctx.logger);
+                    }
                 }
                 catch (e) {
                     ctx.logger.warn(`[simmer] Failed to fetch briefing: ${e}`);

package/package.json

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

package/src/api.ts

@@ -99,10 +99,12 @@ export interface BriefingResponse {
   };
   checked_at: string;
   sdk_update: { current: string; latest: string; message: string } | null;
+  skill_updates: Array<{ slug: string; current: string; latest: string; message: string }> | null;
 }
 
 export interface SkillOutcome {
   skill_slug: string;
+  venue: string;
   trades: number;
   total_cost: number;
   period_pnl: number;
@@ -201,8 +203,13 @@ export class SimmerApi {
     return this.request(`/api/sdk/automaton/outcomes?${params}`);
   }
 
-  async getBriefing(): Promise<BriefingResponse> {
-    return this.request("/api/sdk/briefing");
+  async getBriefing(skillVersions?: Record<string, string>): Promise<BriefingResponse> {
+    let url = "/api/sdk/briefing";
+    if (skillVersions && Object.keys(skillVersions).length > 0) {
+      const params = new URLSearchParams({ skill_versions: JSON.stringify(skillVersions) });
+      url += `?${params}`;
+    }
+    return this.request(url);
   }
 
   async getPositions(): Promise<{ positions: PositionsPosition[] }> {
@@ -214,10 +221,41 @@ export class SimmerApi {
     cycle_number: number;
     selection_meta: Array<{ slug: string; reason: string; score: number | null }>;
     config_changes: Array<{ slug: string; env: string; old: any; new: any; reason: string }>;
+    epsilon?: number;
+    bandit_arms?: BanditArmState[];
   }): Promise<{ ok: boolean; active_skills: string[]; cycle_number: number }> {
     return this.request("/api/sdk/automaton/cycle", {
       method: "POST",
       body: JSON.stringify(data),
     });
   }
+
+  async getBanditState(): Promise<{ epsilon: number; cycle_count: number; arms: BanditArmState[] } | null> {
+    try {
+      return await this.request("/api/sdk/automaton/bandit-state");
+    } catch {
+      return null;
+    }
+  }
+
+  async resetBanditState(): Promise<void> {
+    try {
+      await this.request("/api/sdk/automaton/bandit-state", { method: "DELETE" });
+    } catch {
+      // Best-effort — don't block re-init if this fails
+    }
+  }
+}
+
+/** Serialized form of a bandit arm written to / read from the API. */
+export interface BanditArmState {
+  slug: string;
+  enabled: boolean;
+  timesSelected: number;
+  timesRewarded: number;
+  totalPnl: number;
+  consecutiveZeroSignals: number;
+  signalsFoundTotal: number;
+  tradesExecutedTotal: number;
+  ewmRoc: number;
 }

package/src/bandit.ts

@@ -12,11 +12,17 @@ export interface SkillState {
   consecutiveZeroSignals: number;
   signalsFoundTotal: number;
   tradesExecutedTotal: number;
+  /** Exponentially weighted return-on-capital (period_pnl / total_cost per cycle).
+   *  Alpha=0.1 gives ~7-cycle half-life. Primary bandit arm score. */
+  ewmRoc: number;
   lastCycle?: {
     skipCounts?: Record<string, number>;
   };
 }
 
+/** EWM decay factor. Alpha=0.1 → ~7-cycle half-life. */
+export const EWM_ALPHA = 0.1;
+
 export interface SelectionMeta {
   slug: string;
   reason: string;
@@ -25,11 +31,12 @@ export interface SelectionMeta {
 
 function avgReward(skill: SkillState): number {
   if (skill.timesSelected === 0) return Infinity;
-  // Use P&L as primary signal. When P&L is unavailable (0), fall back to
-  // trade execution rate as bootstrap — a skill that finds and executes trades
-  // is better than one that finds nothing.
-  if (skill.totalPnl !== 0) return skill.totalPnl / skill.timesSelected;
-  return skill.tradesExecutedTotal / skill.timesSelected;
+  // Primary: exponentially weighted return-on-capital. Normalizes for position
+  // size and decays stale regime data (~7-cycle half-life at alpha=0.1).
+  if (skill.ewmRoc !== 0) return skill.ewmRoc;
+  // Bootstrap: a skill that executes trades at all beats one that finds nothing.
+  if (skill.tradesExecutedTotal > 0) return 0.001;
+  return 0;
 }
 
 export function tierMaxSkills(tier: string, maxConcurrent: number): number {

package/src/index.ts

@@ -8,8 +8,8 @@
  */
 
 import { SimmerApi } from "./api.js";
-import type { AutomatonState, Skill, SkillOutcome, BriefingPosition, PositionsPosition } from "./api.js";
-import { selectSkills, tierMaxSkills, type SkillState } from "./bandit.js";
+import type { AutomatonState, Skill, SkillOutcome, BriefingPosition, PositionsPosition, BanditArmState } from "./api.js";
+import { selectSkills, tierMaxSkills, EWM_ALPHA, type SkillState } from "./bandit.js";
 import { computeTier, type Tier } from "./tiers.js";
 import { generateTuningHints, computeTuningChanges, type ConfigChange } from "./tuning.js";
 
@@ -56,6 +56,9 @@ let cachedSkills: Skill[] = [];
 let banditState: SkillState[] = [];
 let currentTier: Tier = "normal";
 let cycleCount = 0;
+let lastUpdateCheckCycle = 0;
+const UPDATE_CHECK_INTERVAL = 50; // cycles between version checks
+const INSTALL_TIMEOUT_MS = 30_000; // 30s per skill install
 let currentSelectedMeta: Array<{ slug: string; reason: string; score: number | null }> = [];
 let lastExecutionResults: Array<{ slug: string; ok: boolean; detail: string }> = [];
 let cachedPortfolio: { totalPnl: number; positionCount: number; positions: BriefingPosition[]; recentTradeCount: number } | null = null;
@@ -73,7 +76,7 @@ let config = {
   epsilonDecay: 0.995,
   minEpsilon: 0.05,
   maxConcurrent: 2,
-  venue: "simmer",
+  venue: "sim",
 };
 
 function loadConfig(pluginConfig?: Record<string, unknown>) {
@@ -88,7 +91,7 @@ function loadConfig(pluginConfig?: Record<string, unknown>) {
   if (pluginConfig.venue) config.venue = pluginConfig.venue as string;
 }
 
-async function refreshState(logger: { info: (m: string) => void; error: (m: string) => void }) {
+async function refreshState(logger: { info: (m: string) => void; warn: (m: string) => void; error: (m: string) => void }) {
   try {
     cachedState = await api.getAutomatonState();
     // Use automaton skills endpoint (respects per-user enable/disable prefs)
@@ -107,9 +110,12 @@ async function refreshState(logger: { info: (m: string) => void; error: (m: stri
         if (lastKnownStartedAt !== null) {
           logger.info(`[simmer] Detected re-init (started_at changed) — resetting cycle counter and bandit state`);
           cycleCount = 0;
+          config.epsilon = 0.2;
           banditState = [];
           currentSelectedMeta = [];
           lastCycleTimestamp = new Date().toISOString();
+          // Delete persisted bandit state so the next startup doesn't restore stale arms
+          api.resetBanditState().catch((e) => logger.warn(`[simmer] Failed to reset bandit state: ${e}`));
         }
         lastKnownStartedAt = cachedState.started_at;
       }
@@ -135,6 +141,7 @@ async function refreshState(logger: { info: (m: string) => void; error: (m: stri
           timesSelected: 0,
           timesRewarded: 0,
           totalPnl: 0,
+          ewmRoc: 0,
           consecutiveZeroSignals: 0,
           signalsFoundTotal: 0,
           tradesExecutedTotal: 0,
@@ -148,7 +155,7 @@ async function refreshState(logger: { info: (m: string) => void; error: (m: stri
 
 function fmtCurrency(amount: number): string {
   const val = amount.toFixed(2);
-  return config.venue === "simmer" ? `${val} $SIM` : `$${val}`;
+  return (config.venue === "sim" || config.venue === "simmer") ? `${val} $SIM` : `$${val}`;
 }
 
 function buildPromptContext(): string {
@@ -262,9 +269,83 @@ function formatStatus(): string {
     `Cycles: ${cycleCount}`,
     `Skills available: ${cachedSkills.length}`,
   ];
+
+  if (cachedPortfolio) {
+    const pnlStr = cachedPortfolio.totalPnl >= 0
+      ? `+${fmtCurrency(cachedPortfolio.totalPnl)}`
+      : fmtCurrency(cachedPortfolio.totalPnl);
+    lines.push(`Positions: ${cachedPortfolio.positionCount} open | P&L: ${pnlStr} | Recent trades: ${cachedPortfolio.recentTradeCount}`);
+    const top = cachedPortfolio.positions.slice(0, 3);
+    for (const p of top) {
+      const pnl = p.pnl >= 0 ? `+${fmtCurrency(p.pnl)}` : fmtCurrency(p.pnl);
+      lines.push(`  · ${p.question.slice(0, 55)} | ${p.side} | ${pnl}`);
+    }
+    if (cachedPortfolio.positions.length > 3) {
+      lines.push(`  · ...and ${cachedPortfolio.positions.length - 3} more (use /simmer portfolio for full list)`);
+    }
+  }
+
   return lines.join("\n");
 }
 
+// =============================================================================
+// Skill auto-update — keep installed skills at latest ClawHub version
+// =============================================================================
+
+/**
+ * Read installed skill versions from SKILL.md frontmatter.
+ * Returns { slug: version } for skills that have a parseable version.
+ */
+function getLocalSkillVersions(workspaceDir: string | undefined): Record<string, string> {
+  const fs = require("fs");
+  const cwd = workspaceDir || process.cwd();
+  const versions: Record<string, string> = {};
+  for (const skill of cachedSkills) {
+    const slug = skill.id;
+    try {
+      const skillMd = fs.readFileSync(`${cwd}/skills/${slug}/SKILL.md`, "utf-8");
+      const versionMatch = skillMd.match(/^\s*version:\s*["']?([^"'\n]+)["']?/m);
+      if (versionMatch) {
+        versions[slug] = versionMatch[1].trim();
+      }
+    } catch {
+      // Skill not installed locally or no SKILL.md — skip
+    }
+  }
+  return versions;
+}
+
+/**
+ * Check for outdated skills and auto-install updates.
+ * Uses the skill_updates from the most recent briefing response.
+ */
+async function checkAndUpdateSkills(
+  skillUpdates: Array<{ slug: string; current: string; latest: string; message: string }>,
+  workspaceDir: string | undefined,
+  logger: { info: (m: string) => void; warn: (m: string) => void; error: (m: string) => void },
+): Promise<void> {
+  if (!runtime || skillUpdates.length === 0) return;
+
+  const cwd = workspaceDir || process.cwd();
+  logger.info(`[simmer] ${skillUpdates.length} skill update(s) available: ${skillUpdates.map((u) => `${u.slug} ${u.current}→${u.latest}`).join(", ")}`);
+
+  for (const update of skillUpdates) {
+    try {
+      const result = await runtime.system.runCommandWithTimeout(
+        ["npx", "clawhub@latest", "install", update.slug, "--force"],
+        { timeoutMs: INSTALL_TIMEOUT_MS, cwd },
+      );
+      if (result.code === 0) {
+        logger.info(`[simmer] Updated ${update.slug} to ${update.latest}`);
+      } else {
+        logger.warn(`[simmer] Failed to update ${update.slug}: exit ${result.code} — ${result.stderr.slice(0, 200)}`);
+      }
+    } catch (e) {
+      logger.warn(`[simmer] Failed to update ${update.slug}: ${e}`);
+    }
+  }
+}
+
 // =============================================================================
 // Skill execution — deterministic, no LLM in the loop
 // =============================================================================
@@ -389,9 +470,51 @@ export default function register(pluginApi: PluginApi) {
       ctx.logger.info("[simmer] Automaton service starting");
       serviceRunning = true;
 
-      // Initial state fetch
+      // Initial state fetch (seeds banditState with current skills)
       await refreshState(ctx.logger);
 
+      // Restore persisted bandit arm statistics — overwrite in-memory state seeded above.
+      // This lets the bandit resume learning after a plugin restart without starting cold.
+      try {
+        const saved = await api.getBanditState();
+        if (saved && saved.arms.length > 0) {
+          const savedBySlug = new Map(saved.arms.map((a: BanditArmState) => [a.slug, a]));
+          banditState = banditState.map((arm) => {
+            const s = savedBySlug.get(arm.slug);
+            if (s) {
+              // Restore learned stats; keep live enabled status from skills registry
+              return {
+                ...s,
+                enabled: arm.enabled,
+              };
+            }
+            return arm; // new skill not in saved state — start fresh
+          });
+          config.epsilon = saved.epsilon;
+          cycleCount = saved.cycle_count;
+          ctx.logger.info(
+            `[simmer] Restored bandit state: ${saved.arms.length} arms, ε=${saved.epsilon.toFixed(3)}, cycle=${saved.cycle_count}`,
+          );
+        } else {
+          ctx.logger.info("[simmer] No saved bandit state — starting fresh");
+        }
+      } catch (e) {
+        ctx.logger.warn(`[simmer] Failed to restore bandit state: ${e}`);
+      }
+
+      // Check for skill updates on startup
+      try {
+        const skillVersions = getLocalSkillVersions(ctx.workspaceDir);
+        if (Object.keys(skillVersions).length > 0) {
+          const briefing = await api.getBriefing(skillVersions);
+          if (briefing.skill_updates && briefing.skill_updates.length > 0) {
+            await checkAndUpdateSkills(briefing.skill_updates, ctx.workspaceDir, ctx.logger);
+          }
+        }
+      } catch (e) {
+        ctx.logger.warn(`[simmer] Startup skill update check failed: ${e}`);
+      }
+
       // Periodic refresh
       cycleTimer = setInterval(async () => {
         if (!serviceRunning) return;
@@ -403,20 +526,28 @@ export default function register(pluginApi: PluginApi) {
         await refreshState(ctx.logger);
 
         // Query outcomes since last cycle and update bandit reward data
+        // Filter to outcomes matching this plugin's configured venue
         try {
           const outcomeRes = await api.getOutcomes(cycleStarted);
-          for (const o of outcomeRes.outcomes) {
+          const venueOutcomes = outcomeRes.outcomes.filter(
+            (o: SkillOutcome) => o.venue === config.venue
+          );
+          for (const o of venueOutcomes) {
             const skill = banditState.find((s) => s.slug === o.skill_slug);
             if (skill) {
               skill.tradesExecutedTotal += o.trades;
-              skill.timesRewarded += o.trades > 0 ? 1 : 0;
+              // Return-on-capital for this cycle (0 if no cost data)
+              const roc = o.total_cost > 0 ? o.period_pnl / o.total_cost : 0;
+              // Exponentially weighted RoC — decays stale data (~7-cycle half-life)
+              skill.ewmRoc = EWM_ALPHA * roc + (1 - EWM_ALPHA) * skill.ewmRoc;
+              skill.timesRewarded += roc > 0 ? 1 : 0;
               skill.totalPnl += o.period_pnl;
               skill.consecutiveZeroSignals = o.trades > 0 ? 0 : skill.consecutiveZeroSignals + 1;
             }
           }
           // Skills that were selected last cycle but had zero trades won't appear in outcomes
           // (GROUP BY only returns rows with trades). Increment consecutiveZeroSignals for them.
-          const outcomeSkillSlugs = new Set(outcomeRes.outcomes.map((o: SkillOutcome) => o.skill_slug));
+          const outcomeSkillSlugs = new Set(venueOutcomes.map((o: SkillOutcome) => o.skill_slug));
           for (const m of currentSelectedMeta) {
             if (!outcomeSkillSlugs.has(m.slug)) {
               const skill = banditState.find((s) => s.slug === m.slug);
@@ -425,8 +556,8 @@ export default function register(pluginApi: PluginApi) {
               }
             }
           }
-          if (outcomeRes.outcomes.length > 0) {
-            ctx.logger.info(`[simmer] Outcomes: ${outcomeRes.outcomes.map((o: SkillOutcome) => `${o.skill_slug}:${o.trades}t`).join(", ")}`);
+          if (venueOutcomes.length > 0) {
+            ctx.logger.info(`[simmer] Outcomes (${config.venue}): ${venueOutcomes.map((o: SkillOutcome) => `${o.skill_slug}:${o.trades}t/$${o.period_pnl.toFixed(2)}pnl`).join(", ")}`);
           }
         } catch (e) {
           ctx.logger.error(`[simmer] Failed to fetch outcomes: ${e}`);
@@ -476,6 +607,19 @@ export default function register(pluginApi: PluginApi) {
             cycle_number: thisCycleNumber,
             selection_meta: meta.map((m) => ({ slug: m.slug, reason: m.reason, score: m.score })),
             config_changes: configChangesPayload,
+            // Bandit persistence — write current arm stats so restarts resume where we left off
+            epsilon: parseFloat(config.epsilon.toFixed(6)),
+            bandit_arms: banditState.map((s) => ({
+              slug: s.slug,
+              enabled: s.enabled,
+              timesSelected: s.timesSelected,
+              timesRewarded: s.timesRewarded,
+              totalPnl: s.totalPnl,
+              consecutiveZeroSignals: s.consecutiveZeroSignals,
+              signalsFoundTotal: s.signalsFoundTotal,
+              tradesExecutedTotal: s.tradesExecutedTotal,
+              ewmRoc: s.ewmRoc,
+            })),
           });
         } catch (e) {
           ctx.logger.warn(`[simmer] Failed to post cycle (active_skills may be stale): ${e}`);
@@ -495,8 +639,9 @@ export default function register(pluginApi: PluginApi) {
 
         // Fetch portfolio snapshot for prompt context
         try {
-          const briefing = await api.getBriefing();
-          const venue = briefing.venues?.simmer;
+          const skillVersions = getLocalSkillVersions(ctx.workspaceDir);
+          const briefing = await api.getBriefing(skillVersions);
+          const venue = (briefing.venues as Record<string, any>)?.[config.venue];
           const attentionPositions = venue?.positions_needing_attention || [];
           cachedPortfolio = {
             totalPnl: briefing.performance?.total_pnl ?? 0,
@@ -504,6 +649,13 @@ export default function register(pluginApi: PluginApi) {
             positions: attentionPositions,
             recentTradeCount: 0,
           };
+
+          // Periodic skill auto-update
+          if (briefing.skill_updates && briefing.skill_updates.length > 0 &&
+              thisCycleNumber - lastUpdateCheckCycle >= UPDATE_CHECK_INTERVAL) {
+            lastUpdateCheckCycle = thisCycleNumber;
+            await checkAndUpdateSkills(briefing.skill_updates, ctx.workspaceDir, ctx.logger);
+          }
         } catch (e) {
           ctx.logger.warn(`[simmer] Failed to fetch briefing: ${e}`);
         }