groove-dev 0.27.14 → 0.27.17

package/node_modules/@groove-dev/daemon/src/index.js

@@ -40,6 +40,7 @@ import { TunnelManager } from './tunnel-manager.js';
 import { ModelManager } from './model-manager.js';
 import { LlamaServerManager } from './llama-server.js';
 import { RepoImporter } from './repo-import.js';
+import { Toys } from './toys.js';
 import { isFirstRun, runFirstTimeSetup, loadConfig, saveConfig, printWelcome } from './firstrun.js';
 
 const DEFAULT_PORT = 31415;
@@ -141,26 +142,48 @@ export class Daemon {
     this.mcpManager = new McpManager(this);
     this.tunnelManager = new TunnelManager(this);
     this.repoImporter = new RepoImporter(this);
+    this.toys = new Toys(this);
+
+    // Subscription state (populated by Electron IPC or direct auth)
+    this.authToken = null;
+    this.subscriptionCache = { plan: 'community', status: 'none', features: [], active: false, validatedAt: 0 };
 
     // HTTP + WebSocket server
     this.app = express();
     this.server = createHttpServer(this.app);
-    this.wss = new WebSocketServer({
-      server: this.server,
-      maxPayload: 1024 * 1024, // 1MB max message
-      verifyClient: ({ req }) => {
-        const origin = req.headers.origin;
-        // Allow: no origin (CLI/native clients)
-        if (!origin) return true;
-        try {
-          const url = new URL(origin);
-          // Allow any localhost origin (any port — tunnels change the port)
-          if (url.hostname === 'localhost' || url.hostname === '127.0.0.1') return true;
-          // Allow the bound interface (for Tailscale/LAN access)
-          if (this.host !== DEFAULT_HOST && url.hostname === this.host) return true;
-        } catch { /* invalid origin */ }
-        return false;
-      },
+
+    const verifyOrigin = (req) => {
+      const origin = req.headers.origin;
+      if (!origin) return true;
+      try {
+        const url = new URL(origin);
+        if (url.hostname === 'localhost' || url.hostname === '127.0.0.1') return true;
+        if (this.host !== DEFAULT_HOST && url.hostname === this.host) return true;
+      } catch { /* invalid origin */ }
+      return false;
+    };
+
+    this.wss = new WebSocketServer({ noServer: true, maxPayload: 1024 * 1024 });
+    this.federationWss = new WebSocketServer({ noServer: true, maxPayload: 1024 * 1024 });
+
+    this.server.on('upgrade', (req, socket, head) => {
+      if (!verifyOrigin(req) && !req.url?.startsWith('/ws/federation')) {
+        socket.destroy();
+        return;
+      }
+      if (req.url?.startsWith('/ws/federation')) {
+        const daemonId = req.headers['x-groove-daemonid'];
+        const signatureHeader = req.headers['x-groove-signature'] || '';
+        const callerIp = req.socket?.remoteAddress?.replace('::ffff:', '') || '';
+        if (!daemonId) { socket.destroy(); return; }
+        this.federationWss.handleUpgrade(req, socket, head, (ws) => {
+          this.federation.handleWsUpgrade(ws, daemonId, callerIp, signatureHeader);
+        });
+      } else {
+        this.wss.handleUpgrade(req, socket, head, (ws) => {
+          this.wss.emit('connection', ws, req);
+        });
+      }
     });
 
     // Wire up API routes
@@ -203,18 +226,38 @@ export class Daemon {
       ws.on('message', (raw) => {
         try {
           const msg = JSON.parse(raw);
+
+          // Validate message type against whitelist
+          const VALID_WS_TYPES = new Set([
+            'terminal:spawn', 'terminal:resize', 'terminal:input', 'terminal:close', 'terminal:kill', 'terminal:rename',
+            'editor:watch', 'editor:unwatch', 'editor:save',
+            'ping'
+          ]);
+          if (!msg || typeof msg !== 'object' || !VALID_WS_TYPES.has(msg.type)) return;
+          if (Object.hasOwn(msg, '__proto__') || Object.hasOwn(msg, 'constructor')) return;
+
           switch (msg.type) {
             // File editor
             case 'editor:watch':
-              if (msg.path) { this.fileWatcher.watch(msg.path); watchedFiles.add(msg.path); }
+              if (msg.path && typeof msg.path === 'string' && !msg.path.includes('..')) {
+                this.fileWatcher.watch(msg.path); watchedFiles.add(msg.path);
+              }
               break;
             case 'editor:unwatch':
               if (msg.path) { this.fileWatcher.unwatch(msg.path); watchedFiles.delete(msg.path); }
               break;
             // Terminal
             case 'terminal:spawn': {
-              const id = this.terminalManager.spawn(ws, { cwd: msg.cwd, cols: msg.cols, rows: msg.rows });
-              ws.send(JSON.stringify({ type: 'terminal:spawned', id }));
+              if (msg.cwd !== undefined && (typeof msg.cwd !== 'string' || msg.cwd.includes('..'))) break;
+              if (msg.cols !== undefined && (typeof msg.cols !== 'number' || msg.cols < 1 || msg.cols > 500)) break;
+              if (msg.rows !== undefined && (typeof msg.rows !== 'number' || msg.rows < 1 || msg.rows > 200)) break;
+              try {
+                const id = this.terminalManager.spawn(ws, { cwd: msg.cwd, cols: msg.cols, rows: msg.rows });
+                ws.send(JSON.stringify({ type: 'terminal:spawned', id }));
+              } catch (err) {
+                console.error('[terminal] spawn error:', err);
+                ws.send(JSON.stringify({ type: 'terminal:error', message: err.message }));
+              }
               break;
             }
             case 'terminal:input':
@@ -226,6 +269,13 @@ export class Daemon {
             case 'terminal:kill':
               if (msg.id) this.terminalManager.kill(msg.id);
               break;
+            case 'terminal:rename':
+              if (msg.id && typeof msg.label === 'string') {
+                if (this.terminalManager.rename(msg.id, msg.label)) {
+                  this.broadcast({ type: 'terminal:renamed', id: msg.id, label: msg.label });
+                }
+              }
+              break;
           }
         } catch { /* ignore malformed messages */ }
       });
@@ -248,6 +298,7 @@ export class Daemon {
   }
 
   broadcast(message) {
+    if (!this.wss) return;
     const payload = JSON.stringify(message);
     for (const client of this.wss.clients) {
       if (client.readyState === 1) {
@@ -256,6 +307,66 @@ export class Daemon {
     }
   }
 
+  async setAuthToken(token) {
+    this.authToken = token;
+    if (token) {
+      await this._pollSubscription();
+      // Fallback: if external API failed, try syncing from stored user data
+      if (!this.subscriptionCache?.active) {
+        this.skills?._syncSubscriptionCache(this.skills?.getUser());
+      }
+    } else {
+      this.subscriptionCache = { plan: 'community', status: 'none', features: [], active: false, validatedAt: Date.now() };
+      this.broadcast({ type: 'subscription:updated', data: this.subscriptionCache });
+    }
+  }
+
+  async _pollSubscription() {
+    if (!this.authToken) return;
+    const API_BASE = 'https://docs.groovedev.ai/api/v1';
+    const delays = [0, 5000, 15000, 30000];
+    for (let attempt = 0; attempt < delays.length; attempt++) {
+      if (attempt > 0) await new Promise((r) => setTimeout(r, delays[attempt]));
+      try {
+        const resp = await fetch(`${API_BASE}/subscription/status`, {
+          headers: { 'Authorization': `Bearer ${this.authToken}` },
+          signal: AbortSignal.timeout(10000),
+        });
+        if (resp.status === 401) {
+          this.subscriptionCache = { plan: 'community', status: 'none', features: [], active: false, validatedAt: Date.now() };
+          this.broadcast({ type: 'subscription:updated', data: this.subscriptionCache });
+          this.broadcast({ type: 'auth:expired' });
+          return;
+        }
+        if (!resp.ok) throw new Error(`HTTP ${resp.status}`);
+        const data = await resp.json();
+        this.subscriptionCache = {
+          plan: data.plan || 'community',
+          status: data.status || 'none',
+          features: data.features || [],
+          active: data.status === 'active' || data.status === 'trialing',
+          seats: data.seats || 1,
+          periodEnd: data.periodEnd || null,
+          cancelAtPeriodEnd: data.cancelAtPeriodEnd || false,
+          validatedAt: Date.now(),
+        };
+        this.broadcast({ type: 'subscription:updated', data: this.subscriptionCache });
+        return;
+      } catch (err) {
+        if (attempt < delays.length - 1) {
+          console.log(`[Groove:Subscription] Attempt ${attempt + 1} failed, retrying in ${delays[attempt + 1] / 1000}s...`);
+          continue;
+        }
+        if (this.subscriptionCache?.validatedAt && (Date.now() - this.subscriptionCache.validatedAt < 72 * 3600 * 1000)) {
+          console.log('[Groove:Subscription] External API unreachable, keeping cached subscription');
+          return;
+        }
+        this.subscriptionCache = { plan: 'community', status: 'none', features: [], active: false, validatedAt: 0 };
+        this.broadcast({ type: 'subscription:updated', data: this.subscriptionCache });
+      }
+    }
+  }
+
   async start() {
     // Kill any existing daemon on our port
     if (existsSync(this.pidFile)) {
@@ -317,6 +428,8 @@ export class Daemon {
 
     return new Promise((resolvePromise) => {
       this.server.listen(this.port, this.host, () => {
+        // Read back actual port (critical for port 0 / dynamic allocation)
+        this.port = this.server.address().port;
         writeFileSync(this.pidFile, String(process.pid));
         // Write actual port and host so CLI can find us
         writeFileSync(resolve(this.grooveDir, 'daemon.port'), String(this.port));
@@ -330,8 +443,34 @@ export class Daemon {
         this.scheduler.start();
         this.timeline.start();
         this.gateways.start();
+        this.federation.initialize();
         this._startGarbageCollector();
 
+        // Restore auth token from stored config so subscription polling works after restart
+        const storedToken = this.skills.getToken();
+        if (storedToken) {
+          this.authToken = storedToken;
+          this._pollSubscription().catch(() => {});
+        }
+
+        // Re-validate subscription every 30 minutes
+        this._subscriptionPollInterval = setInterval(() => {
+          this._pollSubscription().catch(() => {});
+        }, 30 * 60 * 1000);
+
+        // Classifier broadcasting — decoupled from stdout handler
+        // Runs every 30s, checks for classification changes, broadcasts to GUI
+        this._classifierInterval = setInterval(() => {
+          try {
+            const updates = this.classifier.getUpdates();
+            for (const update of updates) {
+              this.broadcast({ type: 'classifier:update', data: update });
+            }
+          } catch {
+            // Never let classifier broadcasting break the daemon
+          }
+        }, 30_000);
+
         // Scan codebase for workspace/structure awareness
         this.indexer.scan();
 
@@ -353,6 +492,9 @@ export class Daemon {
           this.tokens.setProjectStats(stats.totalFiles, stats.totalDirs);
         }
 
+        // Auto-connect saved tunnels that have autoConnect enabled
+        this.tunnelManager.init();
+
         resolvePromise(this);
       });
     });
@@ -362,6 +504,11 @@ export class Daemon {
     // Run once on startup, then every 24 hours
     this._gc();
     this._gcInterval = setInterval(() => this._gc(), 24 * 60 * 60 * 1000);
+
+    // Periodic state save — crash protection (every 30s)
+    this._stateSaveInterval = setInterval(() => {
+      try { this.state.set('agents', this.registry.getAll()); this.state.save(); } catch {}
+    }, 30000);
   }
 
   _gc() {
@@ -449,11 +596,17 @@ export class Daemon {
     this.scheduler.stop();
     this.timeline.stop();
     if (this._gcInterval) clearInterval(this._gcInterval);
+    if (this._stateSaveInterval) clearInterval(this._stateSaveInterval);
+    if (this._classifierInterval) clearInterval(this._classifierInterval);
+    if (this._subscriptionPollInterval) clearInterval(this._subscriptionPollInterval);
 
     // Clean up file watchers and terminal sessions
     this.fileWatcher.unwatchAll();
     this.terminalManager.killAll();
 
+    // Clean up federation (whitelist probing, connections, ambassadors)
+    this.federation.destroy();
+
     // Disconnect all SSH tunnels
     this.tunnelManager.shutdown();
 

package/node_modules/@groove-dev/daemon/src/introducer.js

@@ -14,7 +14,7 @@ export class Introducer {
   }
 
   generateContext(newAgent, options = {}) {
-    const { taskNegotiation } = options;
+    const { taskNegotiation, hasTask } = options;
     const agents = this.daemon.registry.getAll();
     // Only include ACTIVE agents — not completed/killed ones from previous sessions
     // Completed agents' work is captured in the journalist's project map, not here
@@ -178,11 +178,11 @@ export class Introducer {
     lines.push(`If you see files that seem unrelated to your task, leave them alone — they belong to another project or agent.`);
 
     // Memory containment — prevent agents from reading/writing auto-memory
-    // which can contain stale context from unrelated sessions in the same dir
+    // GROOVE manages project memory automatically via Layer 7
     lines.push('');
     lines.push(`## Memory Policy`);
     lines.push('');
-    lines.push(`Ignore auto-memory. Do NOT read or write MEMORY.md or any files in the auto-memory directory.`);
+    lines.push(`GROOVE manages project memory automatically. Do not read or write MEMORY.md or .groove/memory/ files directly.`);
     lines.push(`GROOVE provides all your project context through handoff briefs, AGENTS_REGISTRY.md, and GROOVE_PROJECT_MAP.md.`);
     lines.push(`Do NOT save memories — your state is managed by GROOVE's rotation and handoff system.`);
 
@@ -312,15 +312,24 @@ export class Introducer {
     lines.push('To clone a NEW GitHub repo, use: `POST http://localhost:31415/api/repos/import` with `{ "repoUrl": "...", "targetPath": "~/Projects/name", "createTeam": true }`. Do NOT run `git clone` directly.');
 
     // Surface stored API keys so agents know what's available in their environment
+    // Only inject provider API keys (codex, gemini, ollama) and integration credentials
+    // that are relevant to this agent's attached integrations — skip OAuth boilerplate
     const KEY_MAP = { codex: 'OPENAI_API_KEY', gemini: 'GEMINI_API_KEY', ollama: 'OLLAMA_API_KEY' };
+    const agentIntegrations = new Set(newAgent.integrations || []);
     try {
       const credProviders = this.daemon.credentials?.listProviders() || [];
-      if (credProviders.length > 0) {
+      const relevant = credProviders.filter((cp) => {
+        if (KEY_MAP[cp.provider]) return true;
+        if (!cp.provider.startsWith('integration:')) return true;
+        const parts = cp.provider.split(':');
+        return parts.length >= 2 && agentIntegrations.has(parts[1]);
+      });
+      if (relevant.length > 0) {
         lines.push('');
         lines.push('## Available API Keys');
         lines.push('');
         lines.push('GROOVE has API keys stored and injected into your environment. Do NOT ask the user for these:');
-        for (const cp of credProviders) {
+        for (const cp of relevant) {
           const envVar = KEY_MAP[cp.provider];
           if (envVar) {
             lines.push(`- **${cp.provider}**: available as \`${envVar}\` in your environment`);
@@ -333,7 +342,43 @@ export class Introducer {
       }
     } catch { /* credentials not available */ }
 
-    return lines.join('\n');
+    // --- Layer 7: Project Memory (injected at end, bounded) ---
+    let memorySection = '';
+    try {
+      if (this.daemon.memory) {
+        const parts = [];
+
+        const constraints = this.daemon.memory.getConstraintsMarkdown(2000);
+        if (constraints) {
+          parts.push(`### Constraints (read carefully)\n${constraints}`);
+        }
+
+        if (hasTask) {
+          const discoveries = this.daemon.memory.getDiscoveriesMarkdown(newAgent.role, 15, 1000);
+          if (discoveries) {
+            parts.push(`### Known Fixes for ${newAgent.role} Role\n${discoveries}`);
+          }
+
+          const handoffs = this.daemon.memory.getRecentHandoffMarkdown(newAgent.role, 2, 1000, newAgent.workingDir);
+          if (handoffs) {
+            parts.push(`### Recent Handoff History\n${handoffs}`);
+          }
+        }
+
+        if (parts.length > 0) {
+          memorySection = `\n## Project Memory (auto-generated)\n\n${parts.join('\n\n')}\n`;
+          // Hard budget: 4K chars total
+          if (memorySection.length > 4000) {
+            memorySection = memorySection.slice(0, 3997) + '...';
+          }
+        }
+      }
+    } catch {
+      // Memory injection must never break agent spawn
+      memorySection = '';
+    }
+
+    return lines.join('\n') + memorySection;
   }
 
   loadArchitectureDoc() {
@@ -416,7 +461,7 @@ export class Introducer {
       '',
       `See AGENTS_REGISTRY.md for full agent state.`,
       '',
-      `**Memory policy:** Ignore auto-memory. Do not read or write MEMORY.md. GROOVE manages all context.`,
+      `**Memory policy:** GROOVE manages project memory automatically. Do not read or write MEMORY.md or .groove/memory/ files directly.`,
       '',
       GROOVE_SECTION_END,
     ].filter(Boolean).join('\n');

package/node_modules/@groove-dev/daemon/src/journalist.js

@@ -92,6 +92,10 @@ export class Journalist {
       this.writeDecisionsLog(synthesis.decisions);
       this.writeAgentSessionLogs(activeAgents, filteredLogs);
 
+      // Post-synthesis: extract Layer 7 memory from agent logs
+      this._extractDiscoveries(filteredLogs);
+      this._extractConstraints(filteredLogs);
+
       this.lastSynthesis = synthesis;
       this.history.push({
         cycle: this.cycleCount,
@@ -733,7 +737,7 @@ export class Journalist {
     // Pull recent rotation history from persistent memory (Layer 7).
     // Gives the new agent causal continuity: what the last 3 agents struggled
     // with, decided, and solved — not just what the current session did.
-    const recentChain = this.daemon.memory?.getRecentHandoffMarkdown(agent.role, 3, 3000) || '';
+    const recentChain = this.daemon.memory?.getRecentHandoffMarkdown(agent.role, 3, 3000, agent.workingDir) || '';
 
     // Pull the user's recent messages to this agent so the new instance
     // can continue the conversation naturally instead of restarting it.
@@ -967,6 +971,47 @@ export class Journalist {
     return all.sort((a, b) => a.timestamp.localeCompare(b.timestamp)).slice(-30);
   }
 
+  // --- Layer 7 Memory Extraction ---
+
+  _extractDiscoveries(filteredLogs) {
+    if (!this.daemon.memory) return;
+
+    try {
+      for (const [agentId, data] of Object.entries(filteredLogs)) {
+        const { agent, entries } = data;
+        if (!entries || entries.length === 0) continue;
+
+        for (let i = 0; i < entries.length - 1; i++) {
+          const entry = entries[i];
+          if (entry.type !== 'error') continue;
+
+          const trigger = (entry.text || '').trim();
+          if (trigger.length < 20) continue;
+
+          for (let j = i + 1; j < Math.min(i + 6, entries.length); j++) {
+            const next = entries[j];
+            if (next.type !== 'tool' || (next.tool !== 'Edit' && next.tool !== 'Write')) continue;
+            const fix = (next.input || '').trim();
+            if (fix.length < 10) continue;
+
+            this.daemon.memory.addDiscovery({
+              agentId: agent.id,
+              role: agent.role,
+              trigger: trigger.slice(0, 300),
+              fix: fix.slice(0, 500),
+              outcome: 'success',
+            });
+            break;
+          }
+        }
+      }
+    } catch { /* Memory extraction must never break journalist cycle */ }
+  }
+
+  _extractConstraints(filteredLogs) {
+    return;
+  }
+
   // --- Accessors ---
 
   getLastSynthesis() {

package/node_modules/@groove-dev/daemon/src/memory.js

@@ -10,7 +10,7 @@
 // Read by the introducer on every spawn so agent #50 knows what agent #1 learned.
 
 import { readFileSync, writeFileSync, existsSync, mkdirSync, readdirSync, appendFileSync, statSync } from 'fs';
-import { resolve } from 'path';
+import { resolve, relative } from 'path';
 import { createHash } from 'crypto';
 
 const MAX_CONSTRAINTS = 50;
@@ -34,6 +34,7 @@ function truncate(text, max) {
 export class MemoryStore {
   constructor(grooveDir) {
     this.memDir = resolve(grooveDir, 'memory');
+    this.projectDir = resolve(grooveDir, '..');
     this.constraintsPath = resolve(this.memDir, 'project-constraints.md');
     this.handoffDir = resolve(this.memDir, 'handoff-chain');
     this.discoveriesPath = resolve(this.memDir, 'agent-discoveries.jsonl');
@@ -133,19 +134,29 @@ export class MemoryStore {
 
   // --- Handoff Chain ---
 
-  _chainPath(role) {
+  _workspaceSlug(workingDir) {
+    if (!workingDir) return '';
+    const rel = relative(this.projectDir, workingDir);
+    if (!rel || rel === '.' || rel.startsWith('..')) return '';
+    return safeName(rel);
+  }
+
+  _chainPath(role, workingDir) {
+    const slug = this._workspaceSlug(workingDir);
+    if (slug) {
+      const dir = resolve(this.handoffDir, slug);
+      mkdirSync(dir, { recursive: true });
+      return resolve(dir, `${safeName(role)}.md`);
+    }
     return resolve(this.handoffDir, `${safeName(role)}.md`);
   }
 
-  getHandoffChain(role) {
-    const path = this._chainPath(role);
+  getHandoffChain(role, workingDir) {
+    const path = this._chainPath(role, workingDir);
     if (!existsSync(path)) return [];
     try {
       const content = readFileSync(path, 'utf8');
       const entries = [];
-      // Parse entries — each starts with "## Rotation N —"
-      // Body includes the header + all content up to (but not including) the
-      // trailing --- separator and the next entry.
       const blocks = content.split(/\n(?=## Rotation )/);
       for (const block of blocks) {
         const headerMatch = block.match(/^## Rotation (\d+) —/);
@@ -162,9 +173,9 @@ export class MemoryStore {
     }
   }
 
-  appendHandoffBrief(role, entry) {
+  appendHandoffBrief(role, entry, workingDir) {
     if (!role || !entry) return false;
-    const chain = this.getHandoffChain(role);
+    const chain = this.getHandoffChain(role, workingDir);
     const nextN = (chain[0]?.rotationN || 0) + 1;
 
     const block = [
@@ -178,7 +189,6 @@ export class MemoryStore {
       '',
     ].filter(Boolean).join('\n');
 
-    // Prepend new entry (newest first), keep last N
     const newChain = [{ rotationN: nextN, body: block }, ...chain].slice(0, MAX_HANDOFF_ROTATIONS);
 
     const lines = [
@@ -193,25 +203,27 @@ export class MemoryStore {
     }
 
     try {
-      writeFileSync(this._chainPath(role), lines.join('\n'));
+      writeFileSync(this._chainPath(role, workingDir), lines.join('\n'));
       return true;
     } catch {
       return false;
     }
   }
 
-  getRecentHandoffMarkdown(role, count = 3, maxChars = 4000) {
-    const chain = this.getHandoffChain(role);
+  getRecentHandoffMarkdown(role, count = 3, maxChars = 4000, workingDir) {
+    const chain = this.getHandoffChain(role, workingDir);
     if (chain.length === 0) return '';
     const recent = chain.slice(0, count);
     const out = recent.map((e) => e.body || '').join('\n\n---\n\n');
     return truncate(out, maxChars);
   }
 
-  listHandoffRoles() {
-    if (!existsSync(this.handoffDir)) return [];
+  listHandoffRoles(workingDir) {
+    const slug = this._workspaceSlug(workingDir);
+    const dir = slug ? resolve(this.handoffDir, slug) : this.handoffDir;
+    if (!existsSync(dir)) return [];
     try {
-      return readdirSync(this.handoffDir)
+      return readdirSync(dir)
         .filter((f) => f.endsWith('.md'))
         .map((f) => f.replace(/\.md$/, ''));
     } catch {
@@ -225,6 +237,14 @@ export class MemoryStore {
     if (!trigger || !fix) return { added: false, error: 'trigger and fix required' };
     if (outcome !== 'success') return { added: false, reason: 'only successes stored' };
 
+    const fileExtPattern = /[\w./-]+\.(?:js|ts|json|md|jsx|tsx|css|mjs|cjs)\b/g;
+    const triggerTokens = new Set((String(trigger).match(fileExtPattern) || []).map(t => t.toLowerCase()));
+    const fixTokens = new Set((String(fix).match(fileExtPattern) || []).map(t => t.toLowerCase()));
+    const hasOverlap = [...triggerTokens].some(t => fixTokens.has(t));
+    if (triggerTokens.size > 0 && fixTokens.size > 0 && !hasOverlap) {
+      return { added: false, reason: 'trigger and fix are unrelated' };
+    }
+
     const entry = {
       ts: new Date().toISOString(),
       agentId: agentId || null,