lazyclaw 6.3.1 → 6.4.0

package/daemon/lib/auth.mjs

@@ -18,8 +18,33 @@ export function constantTimeEqual(a, b) {
   return diff === 0;
 }
 
+/**
+ * Static dashboard shell allowlist. The HTML/CSS/JS that make up the
+ * dashboard contain no secrets — they're an empty shell that fetches every
+ * piece of data over the (still token-gated) JSON API. Serving the shell
+ * without a token lets the browser load the page and obtain the token from
+ * the user; the bearer check then guards every data/mutation route. The
+ * list is the EXACT set of static GET routes (see daemon/route_table.mjs);
+ * no prefixes, so a route like `/dashboard.html` or `/config` never matches.
+ */
+const STATIC_DASHBOARD_PATHS = new Set([
+  '/', '/dashboard', '/dashboard/', '/dashboard.css', '/dashboard.js',
+]);
+export function isStaticDashboardPath(pathname) {
+  return STATIC_DASHBOARD_PATHS.has(pathname);
+}
+
 export function isAuthorized(req, expectedToken) {
   if (!expectedToken) return true;  // auth disabled
+  // Static dashboard shell bypasses the token gate (GET-only, no secrets).
+  // Normalize the URL first so a dot-segment path like `/dashboard/../config`
+  // can't ride the bypass into a gated data route — it normalizes to
+  // `/config`, which isn't on the allowlist.
+  if ((req.method || 'GET').toUpperCase() === 'GET') {
+    let pathname = '';
+    try { pathname = new URL(req.url || '/', 'http://localhost').pathname; } catch { pathname = ''; }
+    if (isStaticDashboardPath(pathname)) return true;
+  }
   const header = req.headers['authorization'] || '';
   const m = /^Bearer\s+(.+)$/i.exec(header);
   if (!m) return false;

package/daemon/lib/cost.mjs

@@ -28,3 +28,39 @@ export function accumulateMetricsFromCost(metrics, usage, cost) {
     if (Number.isFinite(usage.outputTokens)) metrics.tokensTotal.outputTokens += usage.outputTokens;
   }
 }
+
+// Account one turn's cost against the running metrics so the cost cap tracks
+// real spend, and return the cost block ONLY when the caller asked for it.
+//
+// The previous /chat + /agent code only accumulated when the CALLER set
+// body.cost — but no bundled client does, so the cap never tripped. Here
+// accumulation is unconditional whenever a rate card resolves a cost;
+// `wantCost` (body.cost) just controls whether the cost block is returned to
+// the client. `costFromUsage` is injected to keep this module pure/testable.
+export function accountTurnCost({ metrics, usage, provider, model, rates, wantCost, costFromUsage }) {
+  if (!usage || !rates || typeof costFromUsage !== 'function') return null;
+  let cost = null;
+  try {
+    cost = costFromUsage({ provider, model, usage }, rates);
+    if (cost) accumulateMetricsFromCost(metrics, usage, cost);
+  } catch { return null; }
+  return wantCost ? cost : null;
+}
+
+// Build the onUsage handler the team multi-agent loop fires per agent turn.
+// Each turn carries its own { provider, model, usage } so a mixed-provider team
+// is priced against the right rate card; the spend lands in metrics so the cost
+// cap covers team traffic (which used to bypass it entirely), and onBreach() is
+// called once accumulated spend trips the cap so the caller can abort the loop
+// mid-run. Best-effort: a cost-accounting hiccup never breaks a turn.
+export function makeTeamUsageAccountant({ metrics, costCap, rates, costFromUsage, onBreach }) {
+  return ({ provider, model, usage }) => {
+    try {
+      if (usage && rates && typeof costFromUsage === 'function') {
+        const cost = costFromUsage({ provider, model, usage }, rates);
+        if (cost) accumulateMetricsFromCost(metrics, usage, cost);
+      }
+      if (typeof onBreach === 'function' && checkCostCap(metrics, costCap)) onBreach();
+    } catch { /* best-effort — never break a turn on accounting */ }
+  };
+}

package/daemon/lib/respond.mjs

@@ -77,7 +77,26 @@ export function writeSseHead(res) {
   });
 }
 
+// Returns the data-frame res.write() result: false when the socket's write
+// buffer is full (backpressure), true otherwise. Streaming loops use this to
+// yield the event loop ONLY when the buffer is full, instead of paying an
+// event-loop turn on every token.
 export function writeSse(res, event, data) {
   if (event) res.write(`event: ${event}\n`);
-  res.write(`data: ${JSON.stringify(data)}\n\n`);
+  return res.write(`data: ${JSON.stringify(data)}\n\n`);
+}
+
+// Opt-in wall-clock cap for a streaming response. The provider's per-chunk
+// idle timeout can't bound a model that streams steadily for minutes, so a
+// caller can abort the whole turn after `maxMs`. Aborting `ac` stops the
+// provider; the loop then breaks and the caller can tell the client it was
+// truncated (vs a client disconnect) via hit(). No-op when maxMs is unset/<=0.
+// The timer is unref'd so it never keeps the process alive.
+export function armStreamDeadline(ac, maxMs) {
+  const ms = Number(maxMs) || 0;
+  if (ms <= 0) return { disarm: () => {}, hit: () => false };
+  let fired = false;
+  const t = setTimeout(() => { fired = true; try { ac.abort(); } catch { /* already done */ } }, ms);
+  if (t && typeof t.unref === 'function') t.unref();
+  return { disarm: () => clearTimeout(t), hit: () => fired };
 }

package/daemon/lib/team_inbound.mjs

@@ -0,0 +1,69 @@
+// daemon/lib/team_inbound.mjs — Slack→team auto-routing for POST /inbound.
+//
+// When the inbound channel is bound to a team (team.slackChannel), drive the
+// multi-agent task loop (mention_router.runTaskTurn) — which emits live
+// dashboard events as the agents work — instead of a single-shot provider
+// reply. Returns { reply, team, taskId } when handled, or null to fall through
+// to the existing single-shot path (byte-stable for unbound channels).
+//
+// Collaborators are static-imported except mention_router (lazy, since it pulls
+// in the agent-turn machinery); `_runTaskTurn` is a test injection seam.
+
+import { teamForChannelCached } from '../../teams.mjs';
+import { getAgent } from '../../agents.mjs';
+import { registerTask } from '../../tasks.mjs';
+import { defaultSandboxSpec } from '../../sandbox/index.mjs';
+
+export async function routeInboundToTeam({
+  cfg, channel, text, configDir, apiKey, baseUrl, logger, slackSender, onUsage, signal, _runTaskTurn,
+} = {}) {
+  if (!channel || !text) return null;
+  const team = teamForChannelCached(channel, configDir);
+  if (!team) return null;
+
+  // Load the team's agent records; bail (fall through) if the lead drifted away.
+  const agentsById = {};
+  for (const name of (team.agents || [])) {
+    const rec = getAgent(name, configDir);
+    if (rec) agentsById[name] = rec;
+  }
+  if (!agentsById[team.lead]) return null;
+
+  const task = registerTask({
+    title: String(text).slice(0, 80) || '(channel task)',
+    team: team.name,
+    lead: team.lead,
+    slackChannel: channel,
+  }, configDir);
+
+  const runTaskTurn = _runTaskTurn
+    || (await import('../../mas/mention_router.mjs')).runTaskTurn;
+
+  // runTaskTurn expects a (line)=>{} logger. The daemon route passes a structured
+  // logger object (with .info/.warn) or null — coerce to a callable so the loop
+  // never throws "logger is not a function".
+  const safeLogger = typeof logger === 'function' ? logger : () => {};
+
+  const result = await runTaskTurn({
+    task, team, agentsById, userMessage: text,
+    configDir, apiKey, baseUrl, logger: safeLogger, slackSender,
+    // Forward per-agent-turn usage so the daemon can price each turn against
+    // its agent's rate card and feed the cost cap (team spend was invisible).
+    onUsage,
+    // Abort signal so the daemon can stop the loop mid-run once the cap trips.
+    signal,
+    // Default-on confinement for every tool the team runs (opt out via cfg).
+    sandbox: defaultSandboxSpec(cfg, { cwd: process.cwd(), configDir }),
+  });
+
+  const turns = (result && result.task && result.task.turns) || [];
+  const lastAssistant = [...turns].reverse().find((t) => t && t.agent && t.agent !== 'user' && t.text);
+  // Strip the internal [[TASK_DONE]] control marker from the channel-facing reply.
+  const reply = (lastAssistant ? lastAssistant.text : '(team finished with no reply)')
+    .replace(/\[\[TASK_DONE\]\]/g, '').trim();
+  return {
+    reply: reply || '(team finished with no reply)',
+    team: team.name,
+    taskId: (result && result.task && result.task.id) || task.id,
+  };
+}

package/daemon/route_table.mjs

@@ -21,15 +21,18 @@ import * as skills from './routes/skills.mjs';
 import * as conversation from './routes/conversation.mjs';
 import * as registry from './routes/registry.mjs';
 import * as ops from './routes/ops.mjs';
+import * as events from './routes/events.mjs';
 
 export const ROUTES = [
-  { m: (c) => c.route === 'GET /' || c.route === 'GET /dashboard', h: meta.dashboard },
+  { m: (c) => c.route === 'GET /' || c.route === 'GET /dashboard' || c.route === 'GET /dashboard/', h: meta.dashboard },
   { m: (c) => c.route === 'GET /dashboard.css', h: meta.dashboardCss },
   { m: (c) => c.route === 'GET /dashboard.js', h: meta.dashboardJs },
+  { m: (c) => c.req.method === 'GET' && /^\/avatars\/\d{2}\.png$/.test(c.path || ''), h: meta.avatar },
   { m: (c) => c.route === 'GET /version', h: meta.version },
   { m: (c) => c.route === 'POST /exec/request', h: conversation.execRequest },
   { m: (c) => c.route === 'GET /health' || c.route === 'GET /healthz', h: meta.health },
   { m: (c) => c.route === 'GET /metrics', h: meta.metrics },
+  { m: (c) => c.route === 'GET /events', h: events.events },
   { m: (c) => c.route === 'GET /providers', h: providers.providersList },
   { m: (c) => c.req.method === 'GET' && !!c.providerMatch && c.providerMatch[1] !== 'test', h: providers.providerGet },
   { m: (c) => c.route === 'GET /providers/test', h: providers.providersTest },
@@ -52,6 +55,7 @@ export const ROUTES = [
   { m: (c) => c.route === 'GET /sessions/search', h: sessions.sessionsSearch },
   { m: (c) => c.req.method === 'GET' && !!c.sessionExportMatch, h: sessions.sessionExport },
   { m: (c) => c.req.method === 'GET' && !!c.sessionMatch, h: sessions.sessionGet },
+  { m: (c) => c.route === 'POST /workflows/run', h: workflows.workflowRun },
   { m: (c) => c.route === 'GET /workflows/aggregate', h: workflows.workflowsAggregate },
   { m: (c) => c.route === 'GET /workflows', h: workflows.workflowsList },
   { m: (c) => c.req.method === 'GET' && !!c.workflowMatch, h: workflows.workflowGet },

package/daemon/routes/_deps.mjs

@@ -25,9 +25,9 @@ export { validateRates } from '../../rates-validate.mjs';
 
 export {
   fileExists, readJson, readTextBody, writeJson, writeSseHead, writeSse,
-  statusForProviderError,
+  statusForProviderError, armStreamDeadline,
 } from '../lib/respond.mjs';
-export { checkCostCap, accumulateMetricsFromCost } from '../lib/cost.mjs';
+export { checkCostCap, accumulateMetricsFromCost, accountTurnCost, makeTeamUsageAccountant } from '../lib/cost.mjs';
 export { resolveProvider } from '../lib/provider.mjs';
 // F5/F6 — cross-channel handoff: the threads store + the rollback-aware
 // migration helper, so the conversation routes can bind inbound messages to a

package/daemon/routes/config.mjs

@@ -2,6 +2,7 @@
 // Each handler takes the per-request dispatch context `c` and returns the
 // HTTP response. Bodies are unchanged; only the dispatch wrapper is new.
 import { fs, nodePath, PROVIDERS, PROVIDER_INFO, maskApiKey, costFromUsage, RATE_CARD_SHAPE, composeSystemPrompt, listSkills, loadSkill, skillPath, installSkill, removeSkill, parseFrontmatter, skillsDefaultConfigDir, indexDb, skillSynth, sandboxListBackends, summarizeState, listWorkflowSessions, loadWorkflowState, aggregateNodeStats, validateConfig, validateRates, fileExists, readJson, readTextBody, writeJson, writeSseHead, writeSse, statusForProviderError, checkCostCap, accumulateMetricsFromCost, resolveProvider } from './_deps.mjs';
+import { redactConfigTree } from '../../mas/redact.mjs';
 
 export async function configValidate(c) {
   const { ctx, logger, metrics, gateway, costCap, cachedByName, gwConfigDir, nudgeSuggestionsRing, workflowStateDir, req, res, method, path, route, url, sessionMatch, providerMatch, providerTestMatch, sessionExportMatch, skillMatch, workflowMatch, configKeyMatch, ratesKeyMatch } = c;
@@ -23,12 +24,13 @@ export async function configValidate(c) {
 
 export async function configGet(c) {
   const { ctx, logger, metrics, gateway, costCap, cachedByName, gwConfigDir, nudgeSuggestionsRing, workflowStateDir, req, res, method, path, route, url, sessionMatch, providerMatch, providerTestMatch, sessionExportMatch, skillMatch, workflowMatch, configKeyMatch, ratesKeyMatch } = c;
-          // Mirror of `lazyclaw config list`. Returns every stored key
-          // with the api-key value masked — lets a dashboard or script
-          // inspect the active configuration without shelling to the CLI.
+          // Mirror of `lazyclaw config list`. Returns every stored key with
+          // ALL credential material masked — a shallow copy that masked only
+          // the top-level 'api-key' leaked customProviders[].apiKey,
+          // authProfiles key material, and channel bot tokens in cleartext to
+          // any local process (the daemon defaults to no auth token).
           const cfg = ctx.readConfig();
-          const safe = { ...cfg };
-          if (safe['api-key']) safe['api-key'] = maskApiKey(safe['api-key']);
+          const safe = redactConfigTree(cfg, maskApiKey);
           return writeJson(res, 200, safe);
 }
 
@@ -43,7 +45,10 @@ export async function configKeyGet(c) {
             return writeJson(res, 404, { error: 'key not found', key });
           }
           const raw = cfg[key];
-          const value = key === 'api-key' ? maskApiKey(raw) : raw;
+          // Deep-redact: GET /config/customProviders (or any nested cargo) must
+          // not return cleartext apiKey/token material. A scalar non-secret key
+          // (provider, model) passes through unchanged.
+          const value = redactConfigTree(raw, maskApiKey, key);
           return writeJson(res, 200, { key, value });
 }
 

package/daemon/routes/conversation.mjs

@@ -1,8 +1,9 @@
 // Daemon route handlers (conversation), extracted verbatim from makeHandler (D5).
 // Each handler takes the per-request dispatch context `c` and returns the
 // HTTP response. Bodies are unchanged; only the dispatch wrapper is new.
-import { fs, nodePath, PROVIDERS, PROVIDER_INFO, maskApiKey, costFromUsage, RATE_CARD_SHAPE, composeSystemPrompt, listSkills, loadSkill, skillPath, installSkill, removeSkill, parseFrontmatter, skillsDefaultConfigDir, indexDb, skillSynth, sandboxListBackends, summarizeState, listWorkflowSessions, loadWorkflowState, aggregateNodeStats, validateConfig, validateRates, fileExists, readJson, readTextBody, writeJson, writeSseHead, writeSse, statusForProviderError, checkCostCap, accumulateMetricsFromCost, resolveProvider, openThreads, handoffWithRollback, openDedup, enqueueLearning } from './_deps.mjs';
+import { fs, nodePath, PROVIDERS, PROVIDER_INFO, maskApiKey, costFromUsage, RATE_CARD_SHAPE, composeSystemPrompt, listSkills, loadSkill, skillPath, installSkill, removeSkill, parseFrontmatter, skillsDefaultConfigDir, indexDb, skillSynth, sandboxListBackends, summarizeState, listWorkflowSessions, loadWorkflowState, aggregateNodeStats, validateConfig, validateRates, fileExists, readJson, readTextBody, writeJson, writeSseHead, writeSse, statusForProviderError, armStreamDeadline, checkCostCap, accumulateMetricsFromCost, accountTurnCost, makeTeamUsageAccountant, resolveProvider, openThreads, handoffWithRollback, openDedup, enqueueLearning } from './_deps.mjs';
 import { randomBytes } from 'node:crypto';
+import { routeInboundToTeam } from '../lib/team_inbound.mjs';
 
 // F5 — mint a fresh session id for a newly-seen channel:externalId binding.
 // Kept filename-local (threads.mjs's newThreadId isn't exported); the `ib_`
@@ -67,7 +68,9 @@ export async function chat(c) {
             apiKey: cfg['api-key'],
             model: body.model || cfg.model,
             thinking: thinkingBudget > 0 ? { enabled: true, budgetTokens: thinkingBudget } : undefined,
-            onUsage: body.usage ? (u) => { captured = u; } : undefined,
+            // Always capture usage so the cost cap can track real spend;
+            // body.usage only controls whether we RETURN it to the caller.
+            onUsage: (u) => { captured = u; },
           };
           // Cost lookup: body.cost:true asks the daemon to attach a cost
           // block when usage was captured AND cfg.rates has a card for
@@ -75,17 +78,13 @@ export async function chat(c) {
           // calls. Inline rather than helper-extract because the two
           // response paths (stream / non-stream) need to bind it
           // differently (SSE event vs JSON field).
-          const computeCost = () => {
-            if (!body.cost || !captured || !cfg.rates) return null;
-            try {
-              const c = costFromUsage(
-                { provider: provName, model: body.model || cfg.model, usage: captured },
-                cfg.rates,
-              );
-              if (c) accumulateMetricsFromCost(metrics, captured, c);
-              return c;
-            } catch { return null; }
-          };
+          // Always accumulate cost into metrics (so checkCostCap tracks real
+          // spend on the NEXT request); return the cost block only when
+          // body.cost asked for it. Call once per turn.
+          const account = () => accountTurnCost({
+            metrics, usage: captured, provider: provName, model: body.model || cfg.model,
+            rates: cfg.rates, wantCost: body.cost, costFromUsage,
+          });
           if (body.stream === true) {
             writeSseHead(res);
             // Abort the provider when the SSE client disconnects — otherwise it
@@ -94,31 +93,44 @@ export async function chat(c) {
             const ac = new AbortController();
             req.on('aborted', () => ac.abort());
             res.on('close', () => { if (!res.writableEnded) ac.abort(); });
+            // Opt-in wall-clock cap (cfg.chat.maxStreamMs): the per-chunk idle
+            // timeout can't bound a model that streams steadily for minutes.
+            const maxStreamMs = Number(cfg.chat?.maxStreamMs) || 0;
+            const _deadline = armStreamDeadline(ac, maxStreamMs);
             try {
               for await (const chunk of prov.sendMessage(messages, { ...sendOpts, signal: ac.signal })) {
                 if (ac.signal.aborted) break;
-                writeSse(res, 'token', { text: chunk });
-                await new Promise(r => setImmediate(r));
+                // Yield the event loop only under backpressure (socket buffer
+                // full) instead of on every token — writeSse returns false when
+                // the buffer is full.
+                if (!writeSse(res, 'token', { text: chunk })) await new Promise(r => setImmediate(r));
               }
+              // Tell the client the reply was cut by the cap (vs a clean finish).
+              if (_deadline.hit()) writeSse(res, 'truncated', { reason: 'maxStreamMs', maxStreamMs });
               if (!ac.signal.aborted) {
-                if (captured) writeSse(res, 'usage', captured);
-                const cost = computeCost();
+                const cost = account();
+                if (captured && body.usage) writeSse(res, 'usage', captured);
                 if (cost) writeSse(res, 'cost', cost);
                 writeSse(res, 'done', { ok: true });
               }
               return res.end();
             } catch (err) {
-              if (err?.code === 'ABORT' || ac.signal.aborted) return res.end();
+              if (err?.code === 'ABORT' || ac.signal.aborted) {
+                if (_deadline.hit()) writeSse(res, 'truncated', { reason: 'maxStreamMs', maxStreamMs });
+                return res.end();
+              }
               writeSse(res, 'error', { message: err?.message || String(err) });
               return res.end();
+            } finally {
+              _deadline.disarm();
             }
           }
           let acc = '';
           try {
             for await (const chunk of prov.sendMessage(messages, sendOpts)) acc += chunk;
-            const cost = computeCost();
+            const cost = account();
             const out = { reply: acc };
-            if (captured) out.usage = captured;
+            if (captured && body.usage) out.usage = captured;
             if (cost) out.cost = cost;
             return writeJson(res, 200, out);
           } catch (err) {
@@ -194,6 +206,52 @@ export async function inbound(c) {
           // pending TTL and retries would be silently dropped.
           let dedupRecorded = false;
           try {
+          // L3 — Slack→team auto-routing. When the inbound channel is bound to a
+          // team (team.slackChannel), drive the multi-agent task loop (which
+          // emits live dashboard events as the agents work) and return its final
+          // reply. Falls through to the single-shot path when no team is bound,
+          // keeping existing single-agent channels byte-stable.
+          if (channel) {
+            // Account every team agent turn's spend so the cost cap covers team
+            // traffic (it used to bypass the cap entirely), and abort the loop
+            // mid-run the moment accumulated spend breaches the cap.
+            const teamAc = new AbortController();
+            const teamOnUsage = makeTeamUsageAccountant({
+              metrics, costCap, rates: cfg.rates, costFromUsage, onBreach: () => teamAc.abort(),
+            });
+            const teamRouted = await routeInboundToTeam({
+              cfg, channel, text, configDir: cfgDir,
+              apiKey: cfg['api-key'], logger,
+              onUsage: teamOnUsage, signal: teamAc.signal,
+            }).catch((err) => {
+              // `logger` here is the daemon's structured logger (object|null), not a
+              // function — use its method API, never call it directly.
+              try { logger?.warn?.('inbound_team_routing_failed', { err: err?.message || String(err) }); } catch { /* best-effort */ }
+              return null;
+            });
+            if (teamRouted) {
+              const out = { reply: teamRouted.reply, threadId: body.threadId || null, team: teamRouted.team, taskId: teamRouted.taskId };
+              if (dedup) { dedup.record(dedupKey, { reply: teamRouted.reply, threadId: out.threadId }); dedupRecorded = true; }
+              return writeJson(res, 200, out);
+            }
+            // No team bound — is the channel bound to a named workflow? If so,
+            // run it with the message as {{input}} and reply with its output.
+            // Falls through (byte-stable) when nothing is bound.
+            const { workflowForChannel, runNamedWorkflow, namedReplyText } = await import('../../workflow/named.mjs');
+            const wf = workflowForChannel(cfg, channel);
+            if (wf) {
+              try {
+                const wfResult = await runNamedWorkflow(wf.name, cfg, { providerLookup: (n) => PROVIDERS[n] || null, input: text });
+                const reply = namedReplyText(wfResult, wf) || '(workflow finished with no reply)';
+                const out = { reply, threadId: body.threadId || null, workflow: wf.name };
+                if (dedup) { dedup.record(dedupKey, { reply, threadId: out.threadId }); dedupRecorded = true; }
+                return writeJson(res, 200, out);
+              } catch (err) {
+                try { logger?.warn?.('inbound_workflow_failed', { workflow: wf.name, err: err?.message || String(err) }); } catch { /* best-effort */ }
+                // fall through to the single-shot provider reply
+              }
+            }
+          }
           let threads = null;
           let bound = null;
           let sessionId = null;
@@ -363,19 +421,14 @@ export async function agent(c) {
             apiKey: cfg['api-key'],
             model,
             thinking: thinkingBudget > 0 ? { enabled: true, budgetTokens: thinkingBudget } : undefined,
-            onUsage: body.usage ? (u) => { agentCaptured = u; } : undefined,
-          };
-          const computeAgentCost = () => {
-            if (!body.cost || !agentCaptured || !cfg.rates) return null;
-            try {
-              const c = costFromUsage(
-                { provider: provName, model, usage: agentCaptured },
-                cfg.rates,
-              );
-              if (c) accumulateMetricsFromCost(metrics, agentCaptured, c);
-              return c;
-            } catch { return null; }
+            // Always capture usage for cap accounting; body.usage gates the return.
+            onUsage: (u) => { agentCaptured = u; },
           };
+          // Accumulate unconditionally; return the cost block only when asked.
+          const accountAgent = () => accountTurnCost({
+            metrics, usage: agentCaptured, provider: provName, model,
+            rates: cfg.rates, wantCost: body.cost, costFromUsage,
+          });
 
           if (body.stream === true) {
             writeSseHead(res);
@@ -384,30 +437,40 @@ export async function agent(c) {
             const ac = new AbortController();
             req.on('aborted', () => ac.abort());
             res.on('close', () => { if (!res.writableEnded) ac.abort(); });
+            // Opt-in wall-clock cap (cfg.chat.maxStreamMs) — bounds a turn that
+            // streams steadily past the per-chunk idle timeout.
+            const maxStreamMs = Number(cfg.chat?.maxStreamMs) || 0;
+            const _deadline = armStreamDeadline(ac, maxStreamMs);
             let acc = '';
             try {
               for await (const chunk of prov.sendMessage(messages, { ...agentSendOpts, signal: ac.signal })) {
                 if (ac.signal.aborted) break;
                 acc += chunk;
-                writeSse(res, 'token', { text: chunk });
-                // Backpressure: yield so the caller can read each frame.
-                await new Promise(r => setImmediate(r));
+                // Backpressure: yield the event loop only when the socket
+                // buffer is full (writeSse returns false), not on every token.
+                if (!writeSse(res, 'token', { text: chunk })) await new Promise(r => setImmediate(r));
               }
-              if (sid && !ac.signal.aborted) ctx.sessionsMod.appendTurn(sid, 'assistant', acc, cfgDir);
+              // On a cap-hit we still persist the partial turn (it's real output)
+              // but tell the client it was truncated rather than a clean finish.
+              if (_deadline.hit()) writeSse(res, 'truncated', { reason: 'maxStreamMs', maxStreamMs });
+              if (sid && (!ac.signal.aborted || _deadline.hit())) ctx.sessionsMod.appendTurn(sid, 'assistant', acc, cfgDir);
               if (!ac.signal.aborted) {
-                if (agentCaptured) writeSse(res, 'usage', agentCaptured);
-                const cost = computeAgentCost();
+                const cost = accountAgent();
+                if (agentCaptured && body.usage) writeSse(res, 'usage', agentCaptured);
                 if (cost) writeSse(res, 'cost', cost);
                 writeSse(res, 'done', { ok: true });
               }
               return res.end();
             } catch (err) {
               if (err?.code === 'ABORT' || ac.signal.aborted) {
+                if (_deadline.hit()) writeSse(res, 'truncated', { reason: 'maxStreamMs', maxStreamMs });
                 // Client gave up — partial assistant turn is discarded.
                 return res.end();
               }
               writeSse(res, 'error', { message: err?.message || String(err) });
               return res.end();
+            } finally {
+              _deadline.disarm();
             }
           }
 
@@ -418,9 +481,9 @@ export async function agent(c) {
           try {
             for await (const chunk of prov.sendMessage(messages, agentSendOpts)) acc += chunk;
             if (sid) ctx.sessionsMod.appendTurn(sid, 'assistant', acc, cfgDir);
-            const cost = computeAgentCost();
+            const cost = accountAgent();
             const out = { reply: acc };
-            if (agentCaptured) out.usage = agentCaptured;
+            if (agentCaptured && body.usage) out.usage = agentCaptured;
             if (cost) out.cost = cost;
             return writeJson(res, 200, out);
           } catch (err) {

package/daemon/routes/events.mjs

@@ -0,0 +1,45 @@
+// GET /events — Server-Sent Events stream of live agent activity for the
+// dashboard's Team view. On connect we replay the recent ring buffer (so a
+// freshly-opened dashboard converges to current state), then stream every
+// subsequent event. Auth is enforced by the daemon's pre-dispatch gate, so the
+// handler can assume the request is authorized.
+//
+// The handler keeps the connection open; it cleans up its subscription +
+// heartbeat when the client disconnects (req 'aborted' / res 'close').
+
+import { writeSseHead, writeSse } from '../lib/respond.mjs';
+import { subscribe, recent } from '../../mas/events.mjs';
+
+const HEARTBEAT_MS = 25_000;
+
+export function events(c) {
+  const { req, res } = c;
+  writeSseHead(res);
+
+  // Replay buffered events. The dashboard dedupes by `seq`, so a full replay on
+  // (re)connect is safe and lets a late subscriber catch up.
+  for (const evt of recent()) {
+    try { writeSse(res, evt.type, evt); } catch { /* client already gone */ }
+  }
+
+  const unsub = subscribe((evt) => {
+    try { writeSse(res, evt.type, evt); } catch { /* client gone — cleanup below */ }
+  });
+
+  // Comment heartbeat so intermediaries don't drop an idle stream.
+  const hb = setInterval(() => {
+    try { res.write(': heartbeat\n\n'); } catch { /* gone */ }
+  }, HEARTBEAT_MS);
+  if (typeof hb.unref === 'function') hb.unref();
+
+  let closed = false;
+  const cleanup = () => {
+    if (closed) return;
+    closed = true;
+    clearInterval(hb);
+    unsub();
+    if (!res.writableEnded) { try { res.end(); } catch { /* already ended */ } }
+  };
+  req.on('aborted', cleanup);
+  res.on('close', cleanup);
+}

package/daemon/routes/meta.mjs

@@ -4,6 +4,27 @@
 import { fs, nodePath, PROVIDERS, PROVIDER_INFO, maskApiKey, costFromUsage, RATE_CARD_SHAPE, composeSystemPrompt, listSkills, loadSkill, skillPath, installSkill, removeSkill, parseFrontmatter, skillsDefaultConfigDir, indexDb, skillSynth, sandboxListBackends, summarizeState, listWorkflowSessions, loadWorkflowState, aggregateNodeStats, validateConfig, validateRates, fileExists, readJson, readTextBody, writeJson, writeSseHead, writeSse, statusForProviderError, checkCostCap, accumulateMetricsFromCost, resolveProvider } from './_deps.mjs';
 import { fileURLToPath } from 'node:url';
 
+// In-memory byte cache for the dashboard's static assets (HTML/CSS/JS + the 20
+// avatar PNGs). These were re-read from disk with a synchronous fs.readFileSync
+// on EVERY request — each GET blocked the event loop reading the whole file.
+// They are shipped, read-only install assets, so cache the bytes; key by file
+// mtime so a dev edit (or reinstall) is still picked up without a daemon
+// restart. Avoids the per-request read of the (largest) PNG bodies.
+const _assetCache = new Map();  // absolute path → { mtimeMs, body: Buffer }
+
+export function _clearAssetCache() { _assetCache.clear(); }
+
+// Read a file, serving the bytes from _assetCache when its mtime is unchanged.
+// Throws (ENOENT etc.) when the file is missing — callers keep their 404/503.
+export function _readAssetCached(filePath) {
+  const mtimeMs = fs.statSync(filePath).mtimeMs;
+  const hit = _assetCache.get(filePath);
+  if (hit && hit.mtimeMs === mtimeMs) return hit.body;
+  const body = fs.readFileSync(filePath);
+  _assetCache.set(filePath, { mtimeMs, body });
+  return body;
+}
+
 // Serve a static asset that lives alongside the dashboard HTML in web/.
 // Used for the split-out dashboard.css / dashboard.js (CLAUDE.md §7: one
 // file = one responsibility). Same loopback origin as the JSON API, so no
@@ -14,7 +35,7 @@ function serveWebFile(c, filename, contentType) {
   try {
     const here = nodePath.dirname(fileURLToPath(import.meta.url));
     const filePath = nodePath.join(here, '..', '..', 'web', filename);
-    const body = fs.readFileSync(filePath);
+    const body = _readAssetCached(filePath);
     res.writeHead(200, { 'content-type': contentType, 'cache-control': 'no-cache' });
     return res.end(body);
   } catch (e) {
@@ -27,6 +48,19 @@ export async function dashboardCss(c) {
   return serveWebFile(c, 'dashboard.css', 'text/css; charset=utf-8');
 }
 
+// Serve a role avatar sprite (web/avatars/NN.png, NN = 01..20). The index is
+// validated to two digits before it reaches serveWebFile so no `..` traversal
+// is possible.
+export async function avatar(c) {
+  const m = /^\/avatars\/(\d{2})\.png$/.exec(c.path || '');
+  const n = m && Number(m[1]);
+  if (!n || n < 1 || n > 20) {
+    c.res.writeHead(404, { 'content-type': 'text/plain; charset=utf-8' });
+    return c.res.end('not found\n');
+  }
+  return serveWebFile(c, `avatars/${m[1]}.png`, 'image/png');
+}
+
 export async function dashboardJs(c) {
   return serveWebFile(c, 'dashboard.js', 'text/javascript; charset=utf-8');
 }
@@ -40,12 +74,9 @@ export async function dashboard(c) {
           // helpful text response when the file is missing (someone
           // ran the daemon out of a partial install).
           try {
-            const fs = await import('node:fs');
-            const path = await import('node:path');
-            const url = await import('node:url');
-            const here = path.dirname(url.fileURLToPath(import.meta.url));
-            const htmlPath = path.join(here, '..', '..', 'web', 'dashboard.html');
-            const body = fs.readFileSync(htmlPath, 'utf8');
+            const here = nodePath.dirname(fileURLToPath(import.meta.url));
+            const htmlPath = nodePath.join(here, '..', '..', 'web', 'dashboard.html');
+            const body = _readAssetCached(htmlPath);
             res.writeHead(200, {
               'content-type': 'text/html; charset=utf-8',
               'cache-control': 'no-cache',