discoclaw 1.2.4 → 2.0.0

package/dist/cron/executor.js

@@ -1,3 +1,4 @@
+import { randomUUID } from 'node:crypto';
 import { execa } from 'execa';
 import { resolveDefaultModel as resolveImagegenDefaultModel } from '../discord/actions-imagegen.js';
 import { acquireCronLock, releaseCronLock } from './job-lock.js';
@@ -9,6 +10,7 @@ import { sendChunks, appendUnavailableActionTypesNotice, appendParseFailureNotic
 import { buildPromptPreamble, loadWorkspacePaFiles, inlineContextFiles, resolveEffectiveTools } from '../discord/prompt-common.js';
 import { ensureStatusMessage } from './discord-sync.js';
 import { globalMetrics } from '../observability/metrics.js';
+import { globalTraceStore } from '../observability/trace-store.js';
 import { mapRuntimeErrorToUserMessage } from '../discord/user-errors.js';
 import { resolveModel } from '../runtime/model-tiers.js';
 import { cliExecaEnv, stripAnsi } from '../runtime/cli-shared.js';
@@ -223,6 +225,10 @@ export async function executeCronJob(job, ctx) {
             return;
         }
     }
+    const traceId = `cron_${randomUUID()}`;
+    const sessionKey = `cron:${job.cronId || job.id}`;
+    let traceOutcome = 'success';
+    globalTraceStore.startTrace(traceId, sessionKey, 'cron', undefined);
     job.running = true;
     activeCronRunKeys.add(runKey);
     ctx.runControl?.register(job.id, requestCancel);
@@ -244,6 +250,13 @@ export async function executeCronJob(job, ctx) {
         const guild = ctx.client.guilds.cache.get(job.guildId);
         if (!guild) {
             ctx.log?.error({ jobId: job.id, guildId: job.guildId }, 'cron:exec guild not found');
+            traceOutcome = 'error';
+            globalTraceStore.addEvent(traceId, {
+                type: 'error',
+                at: Date.now(),
+                message: `guild ${job.guildId} not found`,
+                stage: 'cron_setup',
+            });
             await ctx.status?.runtimeError({ sessionKey: `cron:${job.id}` }, `Cron "${job.name}": guild ${job.guildId} not found`);
             await recordError(ctx, job, `guild ${job.guildId} not found`);
             return;
@@ -251,6 +264,13 @@ export async function executeCronJob(job, ctx) {
         const targetChannel = resolveChannel(guild, job.def.channel);
         if (!targetChannel) {
             ctx.log?.error({ jobId: job.id, channel: job.def.channel }, 'cron:exec target channel not found');
+            traceOutcome = 'error';
+            globalTraceStore.addEvent(traceId, {
+                type: 'error',
+                at: Date.now(),
+                message: `target channel "${job.def.channel}" not found`,
+                stage: 'cron_setup',
+            });
             await ctx.status?.runtimeError({ sessionKey: `cron:${job.id}`, channelName: job.def.channel }, `Cron "${job.name}": target channel "${job.def.channel}" not found`);
             await recordError(ctx, job, `target channel "${job.def.channel}" not found`);
             return;
@@ -264,6 +284,13 @@ export async function executeCronJob(job, ctx) {
                 (parentId && ctx.allowChannelIds.has(parentId));
             if (!allowed) {
                 ctx.log?.error({ jobId: job.id, channel: job.def.channel }, 'cron:exec target channel not allowlisted');
+                traceOutcome = 'error';
+                globalTraceStore.addEvent(traceId, {
+                    type: 'error',
+                    at: Date.now(),
+                    message: `target channel "${job.def.channel}" not allowlisted`,
+                    stage: 'cron_setup',
+                });
                 await ctx.status?.runtimeError({ sessionKey: `cron:${job.id}`, channelName: job.def.channel }, `Cron "${job.name}": target channel "${job.def.channel}" is not allowlisted`);
                 await recordError(ctx, job, `target channel "${job.def.channel}" not allowlisted`);
                 return;
@@ -367,6 +394,12 @@ export async function executeCronJob(job, ctx) {
             }
         }
         metrics.recordInvokeStart('cron');
+        globalTraceStore.addEvent(traceId, {
+            type: 'invoke_start',
+            at: Date.now(),
+            summary: `cron job "${job.name}"`,
+            promptPreview: prompt.slice(0, 220),
+        });
         ctx.log?.info({ flow: 'cron', jobId: job.id, cronId: job.cronId }, 'obs.invoke.start');
         let finalText = '';
         let deltaText = '';
@@ -401,6 +434,13 @@ export async function executeCronJob(job, ctx) {
                     collectedImages.push(evt.image);
                 }
                 else if (evt.type === 'error') {
+                    traceOutcome = 'error';
+                    globalTraceStore.addEvent(traceId, {
+                        type: 'error',
+                        at: Date.now(),
+                        message: evt.message,
+                        stage: 'runtime',
+                    });
                     metrics.recordInvokeResult('cron', Date.now() - t0, false, evt.message);
                     metrics.increment('cron.run.error');
                     ctx.log?.error({ jobId: job.id, error: evt.message }, 'cron:exec runtime error');
@@ -425,11 +465,24 @@ export async function executeCronJob(job, ctx) {
             if (runtimeIterator?.return) {
                 await runtimeIterator.return();
             }
+            traceOutcome = 'canceled';
+            globalTraceStore.addEvent(traceId, {
+                type: 'error',
+                at: Date.now(),
+                message: cancelReason,
+                stage: 'runtime',
+            });
             metrics.increment('cron.run.canceled');
             ctx.log?.warn({ jobId: job.id, cronId: job.cronId }, 'cron:exec canceled');
             await recordError(ctx, job, cancelReason);
             return;
         }
+        globalTraceStore.addEvent(traceId, {
+            type: 'invoke_end',
+            at: Date.now(),
+            ok: true,
+            summary: `completed in ${Date.now() - t0}ms`,
+        });
         metrics.recordInvokeResult('cron', Date.now() - t0, true);
         ctx.log?.info({ flow: 'cron', jobId: job.id, ms: Date.now() - t0, ok: true }, 'obs.invoke.end');
         let output = finalText || deltaText;
@@ -518,8 +571,16 @@ export async function executeCronJob(job, ctx) {
                     imagegenCtx: ctx.imagegenCtx,
                     voiceCtx: ctx.voiceCtx,
                 });
-                for (const result of results) {
+                for (let i = 0; i < results.length; i++) {
+                    const result = results[i];
                     metrics.recordActionResult(result.ok);
+                    globalTraceStore.addEvent(traceId, {
+                        type: 'action_result',
+                        at: Date.now(),
+                        action: actions[i].type,
+                        ok: result.ok,
+                        detail: result.ok ? undefined : ('error' in result ? result.error : undefined),
+                    });
                     ctx.log?.info({ flow: 'cron', jobId: job.id, ok: result.ok }, 'obs.action.result');
                 }
                 const anyActionSucceeded = results.some((r) => r.ok);
@@ -604,6 +665,15 @@ export async function executeCronJob(job, ctx) {
     }
     catch (err) {
         const msg = err instanceof Error ? err.message : String(err);
+        traceOutcome = 'error';
+        globalTraceStore.addEvent(traceId, {
+            type: 'error',
+            at: Date.now(),
+            message: msg,
+            name: err instanceof Error ? err.name : undefined,
+            stage: 'cron_flow',
+            stack: err instanceof Error ? err.stack?.slice(0, 400) : undefined,
+        });
         metrics.increment('cron.run.error');
         ctx.log?.error({ err, jobId: job.id }, 'cron:exec failed');
         await ctx.status?.runtimeError({ sessionKey: `cron:${job.id}`, channelName: job.def.channel }, `Cron "${job.name}": ${msg}`);
@@ -623,6 +693,7 @@ export async function executeCronJob(job, ctx) {
         await recordError(ctx, job, msg);
     }
     finally {
+        globalTraceStore.endTrace(traceId, traceOutcome);
         const shouldRerun = queuedCronRerunKeys.delete(runKey);
         if (lockToken && ctx.lockDir && job.cronId) {
             await releaseCronLock(ctx.lockDir, job.cronId, lockToken).catch((err) => {

package/dist/dashboard/api/metrics.js

@@ -0,0 +1,7 @@
+import { globalMetrics } from '../../observability/metrics.js';
+export function buildMetricsResponse() {
+    return {
+        ok: true,
+        metrics: globalMetrics.snapshot(),
+    };
+}

package/dist/dashboard/api/metrics.test.js

@@ -0,0 +1,16 @@
+import { describe, expect, it } from 'vitest';
+import { buildMetricsResponse } from './metrics.js';
+describe('buildMetricsResponse', () => {
+    it('returns ok with a metrics snapshot', () => {
+        const response = buildMetricsResponse();
+        expect(response.ok).toBe(true);
+        expect(response.metrics).toBeDefined();
+        expect(typeof response.metrics.startedAt).toBe('number');
+        expect(response.metrics.counters).toBeDefined();
+        expect(response.metrics.latencies).toBeDefined();
+        expect(response.metrics.latencies).toHaveProperty('message');
+        expect(response.metrics.latencies).toHaveProperty('reaction');
+        expect(response.metrics.latencies).toHaveProperty('cron');
+        expect(response.metrics.latencies).toHaveProperty('defer');
+    });
+});

package/dist/dashboard/api/traces.js

@@ -0,0 +1,14 @@
+import { globalTraceStore } from '../../observability/trace-store.js';
+const DEFAULT_LIMIT = 50;
+const MAX_LIMIT = 200;
+export function buildTracesResponse(limitParam) {
+    const parsed = limitParam !== null ? Math.floor(Number(limitParam)) : DEFAULT_LIMIT;
+    const limit = Number.isFinite(parsed)
+        ? Math.max(1, Math.min(MAX_LIMIT, parsed))
+        : DEFAULT_LIMIT;
+    return {
+        ok: true,
+        summary: globalTraceStore.summary(),
+        recentTraces: globalTraceStore.listRecent(limit),
+    };
+}

package/dist/dashboard/api/traces.test.js

@@ -0,0 +1,40 @@
+import { describe, expect, it } from 'vitest';
+import { buildTracesResponse } from './traces.js';
+import { globalTraceStore } from '../../observability/trace-store.js';
+describe('buildTracesResponse', () => {
+    it('returns ok with summary and recent traces', () => {
+        const response = buildTracesResponse(null);
+        expect(response.ok).toBe(true);
+        expect(response.summary).toBeDefined();
+        expect(typeof response.summary.total).toBe('number');
+        expect(response.summary.byFlow).toBeDefined();
+        expect(Array.isArray(response.recentTraces)).toBe(true);
+    });
+    it('uses default limit of 50 when param is null', () => {
+        const response = buildTracesResponse(null);
+        expect(response.ok).toBe(true);
+        // With an empty store, recentTraces should be empty
+        expect(response.recentTraces.length).toBeLessThanOrEqual(50);
+    });
+    it('respects a custom limit param', () => {
+        // Seed a few traces
+        globalTraceStore.startTrace('t1', 'user:ch', 'message');
+        globalTraceStore.endTrace('t1', 'success');
+        globalTraceStore.startTrace('t2', 'user:ch', 'cron');
+        globalTraceStore.endTrace('t2', 'success');
+        globalTraceStore.startTrace('t3', 'user:ch', 'reaction');
+        globalTraceStore.endTrace('t3', 'success');
+        const response = buildTracesResponse('2');
+        expect(response.ok).toBe(true);
+        expect(response.recentTraces.length).toBeLessThanOrEqual(2);
+    });
+    it('clamps limit to max of 200', () => {
+        const response = buildTracesResponse('999');
+        expect(response.ok).toBe(true);
+        // Just verify it doesn't throw — the limit is clamped internally
+    });
+    it('falls back to default for non-numeric limit', () => {
+        const response = buildTracesResponse('abc');
+        expect(response.ok).toBe(true);
+    });
+});

package/dist/dashboard/page.js

@@ -697,7 +697,7 @@ export function renderDashboardPage() {
               </label>
             </div>
             <div class="actions">
-              <button id="chat-runtime-submit-btn" type="submit">Apply Runtime</button>
+              <button id="chat-runtime-submit-btn" type="submit">Apply Runtime + Save</button>
               <button id="chat-auth-btn" class="secondary" type="button">Check Auth</button>
             </div>
           </form>
@@ -709,9 +709,9 @@ export function renderDashboardPage() {
                 <select id="chat-model-select" name="model" required></select>
               </label>
             </div>
-            <div class="field-note">Tier options double as the practical thinking profile on runtimes that support explicit effort.</div>
+            <div class="field-note">Tier options double as the practical thinking profile on runtimes that support explicit effort. These chat controls also save the next-start default.</div>
             <div class="actions">
-              <button id="chat-model-submit-btn" type="submit">Apply Model</button>
+              <button id="chat-model-submit-btn" type="submit">Apply Model + Save</button>
             </div>
           </form>
         </div>
@@ -839,6 +839,52 @@ export function renderDashboardPage() {
         </details>
       </section>
 
+      <section class="card span-12">
+        <div class="card-header">
+          <div>
+            <h2>Observability</h2>
+          </div>
+          <div class="actions">
+            <button id="traces-btn" class="secondary" type="button">Refresh Traces</button>
+          </div>
+        </div>
+        <div id="traces-summary" class="metrics"></div>
+        <details>
+          <summary>Runtime Metrics</summary>
+          <div class="details-body">
+            <div id="metrics-counters" class="metrics"></div>
+            <div id="metrics-latencies" class="metrics"></div>
+            <div id="metrics-memory" class="metrics"></div>
+          </div>
+        </details>
+        <details>
+          <summary>Recent Traces</summary>
+          <div class="details-body">
+            <div class="table-wrap">
+              <table>
+                <thead>
+                  <tr>
+                    <th>Flow</th>
+                    <th>Outcome</th>
+                    <th>Duration</th>
+                    <th>Started</th>
+                    <th>Events</th>
+                  </tr>
+                </thead>
+                <tbody id="traces-body"></tbody>
+              </table>
+            </div>
+          </div>
+        </details>
+        <details>
+          <summary>Recent Errors</summary>
+          <div class="details-body">
+            <div id="traces-errors" class="checklist"></div>
+          </div>
+        </details>
+        <div id="traces-status" class="status"></div>
+      </section>
+
       <section class="card span-12">
         <div class="card-header">
           <div>
@@ -955,6 +1001,13 @@ export function renderDashboardPage() {
     const secretValueInput = document.getElementById('secret-value-input');
     const settingsContainer = document.getElementById('settings-container');
     const settingsStatus = document.getElementById('settings-status');
+    const tracesSummary = document.getElementById('traces-summary');
+    const tracesBody = document.getElementById('traces-body');
+    const tracesErrors = document.getElementById('traces-errors');
+    const tracesStatus = document.getElementById('traces-status');
+    const metricsCounters = document.getElementById('metrics-counters');
+    const metricsLatencies = document.getElementById('metrics-latencies');
+    const metricsMemory = document.getElementById('metrics-memory');
     const ROLE_LABELS = {
       chat: 'Chat',
       'plan-run': 'Plan Run',
@@ -1265,7 +1318,9 @@ export function renderDashboardPage() {
       chatRuntimeSelect.value = live.chatRuntime || snapshot.primaryRuntime;
 
       clearNode(chatModelSelect);
-      (snapshot.modelOptions.chat || []).forEach(function (model) {
+      (snapshot.modelOptions.chat || []).filter(function (model) {
+        return model !== 'default';
+      }).forEach(function (model) {
         appendSelectOption(chatModelSelect, model, formatModelOptionLabel('chat', model));
       });
       if ((snapshot.modelOptions.chat || []).indexOf(live.chatModel) >= 0) {
@@ -1303,6 +1358,121 @@ export function renderDashboardPage() {
       secretKeySelect.value = recommendSecretKey(snapshot);
     }
 
+    function renderTraces(data) {
+      var summary = data.summary || {};
+      var recentTraces = data.recentTraces || [];
+      var byFlow = summary.byFlow || {};
+      clearNode(tracesSummary);
+      appendMetric(tracesSummary, 'total traces', String(summary.total || 0));
+      appendMetric(tracesSummary, 'in progress', String(summary.inProgress || 0));
+      var flows = ['message', 'reaction', 'cron', 'defer'];
+      flows.forEach(function (flow) {
+        var fs = byFlow[flow];
+        if (!fs || fs.total === 0) return;
+        var avg = fs.avgDurationMs > 0 ? ' avg ' + fs.avgDurationMs + 'ms' : '';
+        appendMetric(tracesSummary, flow, fs.succeeded + ' ok / ' + fs.failed + ' err / ' + fs.inProgress + ' running' + avg);
+      });
+
+      clearNode(tracesBody);
+      recentTraces.forEach(function (trace) {
+        var tr = document.createElement('tr');
+        var flowCell = document.createElement('td');
+        flowCell.textContent = trace.flow;
+        var outcomeCell = document.createElement('td');
+        outcomeCell.textContent = trace.outcome;
+        if (trace.outcome === 'success') outcomeCell.style.color = 'var(--green)';
+        else if (trace.outcome === 'in_progress') outcomeCell.style.color = 'var(--amber)';
+        else if (trace.outcome !== 'success') outcomeCell.style.color = 'var(--red)';
+        var durationCell = document.createElement('td');
+        durationCell.textContent = trace.outcome === 'in_progress' ? '\u2014' : trace.durationMs + 'ms';
+        var startedCell = document.createElement('td');
+        startedCell.textContent = new Date(trace.startedAt).toLocaleTimeString();
+        var eventsCell = document.createElement('td');
+        eventsCell.textContent = String((trace.events || []).length);
+        tr.append(flowCell, outcomeCell, durationCell, startedCell, eventsCell);
+        tracesBody.append(tr);
+      });
+
+      clearNode(tracesErrors);
+      var recentErrors = summary.recentErrors || [];
+      if (recentErrors.length === 0) {
+        var noErrors = document.createElement('div');
+        noErrors.className = 'card-copy';
+        noErrors.textContent = 'No recent errors.';
+        tracesErrors.append(noErrors);
+      } else {
+        recentErrors.forEach(function (err) {
+          var item = document.createElement('div');
+          item.className = 'checklist-item';
+          var top = document.createElement('div');
+          top.className = 'checklist-top';
+          var dot = document.createElement('div');
+          dot.className = 'status-dot error';
+          var label = document.createElement('div');
+          label.className = 'checklist-label';
+          label.textContent = err.flow + ': ' + err.message;
+          top.append(dot, label);
+          var body = document.createElement('div');
+          body.className = 'checklist-body';
+          body.textContent = new Date(err.at).toLocaleString();
+          item.append(top, body);
+          tracesErrors.append(item);
+        });
+      }
+    }
+
+    async function refreshTraces() {
+      var response = await fetchJson('/api/traces');
+      renderTraces(response);
+    }
+
+    function renderMetrics(data) {
+      var m = data.metrics || {};
+      var counters = m.counters || {};
+      var latencies = m.latencies || {};
+      var memory = m.memory;
+
+      clearNode(metricsCounters);
+      var upSince = m.startedAt ? new Date(m.startedAt).toLocaleString() : 'unknown';
+      appendMetric(metricsCounters, 'up since', upSince);
+      var counterKeys = Object.keys(counters).sort();
+      counterKeys.forEach(function (key) {
+        appendMetric(metricsCounters, key, String(counters[key]));
+      });
+      if (counterKeys.length === 0) {
+        appendMetric(metricsCounters, 'counters', 'none recorded yet');
+      }
+
+      clearNode(metricsLatencies);
+      var flows = ['message', 'reaction', 'cron', 'defer'];
+      flows.forEach(function (flow) {
+        var lat = latencies[flow];
+        if (!lat || lat.count === 0) return;
+        appendMetric(metricsLatencies, flow + ' latency',
+          'p50=' + lat.p50Ms + 'ms  p95=' + lat.p95Ms + 'ms  max=' + lat.maxMs + 'ms  (n=' + lat.count + ')');
+      });
+      if (metricsLatencies.children.length === 0) {
+        appendMetric(metricsLatencies, 'latencies', 'no samples yet');
+      }
+
+      clearNode(metricsMemory);
+      if (memory) {
+        function fmtMB(bytes) { return bytes ? (bytes / 1048576).toFixed(1) + ' MB' : 'n/a'; }
+        appendMetric(metricsMemory, 'rss', fmtMB(memory.rssBytes) + '  (hwm ' + fmtMB(memory.rssHwmBytes) + ')');
+        appendMetric(metricsMemory, 'heap used', fmtMB(memory.heapUsedBytes) + '  (hwm ' + fmtMB(memory.heapUsedHwmBytes) + ')');
+        appendMetric(metricsMemory, 'heap total', fmtMB(memory.heapTotalBytes));
+        appendMetric(metricsMemory, 'external', fmtMB(memory.externalBytes));
+        appendMetric(metricsMemory, 'samples', String(memory.sampleCount || 0));
+      } else {
+        appendMetric(metricsMemory, 'memory', 'sampler not active');
+      }
+    }
+
+    async function refreshMetrics() {
+      var response = await fetchJson('/api/metrics');
+      renderMetrics(response);
+    }
+
     function renderSnapshot(snapshot) {
       if (!snapshot.live) snapshot.live = {};
       const selectedRole = roleSelect.value;
@@ -1560,13 +1730,22 @@ export function renderDashboardPage() {
 
     document.getElementById('refresh-btn').addEventListener('click', async function () {
       try {
-        await Promise.all([refreshSnapshot(false), refreshDoctor(false)]);
+        await Promise.all([refreshSnapshot(false), refreshDoctor(false), refreshTraces(), refreshMetrics()]);
         setStatus(heroStatus, 'Dashboard refreshed.', 'ok');
       } catch (error) {
         setStatus(heroStatus, String(error), 'error');
       }
     });
 
+    document.getElementById('traces-btn').addEventListener('click', async function () {
+      try {
+        await Promise.all([refreshTraces(), refreshMetrics()]);
+        setStatus(tracesStatus, 'Traces refreshed.', 'ok');
+      } catch (error) {
+        setStatus(tracesStatus, String(error), 'error');
+      }
+    });
+
     document.getElementById('status-btn').addEventListener('click', async function () {
       try {
         const response = await fetchJson('/api/status');
@@ -1639,7 +1818,7 @@ export function renderDashboardPage() {
         const response = await fetchJson('/api/live-model', {
           method: 'POST',
           headers: { 'Content-Type': 'application/json' },
-          body: JSON.stringify({ role: 'chat', model: chatRuntimeSelect.value })
+          body: JSON.stringify({ role: 'chat', model: chatRuntimeSelect.value, persist: true })
         });
         renderSnapshot(response.snapshot);
         setStatus(chatStatus, response.message, 'ok');
@@ -1655,7 +1834,7 @@ export function renderDashboardPage() {
         const response = await fetchJson('/api/live-model', {
           method: 'POST',
           headers: { 'Content-Type': 'application/json' },
-          body: JSON.stringify({ role: 'chat', model: chatModelSelect.value })
+          body: JSON.stringify({ role: 'chat', model: chatModelSelect.value, persist: true })
         });
         renderSnapshot(response.snapshot);
         setStatus(chatStatus, response.message, 'ok');
@@ -1762,7 +1941,7 @@ export function renderDashboardPage() {
       syncSecondaryModelOptions(roleSelect.value, '');
     });
 
-    Promise.all([refreshSnapshot(false), refreshDoctor(false), loadSettings()]).then(function () {
+    Promise.all([refreshSnapshot(false), refreshDoctor(false), loadSettings(), refreshTraces(), refreshMetrics()]).then(function () {
       setStatus(heroStatus, 'Dashboard ready.', 'ok');
       if (lastSnapshot) {
         populateSecondaryRoleForm('', '');