@smartmemory/compose 0.1.0

package/server/session-manager.js

@@ -0,0 +1,403 @@
+/**
+ * SessionManager — session lifecycle, per-item accumulator, batched Haiku summaries.
+ *
+ * Sessions are NOT tracker entities — they're execution context that accumulates
+ * tool-use events, groups them into work blocks by resolved tracker item, and
+ * periodically summarises batches via Haiku.
+ */
+
+import path from 'node:path';
+import { randomBytes } from 'node:crypto';
+import { fileURLToPath } from 'node:url';
+import { copyFile, mkdir } from 'node:fs/promises';
+import { buildSummaryPrompt, summarize } from './summarizer.js';
+import { updateBlock, closeCurrentBlock } from './block-tracker.js';
+import { serializeSession, persistSession, readLastSession, readSessionsByFeature } from './session-store.js';
+
+import { getTargetRoot, getDataDir } from './project-root.js';
+
+const PROJECT_ROOT = getTargetRoot();
+const SESSIONS_FILE = path.join(getDataDir(), 'sessions.json');
+
+/** Tools whose events count toward the Haiku summary batch threshold */
+const SIGNIFICANT_TOOLS = new Set(['Write', 'Edit', 'Bash', 'NotebookEdit']);
+
+/** Number of significant events before triggering a Haiku summary call */
+const BATCH_SIZE = 4;
+
+export class SessionManager {
+  constructor({ getFeaturePhase, featureRoot, sessionsFile } = {}) {
+    /** @type {object|null} Current active session */
+    this.currentSession = null;
+
+    /** @type {function} Callback to get current phase for a featureCode */
+    this._getFeaturePhase = getFeaturePhase || (() => null);
+
+    /** @type {string} Root directory for feature folders */
+    this._featureRoot = featureRoot || 'docs/features';
+
+    /** @type {string} Path to sessions.json — injectable for tests */
+    this._sessionsFile = sessionsFile || SESSIONS_FILE;
+
+    /** @type {Array<{tool,filePath,input,itemIds,timestamp}>} Buffered significant events */
+    this._pendingBatch = [];
+
+    /** @type {boolean} Whether a Haiku flush is currently in-flight */
+    this._flushing = false;
+
+    /** @type {Promise|null} In-flight flush promise for awaiting */
+    this._flushPromise = null;
+
+    /** @type {Array<function>} Callbacks for when summaries arrive */
+    this._summaryListeners = [];
+  }
+
+  // ---------------------------------------------------------------------------
+  // Public API
+  // ---------------------------------------------------------------------------
+
+  /**
+   * Start a new session.
+   * @param {'startup'|'resume'|'clear'|'compact'} source — what triggered the session
+   */
+  startSession(source = 'startup') {
+    // Close any lingering session synchronously (skip Haiku flush to avoid async race)
+    if (this.currentSession) {
+      closeCurrentBlock(this.currentSession);
+      const old = this.currentSession;
+      old.endedAt = new Date().toISOString();
+      old.endReason = 'replaced';
+      this._persist(this._serialize(old));
+      console.log(`[session] Ended ${old.id} (reason: replaced, tools: ${old.toolCount})`);
+      this.currentSession = null;
+    }
+
+    const now = new Date().toISOString();
+    this.currentSession = {
+      id: `session-${Date.now()}-${randomBytes(3).toString('hex')}`,
+      startedAt: now,
+      source,
+      toolCount: 0,
+      items: new Map(),          // itemId → { title, summaries[], reads, writes, firstTouched, lastTouched }
+      currentBlock: null,        // { itemIds: Set, startedAt, toolCount } | null
+      blocks: [],                // closed blocks: { itemIds[], startedAt, endedAt, toolCount }
+      commits: [],
+      errors: [],                // { type, severity, tool, message, itemIds, timestamp }
+      featureCode: null,
+      featureItemId: null,
+      phaseAtBind: null,
+      boundAt: null,
+    };
+
+    this._pendingBatch = [];
+    this._flushing = false;
+    this._flushPromise = null;
+
+    console.log(`[session] Started ${this.currentSession.id} (source: ${source})`);
+    return this.currentSession;
+  }
+
+  /**
+   * End the current session, persist it, return session data.
+   * @param {string} reason — why the session ended
+   * @param {string} [transcriptPath] — optional path to conversation transcript
+   * @returns {object|null} The completed session data, or null if no session active
+   */
+  async endSession(reason = 'manual', transcriptPath = null) {
+    if (!this.currentSession) return null;
+
+    await this.flush();
+
+    closeCurrentBlock(this.currentSession);
+
+    const session = this.currentSession;
+    session.endedAt = new Date().toISOString();
+    session.endReason = reason;
+    if (transcriptPath) session.transcriptPath = transcriptPath;
+
+    // Capture phaseAtEnd for bound sessions
+    if (session.featureCode) {
+      session.phaseAtEnd = this._getFeaturePhase(session.featureCode);
+    }
+
+    // Auto-file transcript to feature folder — awaited to ensure copy completes before process exit
+    if (session.featureCode && transcriptPath) {
+      try {
+        await this._fileTranscript(session.featureCode, session.id, transcriptPath);
+      } catch (err) {
+        console.error(`[session] Failed to file transcript to ${session.featureCode}:`, err.message);
+      }
+    }
+
+    const serializable = this._serialize(session);
+
+    this._persist(serializable);
+
+    console.log(`[session] Ended ${session.id} (reason: ${reason}, tools: ${session.toolCount})`);
+
+    this.currentSession = null;
+    this._pendingBatch = [];
+    return serializable;
+  }
+
+  /** Record a tool-use event. Accumulates per-item stats, detects block boundaries,
+   * and buffers significant events for Haiku summarization. */
+  recordActivity(tool, category, filePath, input, resolvedItems = []) {
+    if (!this.currentSession) return;
+
+    const now = new Date().toISOString();
+    const session = this.currentSession;
+    session.toolCount++;
+
+    const isWrite = ['Write', 'Edit', 'NotebookEdit'].includes(tool);
+    const isRead = tool === 'Read';
+
+    for (const item of resolvedItems) {
+      let acc = session.items.get(item.id);
+      if (!acc) {
+        acc = {
+          title: item.title,
+          summaries: [],
+          reads: 0,
+          writes: 0,
+          firstTouched: now,
+          lastTouched: now,
+        };
+        session.items.set(item.id, acc);
+      }
+      acc.lastTouched = now;
+      if (isRead) acc.reads++;
+      if (isWrite) acc.writes++;
+    }
+
+    const itemIds = resolvedItems.map(i => i.id);
+    if (itemIds.length > 0) {
+      updateBlock(session, itemIds, now, category);
+    }
+
+    if (SIGNIFICANT_TOOLS.has(tool)) {
+      this._pendingBatch.push({
+        tool,
+        category,
+        filePath,
+        input: this._truncateInput(input),
+        itemIds,
+        itemTitles: resolvedItems.map(i => i.title),
+        timestamp: now,
+      });
+
+      if (this._pendingBatch.length >= BATCH_SIZE && !this._flushing) {
+        this._flushPromise = this._flushSummary().catch(err => {
+          console.error('[session] Background flush failed:', err.message);
+        });
+      }
+    }
+  }
+
+  /** Record a detected error. Stored for persistence + Haiku batch context. */
+  recordError(tool, filePath, errorType, severity, message, resolvedItems = []) {
+    if (!this.currentSession) return;
+
+    this.currentSession.errors.push({
+      type: errorType,
+      severity,
+      tool,
+      filePath: filePath || null,
+      message: message.length > 200 ? message.slice(0, 197) + '...' : message,
+      itemIds: resolvedItems.map(i => i.id),
+      timestamp: new Date().toISOString(),
+    });
+  }
+
+  /** Force-flush any pending events to Haiku. Awaitable. */
+  async flush() {
+    if (this._flushPromise) {
+      await this._flushPromise;
+    }
+    if (this._pendingBatch.length > 0) {
+      await this._flushSummary();
+    }
+  }
+
+  /** Register a callback for when Haiku summaries arrive. */
+  onSummary(fn) {
+    this._summaryListeners.push(fn);
+  }
+
+  /** Return the most recent session summary for the SessionStart hook. */
+  getContext(featureCode) {
+    if (featureCode) {
+      return readSessionsByFeature(featureCode, 1, this._sessionsFile)[0] || null;
+    }
+    return readLastSession(this._sessionsFile);
+  }
+
+  /** Bind the current session to a lifecycle feature. One-shot — re-bind returns already_bound. */
+  bindToFeature(featureCode, itemId, phase) {
+    const session = this.currentSession;
+    if (!session) throw new Error('No active session');
+    if (session.featureCode) {
+      return { already_bound: true, featureCode: session.featureCode };
+    }
+    session.featureCode = featureCode;
+    session.featureItemId = itemId;
+    session.phaseAtBind = phase;
+    session.boundAt = new Date().toISOString();
+    return { bound: true, featureCode, itemId, phase };
+  }
+
+  /** COMP-UX-2b: Return recent sessions for visionState broadcast. */
+  getRecentSessions(limit = 20) {
+    const sessions = [];
+    // Current active session
+    if (this.currentSession) {
+      const s = this.currentSession;
+      let reads = 0, writes = 0, lastSummary = null;
+      if (s.items instanceof Map) {
+        for (const v of s.items.values()) {
+          reads += v.reads || 0;
+          writes += v.writes || 0;
+          if (v.summaries?.length) {
+            const s_ = v.summaries[v.summaries.length - 1];
+            lastSummary = typeof s_ === 'string' ? s_ : s_?.summary || null;
+          }
+        }
+      }
+      sessions.push({
+        id: s.id,
+        status: 'active',
+        agent: 'claude',
+        featureCode: s.featureCode || null,
+        summary: lastSummary,
+        startedAt: s.startedAt,
+        reads, writes,
+        errors: s.errors?.length || 0,
+        workType: s.phaseAtBind || 'general',
+        toolCount: s.toolCount || 0,
+      });
+    }
+    // Persisted sessions (most recent first)
+    try {
+      const persisted = readSessionsByFeature(null, limit, this._sessionsFile);
+      for (const s of persisted) {
+        if (sessions.length >= limit) break;
+        if (sessions.some(x => x.id === s.id)) continue;
+        // Aggregate reads/writes/summaries from per-item data
+        let reads = 0, writes = 0;
+        let lastSummary = null;
+        if (s.items && typeof s.items === 'object') {
+          for (const v of Object.values(s.items)) {
+            reads += v.reads || 0;
+            writes += v.writes || 0;
+            if (v.summaries?.length) {
+            const s_ = v.summaries[v.summaries.length - 1];
+            lastSummary = typeof s_ === 'string' ? s_ : s_?.summary || null;
+          }
+          }
+        }
+        sessions.push({
+          id: s.id,
+          status: 'completed',
+          agent: 'claude',
+          featureCode: s.featureCode || null,
+          summary: lastSummary,
+          startedAt: s.startedAt,
+          reads, writes,
+          errors: s.errors?.length || 0,
+          workType: s.phaseAtBind || 'general',
+          toolCount: s.toolCount || 0,
+        });
+      }
+    } catch { /* sessions file may not exist yet */ }
+    return sessions;
+  }
+
+  /** Expose sessions file path for use by routes. */
+  get sessionsFile() { return this._sessionsFile; }
+
+  /** True if the current session crosses the journal-worthiness threshold. */
+  meetsJournalThreshold() {
+    if (!this.currentSession) return false;
+    if (this.currentSession.toolCount > 20) return true;
+    const elapsed = Date.now() - new Date(this.currentSession.startedAt).getTime();
+    return elapsed > 10 * 60 * 1000;
+  }
+
+  // ── Internal: Haiku pipeline ─────────────────────────────────────────────
+
+  async _flushSummary() {
+    if (this._pendingBatch.length === 0) return;
+    this._flushing = true;
+
+    const batch = this._pendingBatch.splice(0);
+
+    try {
+      const prompt = buildSummaryPrompt(batch, PROJECT_ROOT);
+      const result = await summarize(prompt, { projectRoot: PROJECT_ROOT });
+      if (result) {
+        this._distributeSummary(result, batch);
+        for (const fn of this._summaryListeners) {
+          try { fn(result, batch); } catch { /* listener errors don't propagate */ }
+        }
+      }
+    } catch (err) {
+      console.error('[session] Haiku summary failed, raw data preserved:', err.message);
+    } finally {
+      this._flushing = false;
+      this._flushPromise = null;
+    }
+  }
+
+  _distributeSummary(result, batch) {
+    if (!this.currentSession) return;
+
+    const itemIds = new Set();
+    for (const evt of batch) {
+      for (const id of evt.itemIds) {
+        itemIds.add(id);
+      }
+    }
+
+    const summary = {
+      ...result,
+      batchSize: batch.length,
+      timestamp: new Date().toISOString(),
+    };
+
+    for (const id of itemIds) {
+      const acc = this.currentSession.items.get(id);
+      if (acc) {
+        acc.summaries.push(summary);
+      }
+    }
+
+    console.log(`[session] Haiku summary distributed to ${itemIds.size} items: "${result.summary}"`);
+  }
+
+  // ── Internal: Utilities ──────────────────────────────────────────────────
+
+  _truncateInput(input) {
+    if (!input) return '(no input)';
+    const raw = input.content
+      || input.new_string
+      || input.command
+      || input.new_source
+      || input.old_string
+      || input.pattern
+      || input.query
+      || (typeof input === 'string' ? input : JSON.stringify(input));
+    const str = typeof raw === 'string' ? raw : JSON.stringify(raw);
+    return str.length > 200 ? str.slice(0, 197) + '...' : str;
+  }
+
+  async _fileTranscript(featureCode, sessionId, transcriptPath) {
+    const ext = path.extname(transcriptPath) || '.transcript';
+    const sessionsDir = path.join(this._featureRoot, featureCode, 'sessions');
+    await mkdir(sessionsDir, { recursive: true });
+    const dest = path.join(sessionsDir, `${sessionId}${ext}`);
+    await copyFile(transcriptPath, dest);
+  }
+
+  _serialize(session) { return serializeSession(session); }
+  _persist(session)   { persistSession(session, this._sessionsFile); }
+}

package/server/session-routes.js

@@ -0,0 +1,190 @@
+/**
+ * session-routes.js — Session lifecycle REST routes.
+ *
+ * Routes:
+ *   POST /api/session/start
+ *   POST /api/session/end
+ *   POST /api/session/bind
+ *   GET  /api/session/history
+ *   GET  /api/session/current
+ */
+
+import { readSessionsByFeature } from './session-store.js';
+
+/**
+ * Attach session lifecycle routes to an Express app.
+ *
+ * @param {object} app — Express app
+ * @param {{
+ *   sessionManager: object,
+ *   scheduleBroadcast: function,
+ *   broadcastMessage: function,
+ *   spawnJournalAgent: function,
+ *   projectRoot: string,
+ *   store: object
+ * }} deps
+ */
+export function attachSessionRoutes(app, { sessionManager, scheduleBroadcast, broadcastMessage, spawnJournalAgent, store }) {
+  // POST /api/session/start — hook calls this on SessionStart
+  app.post('/api/session/start', (req, res) => {
+    const { source } = req.body || {};
+    if (!sessionManager) return res.status(503).json({ error: 'No session manager' });
+    const session = sessionManager.startSession(source || 'startup');
+    const context = sessionManager.getContext();
+
+    broadcastMessage({
+      type: 'sessionStart',
+      sessionId: session.id,
+      source: source || 'startup',
+      timestamp: new Date().toISOString(),
+    });
+    scheduleBroadcast(); // COMP-UX-2b: refresh sessions list in visionState
+
+    res.json({ sessionId: session.id, context });
+  });
+
+  // POST /api/session/end — hook calls this on SessionEnd
+  app.post('/api/session/end', async (req, res) => {
+    const { reason, transcriptPath } = req.body || {};
+    if (!sessionManager) return res.status(503).json({ error: 'No session manager' });
+    const meetsThreshold = sessionManager.meetsJournalThreshold();
+    const session = await sessionManager.endSession(reason, transcriptPath);
+    if (!session) return res.json({ sessionId: null, persisted: false });
+    let journalSpawned = false;
+    if (meetsThreshold && transcriptPath) {
+      spawnJournalAgent(session, transcriptPath);
+      journalSpawned = true;
+    }
+
+    broadcastMessage({
+      type: 'sessionEnd',
+      sessionId: session.id,
+      reason,
+      toolCount: session.toolCount,
+      duration: Math.round((new Date(session.endedAt) - new Date(session.startedAt)) / 1000),
+      journalSpawned,
+      featureCode: session.featureCode || null,
+      phaseAtEnd: session.phaseAtEnd || null,
+      timestamp: new Date().toISOString(),
+    });
+    scheduleBroadcast(); // COMP-UX-2b: refresh sessions list in visionState
+
+    res.json({ sessionId: session.id, persisted: true, journalSpawned });
+  });
+
+  // POST /api/session/bind — bind active session to a lifecycle feature
+  app.post('/api/session/bind', (req, res) => {
+    try {
+      const { featureCode } = req.body;
+      if (!featureCode) return res.status(400).json({ error: 'featureCode required' });
+      if (!/^[A-Za-z0-9_-]+$/.test(featureCode)) return res.status(400).json({ error: 'Invalid featureCode' });
+
+      const session = sessionManager.currentSession;
+      if (!session) return res.status(409).json({ error: 'No active session' });
+
+      // If already bound, return early without validating the new feature code
+      if (session.featureCode) {
+        return res.json({ already_bound: true, featureCode: session.featureCode });
+      }
+
+      // Look up the vision item for this feature — reject if not found
+      const item = store.getItemByFeatureCode(featureCode);
+      if (!item) return res.status(404).json({ error: `No lifecycle item for feature code: ${featureCode}` });
+      const itemId = item.id;
+      const phase = item.lifecycle?.currentPhase || null;
+
+      const result = sessionManager.bindToFeature(featureCode, itemId, phase);
+
+      if (!result.already_bound) {
+        broadcastMessage({
+          type: 'sessionBound',
+          sessionId: session.id,
+          featureCode,
+          itemId,
+          phase,
+          timestamp: new Date().toISOString(),
+        });
+      }
+
+      res.json(result);
+    } catch (err) {
+      res.status(500).json({ error: err.message });
+    }
+  });
+
+  // GET /api/session/history — sessions bound to a feature
+  app.get('/api/session/history', (req, res) => {
+    try {
+      const { featureCode, limit } = req.query;
+      if (!featureCode) return res.status(400).json({ error: 'featureCode required' });
+      const sessions = readSessionsByFeature(featureCode, parseInt(limit) || 10, sessionManager.sessionsFile);
+      res.json({ sessions });
+    } catch (err) {
+      res.status(500).json({ error: err.message });
+    }
+  });
+
+  // GET /api/session/current — current session state (with optional featureCode enrichment)
+  app.get('/api/session/current', (_req, res) => {
+    const { featureCode } = _req.query;
+
+    if (!sessionManager?.currentSession) {
+      if (featureCode) {
+        return res.json(_buildFeatureContext(featureCode, null));
+      }
+      return res.json({ session: null });
+    }
+
+    const s = sessionManager.currentSession;
+    const items = {};
+    const allSummaries = [];
+    for (const [id, acc] of s.items) {
+      items[id] = { title: acc.title, reads: acc.reads, writes: acc.writes, summaries: acc.summaries };
+      for (const summary of (acc.summaries || [])) {
+        if (!summary) continue;
+        allSummaries.push(typeof summary === 'string' ? { summary } : summary);
+      }
+    }
+    const sessionData = {
+      id: s.id, startedAt: s.startedAt, source: s.source, toolCount: s.toolCount,
+      blockCount: s.blocks.length, errorCount: (s.errors || []).length, items,
+      summaries: allSummaries,
+      featureCode: s.featureCode || null,
+      featureItemId: s.featureItemId || null,
+      phaseAtBind: s.phaseAtBind || null,
+      boundAt: s.boundAt || null,
+    };
+
+    // When featureCode requested and active session is bound to THAT feature
+    if (featureCode && s.featureCode === featureCode) {
+      return res.json(_buildFeatureContext(featureCode, sessionData));
+    }
+
+    // When featureCode requested but active session is for a DIFFERENT feature
+    if (featureCode && s.featureCode !== featureCode) {
+      return res.json(_buildFeatureContext(featureCode, null));
+    }
+
+    // No featureCode requested — return generic active session (existing behavior)
+    res.json({ session: sessionData });
+  });
+
+  // Helper: normalize feature-aware response shape across all branches
+  function _buildFeatureContext(featureCode, sessionData) {
+    const item = store.getItemByFeatureCode(featureCode);
+    const recentSessions = readSessionsByFeature(featureCode, 3, sessionManager.sessionsFile);
+    const recentSummaries = recentSessions
+      .flatMap(rs => Object.values(rs.items || {}).flatMap(i => i.summaries || []))
+      .slice(0, 10);
+    return {
+      session: sessionData || recentSessions[0] || null,
+      lifecycle: item?.lifecycle ? {
+        currentPhase: item.lifecycle.currentPhase,
+        phaseHistory: (item.lifecycle.phaseHistory || []).map(h => ({ phase: h.phase, enteredAt: h.enteredAt, exitedAt: h.exitedAt })),
+        artifacts: item.lifecycle.artifacts || {},
+        pendingGate: item.lifecycle.pendingGate || null,
+      } : null,
+      recentSummaries,
+    };
+  }
+}

package/server/session-store.js

@@ -0,0 +1,107 @@
+/**
+ * session-store.js — Session persistence: serialize, persist, and read context.
+ *
+ * Extracted from SessionManager. All functions are pure/stateless helpers
+ * that operate on plain session objects and the sessions.json file path.
+ */
+
+import fs from 'node:fs';
+import path from 'node:path';
+
+/**
+ * Convert session state (with Maps/Sets) to a plain serializable object.
+ * @param {object} session
+ * @returns {object}
+ */
+export function serializeSession(session) {
+  const items = {};
+  for (const [id, acc] of session.items) {
+    items[id] = { ...acc };
+  }
+  return {
+    id: session.id,
+    startedAt: session.startedAt,
+    endedAt: session.endedAt || null,
+    endReason: session.endReason || null,
+    source: session.source,
+    toolCount: session.toolCount,
+    items,
+    blocks: session.blocks,
+    commits: session.commits,
+    errors: session.errors || [],
+    transcriptPath: session.transcriptPath || null,
+    featureCode: session.featureCode || null,
+    featureItemId: session.featureItemId || null,
+    phaseAtBind: session.phaseAtBind || null,
+    phaseAtEnd: session.phaseAtEnd || null,
+    boundAt: session.boundAt || null,
+  };
+}
+
+/**
+ * Append a completed session to data/sessions.json.
+ * @param {object} session — serialized session data
+ * @param {string} sessionsFile — absolute path to sessions.json
+ */
+export function persistSession(session, sessionsFile) {
+  try {
+    fs.mkdirSync(path.dirname(sessionsFile), { recursive: true });
+
+    let sessions = [];
+    try {
+      const raw = fs.readFileSync(sessionsFile, 'utf-8');
+      sessions = JSON.parse(raw);
+      if (!Array.isArray(sessions)) sessions = [];
+    } catch (parseErr) {
+      if (parseErr.code !== 'ENOENT') {
+        const backup = sessionsFile + '.bak';
+        try { fs.copyFileSync(sessionsFile, backup); } catch { /* best effort */ }
+        console.warn(`[session] Corrupted sessions.json backed up to ${backup}`);
+      }
+    }
+
+    sessions.push(session);
+    fs.writeFileSync(sessionsFile, JSON.stringify(sessions, null, 2), 'utf-8');
+    console.log(`[session] Persisted to ${sessionsFile} (${sessions.length} total sessions)`);
+  } catch (err) {
+    console.error('[session] Failed to persist session:', err.message);
+  }
+}
+
+/**
+ * Read the most recent session from sessions.json.
+ * @param {string} sessionsFile — absolute path to sessions.json
+ * @returns {object|null}
+ */
+export function readLastSession(sessionsFile) {
+  try {
+    const raw = fs.readFileSync(sessionsFile, 'utf-8');
+    const sessions = JSON.parse(raw);
+    if (Array.isArray(sessions) && sessions.length > 0) {
+      return sessions[sessions.length - 1];
+    }
+  } catch {
+    // No sessions file yet — that's fine
+  }
+  return null;
+}
+
+/**
+ * Read sessions bound to a specific feature, sorted descending by startedAt.
+ * @param {string} featureCode
+ * @param {number} limit — max results to return
+ * @param {string} sessionsFile — absolute path to sessions.json
+ * @returns {Array<object>}
+ */
+export function readSessionsByFeature(featureCode, limit, sessionsFile) {
+  try {
+    const raw = fs.readFileSync(sessionsFile, 'utf8');
+    const sessions = JSON.parse(raw);
+    return sessions
+      .filter(s => featureCode === null || featureCode === undefined ? true : s.featureCode === featureCode)
+      .sort((a, b) => b.startedAt.localeCompare(a.startedAt))
+      .slice(0, limit);
+  } catch {
+    return [];
+  }
+}