spora 0.7.3 → 0.7.5

package/dist/prompt-builder-XJHXZCSQ.js

@@ -0,0 +1,27 @@
+import {
+  buildChatPrompt,
+  buildHeartbeatUserMessage,
+  buildOpportunityPortfolioMessage,
+  buildReflectionPrompt,
+  buildSystemPrompt,
+  buildToolDecisionMessage,
+  buildTrainingChatPrompt
+} from "./chunk-A2XTKC7B.js";
+import "./chunk-OTZNHIXT.js";
+import "./chunk-CAWWG3MD.js";
+import "./chunk-CP6JWCLY.js";
+import "./chunk-IULO3GRE.js";
+import "./chunk-RSNEVBEI.js";
+import "./chunk-QYFNAGNI.js";
+import "./chunk-BBXHECZ5.js";
+import "./chunk-ZWKTKWS6.js";
+export {
+  buildChatPrompt,
+  buildHeartbeatUserMessage,
+  buildOpportunityPortfolioMessage,
+  buildReflectionPrompt,
+  buildSystemPrompt,
+  buildToolDecisionMessage,
+  buildTrainingChatPrompt
+};
+//# sourceMappingURL=prompt-builder-XJHXZCSQ.js.map

package/dist/queue-QCGNDHH2.js

@@ -0,0 +1,14 @@
+import {
+  addToQueue,
+  flushQueue,
+  showQueue
+} from "./chunk-ZLSDFYBR.js";
+import "./chunk-RSNEVBEI.js";
+import "./chunk-QYFNAGNI.js";
+import "./chunk-ZWKTKWS6.js";
+export {
+  addToQueue,
+  flushQueue,
+  showQueue
+};
+//# sourceMappingURL=queue-QCGNDHH2.js.map

package/dist/strategy-R2BMRVJ3.js

@@ -0,0 +1,19 @@
+import {
+  applyStrategyUpdate,
+  deriveStrategyIntent,
+  extractHandlesFromText,
+  loadStrategy,
+  renderStrategyForPrompt,
+  saveStrategy
+} from "./chunk-OTZNHIXT.js";
+import "./chunk-IULO3GRE.js";
+import "./chunk-ZWKTKWS6.js";
+export {
+  applyStrategyUpdate,
+  deriveStrategyIntent,
+  extractHandlesFromText,
+  loadStrategy,
+  renderStrategyForPrompt,
+  saveStrategy
+};
+//# sourceMappingURL=strategy-R2BMRVJ3.js.map

package/dist/web-chat/chat.html

@@ -38,7 +38,7 @@
       margin-left: auto;
       display: flex;
       align-items: center;
-      gap: 0.5rem;
+      gap: 0.75rem;
     }
 
     .status-dot {
@@ -54,6 +54,82 @@
       color: rgba(255, 255, 255, 0.4);
     }
 
+    .heartbeat-menu {
+      position: relative;
+    }
+
+    .heartbeat-trigger {
+      width: 30px;
+      height: 30px;
+      border-radius: 999px;
+      border: 1px solid rgba(255, 255, 255, 0.15);
+      background: #141414;
+      color: #ff647d;
+      cursor: pointer;
+      font-size: 0.95rem;
+      line-height: 1;
+      display: inline-flex;
+      align-items: center;
+      justify-content: center;
+      transition: transform 0.15s ease, border-color 0.2s ease;
+    }
+
+    .heartbeat-trigger:hover {
+      transform: scale(1.06);
+      border-color: rgba(255, 100, 125, 0.45);
+    }
+
+    .heartbeat-trigger:disabled {
+      opacity: 0.4;
+      cursor: not-allowed;
+    }
+
+    .heartbeat-popover {
+      position: absolute;
+      right: 0;
+      top: calc(100% + 0.45rem);
+      min-width: 150px;
+      background: #111111;
+      border: 1px solid rgba(255, 255, 255, 0.14);
+      border-radius: 0.7rem;
+      padding: 0.5rem;
+      z-index: 10;
+      box-shadow: 0 8px 18px rgba(0, 0, 0, 0.45);
+      animation: fadeIn 0.18s ease-in;
+    }
+
+    .heartbeat-popover-title {
+      font-size: 0.67rem;
+      color: rgba(255, 255, 255, 0.44);
+      margin-bottom: 0.35rem;
+      padding: 0 0.2rem;
+      text-transform: uppercase;
+      letter-spacing: 0.04em;
+    }
+
+    .heartbeat-option {
+      width: 100%;
+      border: 1px solid transparent;
+      background: transparent;
+      color: rgba(255, 255, 255, 0.88);
+      padding: 0.42rem 0.5rem;
+      font-size: 0.75rem;
+      text-align: left;
+      border-radius: 0.5rem;
+      cursor: pointer;
+      transition: background 0.18s ease, border-color 0.18s ease;
+    }
+
+    .heartbeat-option:hover {
+      background: rgba(255, 255, 255, 0.06);
+    }
+
+    .heartbeat-option.active {
+      border-color: rgba(56, 158, 119, 0.65);
+      background: rgba(56, 158, 119, 0.16);
+      color: #89dbba;
+    }
+
     @keyframes pulse {
       0%, 100% { opacity: 1; }
       50% { opacity: 0.5; }
@@ -328,7 +404,18 @@
     </svg>
     <div class="header-right">
       <span class="status-dot"></span>
-      <span class="status-text">Online</span>
+      <span class="status-text" id="statusText">Online</span>
+      <div class="heartbeat-menu" id="heartbeatMenu">
+        <button class="heartbeat-trigger" id="heartbeatTrigger" title="Heartbeat settings" aria-label="Heartbeat settings">♥</button>
+        <div class="heartbeat-popover" id="heartbeatPopover" hidden>
+          <div class="heartbeat-popover-title">Heartbeat</div>
+          <button class="heartbeat-option" data-interval="60000">1 min</button>
+          <button class="heartbeat-option" data-interval="300000">5 min</button>
+          <button class="heartbeat-option" data-interval="1800000">30 min</button>
+          <button class="heartbeat-option" data-interval="3600000">1 hour</button>
+          <button class="heartbeat-option" data-interval="21600000">6 hours</button>
+        </div>
+      </div>
     </div>
   </div>
 
@@ -350,12 +437,86 @@
     const chatContainer = document.getElementById('chatContainer');
     const messageInput = document.getElementById('messageInput');
     const sendButton = document.getElementById('sendButton');
+    const heartbeatMenu = document.getElementById('heartbeatMenu');
+    const heartbeatTrigger = document.getElementById('heartbeatTrigger');
+    const heartbeatPopover = document.getElementById('heartbeatPopover');
+    const heartbeatOptions = Array.from(document.querySelectorAll('.heartbeat-option'));
+    const statusText = document.getElementById('statusText');
 
     let isLoading = false;
     let agentName = 'Your Spore';
     let agentHandle = '';
     let agentPfp = null;
     let sleepTimerId = null;
+    let heartbeatMs = 300000;
+
+    const HEARTBEAT_LABELS = {
+      60000: '1 min',
+      300000: '5 min',
+      1800000: '30 min',
+      3600000: '1 hour',
+      21600000: '6 hours',
+    };
+
+    function heartbeatLabel(ms) {
+      return HEARTBEAT_LABELS[ms] || `${Math.round(ms / 60000)} min`;
+    }
+
+    function updateStatusText() {
+      statusText.textContent = `Online • ${heartbeatLabel(heartbeatMs)} heartbeat`;
+    }
+
+    function setHeartbeatPopoverOpen(isOpen) {
+      heartbeatPopover.hidden = !isOpen;
+    }
+
+    function updateHeartbeatOptions() {
+      for (const option of heartbeatOptions) {
+        const value = parseInt(option.dataset.interval || '0', 10);
+        option.classList.toggle('active', value === heartbeatMs);
+      }
+    }
+
+    async function loadHeartbeatConfig() {
+      try {
+        const response = await fetch('/api/heartbeat-config');
+        if (!response.ok) return;
+        const data = await response.json();
+        if (data.intervalMs) {
+          heartbeatMs = data.intervalMs;
+          updateStatusText();
+          updateHeartbeatOptions();
+        }
+      } catch {
+        // best effort
+      }
+    }
+
+    async function setHeartbeatConfig(intervalMs) {
+      const previous = heartbeatMs;
+      heartbeatTrigger.disabled = true;
+      setHeartbeatPopoverOpen(false);
+      try {
+        const response = await fetch('/api/heartbeat-config', {
+          method: 'POST',
+          headers: { 'Content-Type': 'application/json' },
+          body: JSON.stringify({ intervalMs }),
+        });
+        if (!response.ok) {
+          throw new Error('Failed to update heartbeat');
+        }
+        heartbeatMs = intervalMs;
+        updateStatusText();
+        updateHeartbeatOptions();
+        addNarration(`Heartbeat updated to ${heartbeatLabel(intervalMs)}`, 'action');
+      } catch {
+        heartbeatMs = previous;
+        updateHeartbeatOptions();
+        addNarration('Could not update heartbeat interval', 'error');
+      } finally {
+        heartbeatTrigger.disabled = false;
+      }
+    }
 
     // ===== Init =====
     async function init() {
@@ -372,6 +533,7 @@
         console.error('Failed to load identity:', error);
       }
 
+      await loadHeartbeatConfig();
       addMessage('assistant', `Hey! I'm ${agentName}. I run on my own — posting, replying, exploring X during my heartbeat cycles. You can shape who I am by chatting with me here.`);
       await loadMessages();
     }
@@ -480,7 +642,6 @@
 
     // ===== Narration =====
     function addNarration(text, type) {
-      removeSleepCard();
       const el = document.createElement('div');
       el.className = 'narration';
       const dot = document.createElement('div');
@@ -588,6 +749,30 @@
     }
 
     sendButton.addEventListener('click', sendMessage);
+    heartbeatTrigger.addEventListener('click', (e) => {
+      e.preventDefault();
+      e.stopPropagation();
+      setHeartbeatPopoverOpen(heartbeatPopover.hidden);
+    });
+
+    heartbeatPopover.addEventListener('click', (e) => {
+      const target = e.target.closest('.heartbeat-option');
+      if (!target) return;
+      const intervalMs = parseInt(target.dataset.interval || '0', 10);
+      if (!Number.isFinite(intervalMs)) return;
+      if (intervalMs === heartbeatMs) {
+        setHeartbeatPopoverOpen(false);
+        return;
+      }
+      setHeartbeatConfig(intervalMs);
+    });
+
+    document.addEventListener('click', (e) => {
+      if (!heartbeatMenu.contains(e.target)) {
+        setHeartbeatPopoverOpen(false);
+      }
+    });
+
     messageInput.addEventListener('keydown', (e) => {
       if (e.key === 'Enter' && !e.shiftKey) {
         e.preventDefault();
@@ -642,6 +827,8 @@
     setInterval(pollAgentEvents, 2000);
 
     // Initialize
+    updateStatusText();
+    updateHeartbeatOptions();
     init();
     messageInput.focus();
   </script>

package/dist/{web-chat-O24HGJVE.js → web-chat-TB3ACPVF.js}

@@ -1,7 +1,7 @@
 import {
   loadIdentity
-} from "./chunk-M6YOQVSI.js";
-import "./chunk-3RYCUGXE.js";
+} from "./chunk-IULO3GRE.js";
+import "./chunk-ZWKTKWS6.js";
 
 // src/web-chat/server.ts
 import http from "http";
@@ -11,6 +11,7 @@ import { join, dirname } from "path";
 import { fileURLToPath } from "url";
 var __filename = fileURLToPath(import.meta.url);
 var __dirname = dirname(__filename);
+var ALLOWED_HEARTBEAT_INTERVALS = [6e4, 3e5, 18e5, 36e5, 216e5];
 var WebChatServer = class {
   server = null;
   port;
@@ -19,6 +20,7 @@ var WebChatServer = class {
   agentEvents = [];
   onUserMessage;
   identity;
+  heartbeatConfigHandlers;
   constructor(port = 3737) {
     this.port = port;
   }
@@ -28,6 +30,9 @@ var WebChatServer = class {
   setMessageHandler(handler) {
     this.onUserMessage = handler;
   }
+  setHeartbeatConfigHandlers(handlers) {
+    this.heartbeatConfigHandlers = handlers;
+  }
   /** Push an activity update (from heartbeat) to the UI — kept for backwards compat */
   pushActivity(type, message) {
     this.activities.push({ type, message, timestamp: Date.now() });
@@ -109,6 +114,52 @@ var WebChatServer = class {
           res.end(JSON.stringify({ events: newEvents }));
           return;
         }
+        if (url.pathname === "/api/heartbeat-config" && req.method === "GET") {
+          if (!this.heartbeatConfigHandlers) {
+            res.writeHead(503, { "Content-Type": "application/json" });
+            res.end(JSON.stringify({ error: "Heartbeat config unavailable" }));
+            return;
+          }
+          try {
+            const intervalMs = await this.heartbeatConfigHandlers.getIntervalMs();
+            res.writeHead(200, { "Content-Type": "application/json" });
+            res.end(JSON.stringify({ intervalMs, allowedIntervals: ALLOWED_HEARTBEAT_INTERVALS }));
+          } catch {
+            res.writeHead(500, { "Content-Type": "application/json" });
+            res.end(JSON.stringify({ error: "Failed to load heartbeat config" }));
+          }
+          return;
+        }
+        if (url.pathname === "/api/heartbeat-config" && req.method === "POST") {
+          if (!this.heartbeatConfigHandlers) {
+            res.writeHead(503, { "Content-Type": "application/json" });
+            res.end(JSON.stringify({ error: "Heartbeat config unavailable" }));
+            return;
+          }
+          const handlers = this.heartbeatConfigHandlers;
+          let body = "";
+          req.on("data", (chunk) => {
+            body += chunk.toString();
+          });
+          req.on("end", async () => {
+            try {
+              const parsed = JSON.parse(body);
+              const intervalMs = parsed.intervalMs;
+              if (typeof intervalMs !== "number" || !Number.isInteger(intervalMs) || !ALLOWED_HEARTBEAT_INTERVALS.includes(intervalMs)) {
+                res.writeHead(400, { "Content-Type": "application/json" });
+                res.end(JSON.stringify({ error: "Unsupported heartbeat interval" }));
+                return;
+              }
+              await handlers.setIntervalMs(intervalMs);
+              res.writeHead(200, { "Content-Type": "application/json" });
+              res.end(JSON.stringify({ success: true, intervalMs }));
+            } catch {
+              res.writeHead(400, { "Content-Type": "application/json" });
+              res.end(JSON.stringify({ error: "Invalid request" }));
+            }
+          });
+          return;
+        }
         if (url.pathname === "/api/message" && req.method === "POST") {
           let body = "";
           req.on("data", (chunk) => {
@@ -171,11 +222,18 @@ var WebChatServer = class {
 // src/web-chat/index.ts
 import { execSync } from "child_process";
 import chalk from "chalk";
+var HEARTBEAT_INTERVAL_OPTIONS = [6e4, 3e5, 18e5, 36e5, 216e5];
+function formatHeartbeatInterval(intervalMs) {
+  const minutes = intervalMs / 6e4;
+  if (minutes < 60) return `${minutes} minute${minutes === 1 ? "" : "s"}`;
+  const hours = minutes / 60;
+  return `${hours} hour${hours === 1 ? "" : "s"}`;
+}
 async function extractAndSaveLearnings(responseText) {
   const learnPattern = /<<LEARN:\s*(.+?)>>/g;
   const matches = [...responseText.matchAll(learnPattern)];
   if (matches.length > 0) {
-    const { addLearning } = await import("./memory-OIAH33G2.js");
+    const { addLearning } = await import("./memory-DTSLVSQG.js");
     for (const match of matches) {
       const learning = match[1].trim();
       addLearning(learning, "web-chat", ["chat", "creator-interaction"]);
@@ -191,7 +249,7 @@ async function extractAndApplyTraining(responseText) {
     try {
       const update = JSON.parse(match[1].trim());
       if (update.identity) {
-        const { loadIdentity: loadIdentity2, mutateIdentity, saveIdentity } = await import("./identity-VDUW4I2K.js");
+        const { loadIdentity: loadIdentity2, mutateIdentity, saveIdentity } = await import("./identity-ASHVWIN5.js");
         let identity = loadIdentity2();
         const identityFields = {
           tone: "tone",
@@ -230,7 +288,7 @@ async function extractAndApplyTraining(responseText) {
         saveIdentity(identity);
       }
       if (update.strategy) {
-        const { loadStrategy, saveStrategy } = await import("./strategy-Z4JSFHSP.js");
+        const { loadStrategy, saveStrategy } = await import("./strategy-R2BMRVJ3.js");
         const strategy = loadStrategy();
         if (update.strategy.currentFocus) strategy.currentFocus = update.strategy.currentFocus;
         if (update.strategy.shortTermGoals) strategy.shortTermGoals = update.strategy.shortTermGoals;
@@ -245,7 +303,7 @@ async function extractAndApplyTraining(responseText) {
         console.log(chalk.dim(`  [Training] Updated strategy`));
       }
       if (update.learning) {
-        const { addLearning } = await import("./memory-OIAH33G2.js");
+        const { addLearning } = await import("./memory-DTSLVSQG.js");
         addLearning(
           update.learning.content,
           "training-chat",
@@ -254,7 +312,7 @@ async function extractAndApplyTraining(responseText) {
         console.log(chalk.dim(`  [Training] Saved learning: ${update.learning.content}`));
       }
       if (update.reflection) {
-        const { loadIdentity: loadIdentity2, saveIdentity } = await import("./identity-VDUW4I2K.js");
+        const { loadIdentity: loadIdentity2, saveIdentity } = await import("./identity-ASHVWIN5.js");
         const identity = loadIdentity2();
         identity.evolutionJournal.push({
           date: (/* @__PURE__ */ new Date()).toISOString(),
@@ -264,7 +322,7 @@ async function extractAndApplyTraining(responseText) {
         console.log(chalk.dim(`  [Training] Added reflection to evolution journal`));
       }
       if (update.goalUpdates && Array.isArray(update.goalUpdates)) {
-        const { loadGoals, saveGoals } = await import("./goals-RBKLMILE.js");
+        const { loadGoals, saveGoals } = await import("./goals-QWX3A47Y.js");
         const tracker = loadGoals();
         for (const gu of update.goalUpdates) {
           const existing = tracker.goals.find((g) => g.goal === gu.goal);
@@ -290,7 +348,7 @@ async function extractAndApplyTraining(responseText) {
   return responseText.replace(/<<TRAINING:[\s\S]*?>>/g, "").trim();
 }
 async function logChatInteraction(userMessage, agentResponse) {
-  const { logInteraction } = await import("./memory-OIAH33G2.js");
+  const { logInteraction } = await import("./memory-DTSLVSQG.js");
   logInteraction({
     id: `chat-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`,
     timestamp: (/* @__PURE__ */ new Date()).toISOString(),
@@ -302,26 +360,46 @@ async function logChatInteraction(userMessage, agentResponse) {
   });
 }
 async function runNarratedHeartbeat(server) {
-  const { loadConfig } = await import("./config-FL4VJVKZ.js");
-  const { flushQueue } = await import("./queue-D3MRKABU.js");
-  const { runAutonomyCycle } = await import("./autonomy-6UWPXTPD.js");
-  const { buildReflectionPrompt } = await import("./prompt-builder-KJKFCGM7.js");
-  const { generateResponse } = await import("./llm-OGOYCWBH.js");
-  const { addLearning } = await import("./memory-OIAH33G2.js");
-  const { loadStrategy, saveStrategy } = await import("./strategy-Z4JSFHSP.js");
-  const config = loadConfig();
-  const intervalMs = config.runtime?.heartbeatIntervalMs ?? 3e5;
-  const maxActions = config.runtime?.actionsPerHeartbeat ?? 4;
+  const { loadConfig } = await import("./config-MU2ODEO3.js");
+  const { flushQueue } = await import("./queue-QCGNDHH2.js");
+  const { runAutonomyCycle } = await import("./autonomy-DFPA3OK6.js");
+  const { buildReflectionPrompt } = await import("./prompt-builder-XJHXZCSQ.js");
+  const { generateResponse } = await import("./llm-IJBRQ7O2.js");
+  const { addLearning } = await import("./memory-DTSLVSQG.js");
+  const { loadStrategy, saveStrategy, applyStrategyUpdate } = await import("./strategy-R2BMRVJ3.js");
   let heartbeatCount = 0;
-  console.log(chalk.cyan(`  [Agent] Autonomous heartbeat started (every ${Math.round(intervalMs / 6e4)} min)`));
+  let lastIntervalMs = loadConfig().runtime?.heartbeatIntervalMs ?? 3e5;
+  console.log(chalk.cyan(`  [Agent] Autonomous heartbeat started (every ${Math.round(lastIntervalMs / 6e4)} min)`));
   while (true) {
+    const runtimeConfig = loadConfig();
+    const intervalMs = runtimeConfig.runtime?.heartbeatIntervalMs ?? 3e5;
+    const maxActions = runtimeConfig.runtime?.actionsPerHeartbeat ?? 4;
+    if (intervalMs !== lastIntervalMs) {
+      server.pushAgentEvent("narration", `Heartbeat interval updated to ${formatHeartbeatInterval(intervalMs)}.`);
+      console.log(chalk.cyan(`  [Agent] Heartbeat interval updated to ${Math.round(intervalMs / 6e4)} min`));
+      lastIntervalMs = intervalMs;
+    }
     const jitter = Math.floor(Math.random() * intervalMs * 0.3);
     const sleepMs = heartbeatCount === 0 ? 1e4 : intervalMs + jitter;
     const wakeUpAt = Date.now() + sleepMs;
     if (heartbeatCount > 0) {
       server.pushAgentEvent("sleep", "sleeping", { wakeUpAt });
     }
-    await new Promise((r) => setTimeout(r, sleepMs));
+    let sleptMs = 0;
+    let intervalChangedDuringSleep = false;
+    while (sleptMs < sleepMs) {
+      const chunkMs = Math.min(1e3, sleepMs - sleptMs);
+      await new Promise((r) => setTimeout(r, chunkMs));
+      sleptMs += chunkMs;
+      const liveIntervalMs = loadConfig().runtime?.heartbeatIntervalMs ?? 3e5;
+      if (liveIntervalMs !== intervalMs) {
+        intervalChangedDuringSleep = true;
+        break;
+      }
+    }
+    if (intervalChangedDuringSleep) {
+      continue;
+    }
     heartbeatCount++;
     console.log(chalk.cyan(`  [Agent] Heartbeat #${heartbeatCount}`));
     server.pushAgentEvent("wake", `Waking up... heartbeat #${heartbeatCount}`);
@@ -334,7 +412,7 @@ async function runNarratedHeartbeat(server) {
       } catch {
       }
       server.pushAgentEvent("narration", "Observing timeline and planning actions...");
-      const cycle = await runAutonomyCycle(maxActions);
+      const cycle = await runAutonomyCycle(maxActions, heartbeatCount);
       if (cycle.timeline.length > 0 || cycle.mentions.length > 0) {
         server.pushAgentEvent("narration", `Found ${cycle.timeline.length} timeline posts and ${cycle.mentions.length} mentions`);
       }
@@ -395,12 +473,7 @@ async function runNarratedHeartbeat(server) {
               }
               if (reflection.strategyUpdate && reflection.strategyUpdate !== "null") {
                 const strategy = loadStrategy();
-                strategy.experiments.push({
-                  description: reflection.strategyUpdate,
-                  status: "pending"
-                });
-                strategy.lastUpdated = (/* @__PURE__ */ new Date()).toISOString();
-                saveStrategy(strategy);
+                saveStrategy(applyStrategyUpdate(strategy, reflection.strategyUpdate));
                 server.pushAgentEvent("narration", `Strategy: ${reflection.strategyUpdate}`);
                 console.log(chalk.dim(`  [Agent] Strategy update: ${reflection.strategyUpdate}`));
               }
@@ -420,6 +493,7 @@ async function runNarratedHeartbeat(server) {
 }
 async function startWebChat() {
   const identity = loadIdentity();
+  const { loadConfig: loadRuntimeConfig, saveConfig } = await import("./config-MU2ODEO3.js");
   const server = new WebChatServer();
   server.setIdentity({
     name: identity.name,
@@ -427,17 +501,36 @@ async function startWebChat() {
     bio: identity.bio,
     profileImage: identity.profileImage
   });
+  server.setHeartbeatConfigHandlers({
+    getIntervalMs: () => {
+      const config = loadRuntimeConfig();
+      return config.runtime?.heartbeatIntervalMs ?? 3e5;
+    },
+    setIntervalMs: (intervalMs) => {
+      if (!HEARTBEAT_INTERVAL_OPTIONS.includes(intervalMs)) {
+        throw new Error("Unsupported heartbeat interval.");
+      }
+      const config = loadRuntimeConfig();
+      config.runtime = {
+        heartbeatIntervalMs: intervalMs,
+        actionsPerHeartbeat: config.runtime?.actionsPerHeartbeat ?? 4,
+        enabled: true
+      };
+      saveConfig(config);
+      server.pushAgentEvent("narration", `Heartbeat interval set to ${formatHeartbeatInterval(intervalMs)}.`);
+    }
+  });
   const chatHistory = [];
   let systemPrompt = null;
   let messageCount = 0;
   server.setMessageHandler(async (message) => {
     try {
       if (!systemPrompt || messageCount % 10 === 0) {
-        const { buildTrainingChatPrompt } = await import("./prompt-builder-KJKFCGM7.js");
+        const { buildTrainingChatPrompt } = await import("./prompt-builder-XJHXZCSQ.js");
         systemPrompt = buildTrainingChatPrompt();
       }
       messageCount++;
-      const { hasLLMKey, chat: chatLLM } = await import("./llm-OGOYCWBH.js");
+      const { hasLLMKey, chat: chatLLM } = await import("./llm-IJBRQ7O2.js");
       if (!hasLLMKey()) {
         return "I can't respond right now - no API key configured. Run `spora llm set --provider <provider>` to set one up.";
       }
@@ -463,7 +556,7 @@ async function startWebChat() {
 `));
   openBrowser(url);
   try {
-    const { hasLLMKey } = await import("./llm-OGOYCWBH.js");
+    const { hasLLMKey } = await import("./llm-IJBRQ7O2.js");
     if (hasLLMKey()) {
       runNarratedHeartbeat(server).catch((err) => {
         console.error(chalk.red(`Heartbeat failed to start: ${err}`));
@@ -516,4 +609,4 @@ export {
   openBrowser,
   startWebChat
 };
-//# sourceMappingURL=web-chat-O24HGJVE.js.map
+//# sourceMappingURL=web-chat-TB3ACPVF.js.map