@desplega.ai/agent-swarm 1.157.0 → 1.158.0

package/src/artifact-sdk/browser-sdk.ts

@@ -152,8 +152,9 @@ window.swarmSdk = new SwarmSDK();
 //
 // Auto-injected alongside the SDK. Exposes a tiny set of declarative web
 // components agents can drop into HTML pages without bundling anything. v1:
-// only \`<swarm-diff>\` (unified-diff renderer) + \`<swarm-diff-jumps>\` (a
-// sibling-anchor jump list). All zero-dep, pure DOM — Tailwind utility
+// \`<swarm-diff>\` (unified-diff renderer), \`<swarm-diff-jumps>\` (a
+// sibling-anchor jump list), and \`<swarm-cursors>\` (shared page pointers).
+// All zero-dep, pure DOM — Tailwind utility
 // classes are used freely since the Play CDN is already loaded by
 // PAGE_HEAD_DEFAULTS, but every visual aspect has inline-style fallbacks so
 // the component is still legible if Tailwind fails to load.
@@ -176,6 +177,201 @@ export const SWARM_UI_JS = `
   if (typeof window === 'undefined' || !window.customElements) return;
   if (window.customElements.get('swarm-diff')) return;
 
+  // Keep page-owned presence fields alongside the cursor. Room.presence.set
+  // replaces its payload, so retain each room's latest page data and merge
+  // the reserved __cursor field into it when the cursor moves.
+  var roomPresenceTrackers = new WeakMap();
+
+  function clonePresenceRecord(data) {
+    return data && typeof data === 'object' && !Array.isArray(data)
+      ? structuredClone(data)
+      : {};
+  }
+
+  function mergeCursorPresence(data, cursor) {
+    var merged = clonePresenceRecord(data);
+    if (cursor) merged.__cursor = { x: cursor.x, y: cursor.y };
+    else delete merged.__cursor;
+    return merged;
+  }
+
+  function trackRoomPresence(room) {
+    if (!room || !room.presence || typeof room.presence.set !== 'function') return null;
+    var existing = roomPresenceTrackers.get(room);
+    if (existing) return existing;
+
+    var presence = room.presence;
+    var originalSet = presence.set;
+    var pageData = {};
+    var cursor = null;
+    var tracker = {
+      setCursor: function(nextCursor) {
+        cursor = nextCursor;
+        return originalSet.call(presence, mergeCursorPresence(pageData, cursor));
+      },
+      clearCursor: function() {
+        if (!cursor) return;
+        return tracker.setCursor(null);
+      },
+    };
+
+    presence.set = function(data) {
+      pageData = clonePresenceRecord(data);
+      return originalSet.call(presence, cursor ? mergeCursorPresence(pageData, cursor) : data);
+    };
+    roomPresenceTrackers.set(room, tracker);
+    return tracker;
+  }
+
+  // Wrap room creation before page scripts run so presence.set calls made by
+  // page code are tracked even when they happen before <swarm-cursors> connects.
+  var cursorRoomRecords = new Map();
+  var sdkRoomMethods = new WeakMap();
+  var observedRoomClosers = new WeakSet();
+  var originalRoom = null;
+  function roomRecordKey(name) {
+    return name === undefined ? 'default' : name;
+  }
+
+  function observeRoom(record, room) {
+    record.hasResolvedRoom = true;
+    if (!cursorRoomRecords.has(record.name)) cursorRoomRecords.set(record.name, record);
+    trackRoomPresence(room);
+    if (room && typeof room.close === 'function' && !observedRoomClosers.has(room)) {
+      var originalClose = room.close;
+      room.close = function() {
+        if (cursorRoomRecords.get(record.name) === record) cursorRoomRecords.delete(record.name);
+        return originalClose.apply(room, arguments);
+      };
+      observedRoomClosers.add(room);
+    }
+    return room;
+  }
+
+  function observeRoomPromise(record, result) {
+    var observed = Promise.resolve(result).then(function(room) {
+      var resolvedRoom = observeRoom(record, room);
+      record.pageRequests--;
+      record.hasPageUse = true;
+      record.pageUsed = true;
+      record.promise = Promise.resolve(resolvedRoom);
+      return resolvedRoom;
+    }).catch(function(error) {
+      record.pageRequests--;
+      record.pageUsed = record.hasPageUse || record.pageRequests > 0;
+      if (!record.hasResolvedRoom
+        && record.pageRequests === 0
+        && cursorRoomRecords.get(record.name) === record)
+        cursorRoomRecords.delete(record.name);
+      if (record.cursorRefs === 0 && record.openedByCursor && !record.pageUsed)
+        closeCursorRoomIfUnused(record);
+      throw error;
+    });
+    record.pageRequests++;
+    record.pageUsed = true;
+    if (!record.promise) record.promise = observed;
+    return observed;
+  }
+
+  function closeCursorRoomIfUnused(record) {
+    if (record.closing || record.cursorRefs || !record.openedByCursor || record.pageUsed) return;
+    record.closing = true;
+    record.promise.then(function(room) {
+      if (record.cursorRefs || record.pageUsed) {
+        record.closing = false;
+        return;
+      }
+      if (cursorRoomRecords.get(record.name) === record) cursorRoomRecords.delete(record.name);
+      if (room && typeof room.close === 'function') return room.close();
+    }).catch(function() {
+      record.closing = false;
+    });
+  }
+
+  function instrumentSdk(sdk) {
+    if (!sdk || typeof sdk.room !== 'function') return null;
+    var existing = sdkRoomMethods.get(sdk);
+    if (existing) return existing;
+
+    var sdkOriginalRoom = sdk.room;
+    var wrappedRoom = function(name, options) {
+      var key = roomRecordKey(name);
+      var record = cursorRoomRecords.get(key);
+      var result = sdkOriginalRoom.call(sdk, name, options);
+      if (!record) {
+        record = {
+          name: key,
+          cursorRefs: 0,
+          openedByCursor: false,
+          pageUsed: false,
+          hasPageUse: false,
+          pageRequests: 0,
+          hasResolvedRoom: false,
+          promise: null,
+        };
+        cursorRoomRecords.set(key, record);
+      }
+      return observeRoomPromise(record, result);
+    };
+    sdk.room = wrappedRoom;
+    var methods = { original: sdkOriginalRoom, wrapped: wrappedRoom };
+    sdkRoomMethods.set(sdk, methods);
+    return methods;
+  }
+
+  if (window.swarmSdk) {
+    var singletonRoomMethods = instrumentSdk(window.swarmSdk);
+    originalRoom = singletonRoomMethods && singletonRoomMethods.original;
+  }
+  if (typeof window.SwarmSDK === 'function') {
+    var OriginalSwarmSDK = window.SwarmSDK;
+    window.SwarmSDK = new Proxy(OriginalSwarmSDK, {
+      construct: function(target, args, newTarget) {
+        var sdk = Reflect.construct(target, args, newTarget);
+        instrumentSdk(sdk);
+        return sdk;
+      },
+    });
+  }
+
+  function acquireCursorRoom(name, options) {
+    var key = roomRecordKey(name);
+    var record = cursorRoomRecords.get(key);
+    if (record) {
+      record.cursorRefs++;
+      return { record: record, promise: record.promise };
+    }
+
+    record = {
+      name: key,
+      cursorRefs: 1,
+      openedByCursor: true,
+      pageUsed: false,
+      hasPageUse: false,
+      pageRequests: 0,
+      hasResolvedRoom: false,
+      closing: false,
+      promise: null,
+    };
+    cursorRoomRecords.set(key, record);
+    record.promise = Promise.resolve().then(function() {
+      return originalRoom(name, options);
+    }).then(function(room) {
+      return observeRoom(record, room);
+    }).catch(function(error) {
+      if (cursorRoomRecords.get(key) === record) cursorRoomRecords.delete(key);
+      throw error;
+    });
+    return { record: record, promise: record.promise };
+  }
+
+  function releaseCursorRoom(record, presence) {
+    if (!record || record.cursorRefs < 1) return;
+    if (record.cursorRefs === 1 && presence) presence.clearCursor();
+    record.cursorRefs--;
+    closeCursorRoomIfUnused(record);
+  }
+
   var SEV_COLOR = {
     error: '#ef4444',
     warn:  '#f59e0b',
@@ -418,5 +614,243 @@ export const SWARM_UI_JS = `
     }
   }
   window.customElements.define('swarm-diff-jumps', SwarmDiffJumpsElement);
+
+  var CURSOR_IDLE_MS = 3000;
+  var CURSOR_SMOOTHING = 0.28;
+
+  function cursorColor(userId) {
+    var hash = 2166136261;
+    var value = String(userId || '');
+    for (var i = 0; i < value.length; i++) {
+      hash ^= value.charCodeAt(i);
+      hash = Math.imul(hash, 16777619);
+    }
+    return 'hsl(' + ((hash >>> 0) % 360) + ', 72%, 42%)';
+  }
+
+  function documentSize() {
+    var root = document.documentElement || {};
+    return {
+      width: Math.max(1, root.scrollWidth || root.clientWidth || window.innerWidth || 1),
+      height: Math.max(1, root.scrollHeight || root.clientHeight || window.innerHeight || 1),
+    };
+  }
+
+  function cursorMarkup(name, color) {
+    // CursorPointer + CursorBody label structure adapted from Kibo UI (MIT):
+    // https://github.com/shadcnblocks/kibo/blob/main/packages/cursor/index.tsx
+    return '<svg aria-hidden="true" focusable="false" height="20" width="20" viewBox="0 0 20 20" xmlns="http://www.w3.org/2000/svg" style="width:20px;height:20px;flex:none;filter:drop-shadow(0 1px 1px rgba(0,0,0,.2));">'
+      + '<path d="M19.438 6.716 1.115.05A.832.832 0 0 0 .05 1.116L6.712 19.45a.834.834 0 0 0 1.557.025l3.198-8 7.995-3.2a.833.833 0 0 0 0-1.559h-.024Z" fill="currentColor"></path>'
+      + '</svg>'
+      + '<span style="position:relative;margin-left:14px;display:flex;flex-direction:column;white-space:nowrap;border-radius:12px;padding:4px 12px 4px 10px;font-family:system-ui,sans-serif;font-size:12px;font-weight:500;line-height:1.4;background:' + color + ';color:#fff;box-shadow:0 2px 6px rgba(0,0,0,.18);">'
+      + esc(name || 'Guest')
+      + '</span>';
+  }
+
+  class SwarmCursorsElement extends HTMLElement {
+    connectedCallback() {
+      if (this._startPromise) return;
+      var roomName = this.getAttribute('room');
+      if (!roomName || !originalRoom) return;
+
+      var self = this;
+      var lifecycle = (this._lifecycle || 0) + 1;
+      this._lifecycle = lifecycle;
+      var begin = function() {
+        self._onDomReady = null;
+      if (!self.isConnected || self._lifecycle !== lifecycle) return;
+        var schemaVersion = self.getAttribute('schema-version');
+        var options = schemaVersion == null ? {} : { schemaVersion: Number(schemaVersion) };
+        var acquired = acquireCursorRoom(roomName, options);
+        self._roomRecord = acquired.record;
+        self._startPromise = acquired.promise.then(function(room) {
+        if (!self.isConnected || self._lifecycle !== lifecycle) return;
+        self._startPromise = null;
+        self._room = room;
+        self._presence = trackRoomPresence(room);
+        if (!self._presence) return;
+        self._pointers = new Map();
+        self._cursorStates = new Map();
+
+        self._overlay = document.createElement('div');
+        self._overlay.setAttribute('aria-hidden', 'true');
+        self._overlay.style.cssText = 'position:fixed;inset:0;z-index:2147483647;pointer-events:none;overflow:hidden;';
+        var parent = document.body || document.documentElement;
+        if (parent) parent.appendChild(self._overlay);
+
+        self._onPresence = function(peers) { self._renderPeers(peers || []); };
+        self._onPointerMove = function(event) {
+          var size = documentSize();
+          var scrollX = window.scrollX || window.pageXOffset || 0;
+          var scrollY = window.scrollY || window.pageYOffset || 0;
+          var pageX = typeof event.pageX === 'number' ? event.pageX : event.clientX + scrollX;
+          var pageY = typeof event.pageY === 'number' ? event.pageY : event.clientY + scrollY;
+          var x = Math.max(0, Math.min(1, pageX / size.width));
+          var y = Math.max(0, Math.min(1, pageY / size.height));
+          self._presence.setCursor({ x: x, y: y });
+        };
+        self._onPointerLeave = function() {
+          self._presence.clearCursor();
+        };
+
+        self._unsubscribe = room.on('presence', self._onPresence);
+        document.addEventListener('pointermove', self._onPointerMove, { passive: true });
+        document.addEventListener('pointerleave', self._onPointerLeave);
+        self._renderPeers(room.presence.peers || []);
+      }).catch(function(error) {
+        self._startPromise = null;
+        console.warn('[swarm-cursors] failed to join room:', error);
+      });
+      };
+      if (document.readyState === 'loading') {
+        this._onDomReady = function() { queueMicrotask(begin); };
+        this._startPromise = Promise.resolve();
+        document.addEventListener('DOMContentLoaded', this._onDomReady, { once: true });
+      } else {
+        begin();
+      }
+    }
+
+    _renderPeers(peers) {
+      if (!this._pointers) return;
+      var seen = new Set();
+      var activePeerIds = new Set();
+      var includeAgents = this.hasAttribute('include-agents');
+      var ownId = this._room && this._room.me && this._room.me.userId;
+      var now = Date.now();
+
+      for (var i = 0; i < peers.length; i++) {
+        var peer = peers[i];
+        if (!peer || !peer.userId || peer.userId === ownId) continue;
+        if (peer.kind === 'agent' && !includeAgents) continue;
+        var data = peer.data && typeof peer.data === 'object' ? peer.data : null;
+        var cursor = data && data.__cursor;
+        if (!cursor || typeof cursor.x !== 'number' || typeof cursor.y !== 'number'
+          || !Number.isFinite(cursor.x) || !Number.isFinite(cursor.y)) continue;
+
+        var id = String(peer.userId);
+        activePeerIds.add(id);
+        var state = this._cursorStates.get(id);
+        if (!state || state.x !== cursor.x || state.y !== cursor.y) {
+          state = { x: cursor.x, y: cursor.y, lastSeen: now };
+          this._cursorStates.set(id, state);
+        }
+        if (now - state.lastSeen > CURSOR_IDLE_MS) continue;
+
+        var entry = this._pointers.get(id);
+        if (!entry) {
+          entry = this._createPointer(peer);
+          this._pointers.set(id, entry);
+        }
+        entry.cursor = { x: state.x, y: state.y };
+        entry.lastSeen = state.lastSeen;
+        if (entry.name !== peer.name) {
+          entry.name = peer.name || 'Guest';
+          entry.node.innerHTML = cursorMarkup(entry.name, entry.color);
+        }
+        seen.add(id);
+      }
+
+      var ids = Array.from(this._pointers.keys());
+      for (var j = 0; j < ids.length; j++) {
+        if (!seen.has(ids[j])) this._removePointer(ids[j]);
+      }
+      var stateIds = Array.from(this._cursorStates.keys());
+      for (var k = 0; k < stateIds.length; k++) {
+        if (!activePeerIds.has(stateIds[k])) this._cursorStates.delete(stateIds[k]);
+      }
+      this._scheduleFrame();
+    }
+
+    _createPointer(peer) {
+      var color = cursorColor(peer.userId);
+      var node = document.createElement('div');
+      node.style.cssText = 'position:absolute;left:0;top:0;display:flex;align-items:flex-start;pointer-events:none;user-select:none;will-change:transform;color:' + color + ';';
+      node.innerHTML = cursorMarkup(peer.name || 'Guest', color);
+      this._overlay.appendChild(node);
+      return {
+        node: node,
+        color: color,
+        name: peer.name || 'Guest',
+        cursor: null,
+        x: null,
+        y: null,
+        lastSeen: Date.now(),
+      };
+    }
+
+    _removePointer(id) {
+      var entry = this._pointers.get(id);
+      if (entry && entry.node.parentNode) entry.node.parentNode.removeChild(entry.node);
+      this._pointers.delete(id);
+    }
+
+    _scheduleFrame() {
+      if (this._frameId != null || !this._pointers || !this._pointers.size
+        || typeof window.requestAnimationFrame !== 'function') return;
+      var self = this;
+      this._frameId = window.requestAnimationFrame(function() { self._animate(); });
+    }
+
+    _animate() {
+      this._frameId = null;
+      if (!this._pointers || !this._overlay) return;
+      var now = Date.now();
+      var size = documentSize();
+      var scrollX = window.scrollX || window.pageXOffset || 0;
+      var scrollY = window.scrollY || window.pageYOffset || 0;
+      var ids = Array.from(this._pointers.keys());
+
+      for (var i = 0; i < ids.length; i++) {
+        var id = ids[i];
+        var entry = this._pointers.get(id);
+        if (now - entry.lastSeen > CURSOR_IDLE_MS) {
+          this._removePointer(id);
+          continue;
+        }
+        var targetX = entry.cursor.x * size.width - scrollX;
+        var targetY = entry.cursor.y * size.height - scrollY;
+        if (entry.x == null || entry.y == null) {
+          entry.x = targetX;
+          entry.y = targetY;
+        } else {
+          // Exponential interpolation keeps 50 ms presence updates from jumping.
+          entry.x += (targetX - entry.x) * CURSOR_SMOOTHING;
+          entry.y += (targetY - entry.y) * CURSOR_SMOOTHING;
+        }
+        entry.node.style.transform = 'translate3d(' + Math.round(entry.x) + 'px,' + Math.round(entry.y) + 'px,0)';
+      }
+      this._scheduleFrame();
+    }
+
+    disconnectedCallback() {
+      this._lifecycle = (this._lifecycle || 0) + 1;
+      this._startPromise = null;
+      if (this._onDomReady) {
+        document.removeEventListener('DOMContentLoaded', this._onDomReady);
+        this._onDomReady = null;
+      }
+      if (this._unsubscribe) this._unsubscribe();
+      if (this._onPointerMove) document.removeEventListener('pointermove', this._onPointerMove);
+      if (this._onPointerLeave) document.removeEventListener('pointerleave', this._onPointerLeave);
+      if (this._roomRecord) releaseCursorRoom(this._roomRecord, this._presence);
+      if (this._frameId != null && typeof window.cancelAnimationFrame === 'function')
+        window.cancelAnimationFrame(this._frameId);
+      if (this._pointers) {
+        var ids = Array.from(this._pointers.keys());
+        for (var i = 0; i < ids.length; i++) this._removePointer(ids[i]);
+      }
+      if (this._overlay && this._overlay.parentNode)
+        this._overlay.parentNode.removeChild(this._overlay);
+      this._room = null;
+      this._roomRecord = null;
+      this._presence = null;
+      this._overlay = null;
+      this._pointers = null;
+      this._cursorStates = null;
+      this._frameId = null;
+    }
+  }
+  window.customElements.define('swarm-cursors', SwarmCursorsElement);
 })();
 `;

package/src/be/approval-sweeps.ts

@@ -0,0 +1,109 @@
+import { cancelApprovalRequestAndRun } from "../workflows/approval-cancel";
+import { createApprovalFollowUpTask } from "../workflows/approval-notifications";
+import {
+  type ApprovalRequest,
+  getDbClient,
+  getExpiredPendingApprovals,
+  getStaleApprovalRequests,
+  resolveApprovalRequest,
+} from "./db";
+
+export const DEFAULT_APPROVAL_REQUEST_AUTO_CANCELLATION_DAYS = 7;
+
+// Days a pending approval request with no explicit expiresAt may wait before
+// the heartbeat sweep cancels it. 0 turns auto-cancellation off.
+//
+// Read DYNAMICALLY, not captured at module load: this module is imported by
+// the heartbeat before `loadGlobalConfigsIntoEnv()` hydrates swarm_config
+// into `process.env`, so a module-level capture would leave a
+// dashboard-saved override permanently inert (even across restarts).
+export function approvalRequestAutoCancellationDays(): number {
+  const raw = process.env.APPROVAL_REQUEST_AUTO_CANCELLATION_DAYS;
+  if (raw != null && /^\d+$/.test(raw.trim())) {
+    return Number.parseInt(raw.trim(), 10);
+  }
+  return DEFAULT_APPROVAL_REQUEST_AUTO_CANCELLATION_DAYS;
+}
+
+/**
+ * Cancel every pending request with no explicit expiresAt that is older than
+ * APPROVAL_REQUEST_AUTO_CANCELLATION_DAYS. A request that gates a live
+ * workflow run cancels that run too. Creates no follow-up task and emits no
+ * workflow event.
+ */
+export async function autoCancelStaleApprovalRequests(
+  now = new Date(),
+): Promise<{ cancelled: ApprovalRequest[]; runsCancelled: string[] }> {
+  const days = approvalRequestAutoCancellationDays();
+  if (days === 0) return { cancelled: [], runsCancelled: [] };
+
+  const cutoff = new Date(now.getTime() - days * 86_400_000).toISOString();
+  const stale = await getStaleApprovalRequests({ cutoff });
+  const reason = `Auto-cancelled by the approval sweep after ${days} days with no response`;
+
+  // Each request and its live run cancel in 1 transaction. A failed row
+  // rolls back alone and the next tick retries it.
+  const cancelled: ApprovalRequest[] = [];
+  const runsCancelled: string[] = [];
+  for (const row of stale) {
+    try {
+      const result = await cancelApprovalRequestAndRun(row.id, {
+        reason,
+        resolvedBy: null,
+        slackReason: "auto-cancelled with no response",
+      });
+      if (!result || "timedOut" in result) continue;
+      cancelled.push(result.request);
+      if (result.runCancelled && result.request.workflowRunId) {
+        runsCancelled.push(result.request.workflowRunId);
+      }
+    } catch (err) {
+      console.error(
+        `[approval-sweep] could not cancel approval request ${row.id}: ${err instanceof Error ? err.message : String(err)}`,
+      );
+    }
+  }
+
+  if (cancelled.length > 0) {
+    console.log(
+      `[approval-sweep] auto-cancelled ${cancelled.length} stale approval requests and ${runsCancelled.length} workflow runs`,
+    );
+  }
+  return { cancelled, runsCancelled };
+}
+
+/**
+ * Set `timeout` on every pending request whose explicit expiresAt passed,
+ * whatever the state of its workflow run. A standalone request whose source
+ * task is still active gets a `hitl.timeout` follow-up task.
+ */
+export async function timeoutExpiredApprovalRequests(
+  now = new Date(),
+): Promise<{ timedOut: ApprovalRequest[] }> {
+  const expired = await getExpiredPendingApprovals({ now: now.toISOString() });
+  const timedOut: ApprovalRequest[] = [];
+  for (const row of expired) {
+    // The status change and the follow-up task commit together: a crash
+    // between them cannot leave a timeout with no follow-up task.
+    try {
+      const updated = await getDbClient().transaction(async () => {
+        const request = await resolveApprovalRequest(row.id, {
+          status: "timeout",
+          resolutionReason: `Timed out by the approval sweep: no answer before ${row.expiresAt}`,
+        });
+        if (request) await createApprovalFollowUpTask(request, "hitl.timeout");
+        return request;
+      });
+      if (updated) timedOut.push(updated);
+    } catch (err) {
+      console.error(
+        `[approval-sweep] could not time out approval request ${row.id}: ${err instanceof Error ? err.message : String(err)}`,
+      );
+    }
+  }
+
+  if (timedOut.length > 0) {
+    console.log(`[approval-sweep] timed out ${timedOut.length} expired approval requests`);
+  }
+  return { timedOut };
+}

package/src/be/boot-seeds.ts

@@ -0,0 +1,40 @@
+/**
+ * Once-per-database guards for seed work that belongs to boot.
+ *
+ * `createServer()` runs on every new MCP session (`POST /mcp`), and it used to
+ * re-run the pricing seed (an 8.6 MB `JSON.parse` plus a 3,400-row
+ * `BEGIN IMMEDIATE` insert transaction) and the RBAC seed sync on each one.
+ * All of that is synchronous on the API's single event loop, so every agent
+ * session start stalled every other route. Both seeds are idempotent, so the
+ * first caller for a given database handle does the work and later callers
+ * return immediately.
+ *
+ * The guard is keyed on the live `Database` handle rather than a bare boolean:
+ * `closeDb()` + `initDb()` (tests, DB swaps) yields a new handle that has not
+ * been seeded, so it is seeded again. A failed seed does not mark the handle
+ * done, so the next caller retries and still sees the error.
+ */
+
+import type { Database } from "bun:sqlite";
+import { getDb } from "./db";
+import { ensureRbacSeedsSynced } from "./rbac-roles";
+import { seedPricingFromModelsDev } from "./seed-pricing";
+
+const pricingSeededDbs = new WeakSet<Database>();
+const rbacSyncedDbs = new WeakSet<Database>();
+
+/** Seed the pricing table from the vendored models.dev snapshot. */
+export function ensurePricingSeeded(): void {
+  const db = getDb();
+  if (pricingSeededDbs.has(db)) return;
+  seedPricingFromModelsDev();
+  pricingSeededDbs.add(db);
+}
+
+/** Sync the built-in RBAC roles, permissions and default-role trigger. */
+export function ensureRbacSeeded(): void {
+  const db = getDb();
+  if (rbacSyncedDbs.has(db)) return;
+  ensureRbacSeedsSynced();
+  rbacSyncedDbs.add(db);
+}

package/src/be/chunking.ts

@@ -167,8 +167,8 @@ function hardSplit(text: string): string[] {
   while (start < text.length) {
     const end = Math.min(start + MAX_CHUNK_SIZE, text.length);
     chunks.push(text.slice(start, end).trim());
+    if (end === text.length) break;
     start = end - CHUNK_OVERLAP;
-    if (start >= text.length - MIN_CHUNK_SIZE) break;
   }
   return chunks.filter((c) => c.length > 0);
 }

package/src/be/db/agents.ts

@@ -636,3 +636,23 @@ export function isAgentEligibleForTask(
 
   return hasRequiredCapabilities();
 }
+
+/**
+ * Tasks created per UTC day for one agent, oldest first, over the last `days`
+ * days. Days with no tasks are omitted; the caller fills the gaps. Backs the
+ * dashboard activity heatmap on /agents/:id.
+ */
+export async function getAgentDailyTaskCounts(
+  agentId: string,
+  days: number,
+): Promise<{ date: string; count: number }[]> {
+  const since = new Date(Date.now() - days * 86_400_000).toISOString().slice(0, 10);
+  return getDbClient().query<{ date: string; count: number }>(
+    `SELECT substr(createdAt, 1, 10) AS date, COUNT(*) AS count
+       FROM agent_tasks
+      WHERE agentId = ? AND createdAt >= ?
+      GROUP BY date
+      ORDER BY date`,
+    [agentId, since],
+  );
+}