chainlesschain 0.162.149 → 0.162.150

package/src/lib/siem-exporter.js

@@ -136,6 +136,51 @@ export function _resetState() {
   _exports.length = 0;
 }
 
+/**
+ * Rehydrate the in-memory _targets Map from the persisted siem_exports table.
+ * The CLI runs each `cc siem` subcommand in a fresh node process, so _targets
+ * starts empty every invocation. addTarget dual-writes (Map + INSERT INTO
+ * siem_exports) but every read (listTargets/exportLogs/getSIEMStats/
+ * removeTarget/setTargetStatus/listTargetsByStatus) is Map-only and nothing
+ * SELECTed the table back — so a target added in one invocation was invisible in
+ * the next (`No SIEM targets configured.`) and `siem export <id>` hard-crashed
+ * with `Target not found` for a target that genuinely exists on disk. Call after
+ * ensureSIEMTables(db).
+ */
+export function loadFromDb(db) {
+  if (!db) return 0;
+  ensureSIEMTables(db);
+  _targets.clear();
+  for (const r of db
+    .prepare(
+      `SELECT id, target_type, target_url, format, last_exported_log_id,
+              exported_count, last_export_at, status, config, created_at
+         FROM siem_exports ORDER BY created_at ASC`,
+    )
+    .all()) {
+    // One corrupt config cell must not sink the whole target load.
+    let config = {};
+    try {
+      config = r.config ? JSON.parse(r.config) : {};
+    } catch {
+      config = {};
+    }
+    _targets.set(r.id, {
+      id: r.id,
+      type: r.target_type,
+      url: r.target_url,
+      format: r.format,
+      exportedCount: Number(r.exported_count) || 0,
+      lastExportAt: r.last_export_at ?? null,
+      lastExportedLogId: r.last_exported_log_id ?? null,
+      status: r.status,
+      config,
+      createdAt: r.created_at,
+    });
+  }
+  return _targets.size;
+}
+
 // ═══════════════════════════════════════════════════════════════
 // V2 Canonical Surface (Phase 51)
 // ═══════════════════════════════════════════════════════════════

package/src/lib/skill-loader.js

@@ -84,6 +84,17 @@ export const LAYER_NAMES = [
  *  `<group>/<skill>/SKILL.md` layouts (infinite-recursion / deep-tree guard). */
 export const MAX_SKILL_NEST_DEPTH = 5;
 
+// Frontmatter keys (camelCased) that are semantically strings and are consumed
+// with string methods; they must never be number/boolean-coerced. `version` is
+// deliberately excluded — it is only string-interpolated and existing behavior
+// coerces it to a number.
+const STRING_SCALAR_FIELDS = new Set([
+  "name",
+  "displayName",
+  "description",
+  "category",
+]);
+
 /**
  * Simple YAML frontmatter parser (no dependencies)
  * Shared utility extracted from skill.js
@@ -165,8 +176,15 @@ export function parseSkillMd(content) {
         continue;
       }
 
-      // Handle booleans and numbers
-      if (value === "true") value = true;
+      // Handle booleans and numbers. These fields are string-semantic and get
+      // used with string methods downstream (skill.id.includes(),
+      // description.substring(), category/displayName.toLowerCase()); coercing a
+      // bare numeric ("2024") or boolean value to Number/Boolean makes those
+      // throw and aborts the whole `cc skill list/search/run` command on a
+      // single such skill — so never coerce them. (version stays coercible.)
+      if (STRING_SCALAR_FIELDS.has(camelKey))
+        value = value.replace(/^['"]|['"]$/g, "");
+      else if (value === "true") value = true;
       else if (value === "false") value = false;
       else if (value === "null") value = null;
       else if (/^\d+(\.\d+)?$/.test(value)) value = parseFloat(value);

package/src/lib/skill-marketplace.js

@@ -109,6 +109,89 @@ export function ensureMarketplaceTables(db) {
   );
 }
 
+/**
+ * Hydrate the in-memory _services/_invocations Maps from the DB. The CLI is
+ * one-shot: both start empty each process. Writes dual-write (Map + INSERT) but
+ * every read (getService/listServices/listInvocations/getInvocationStats/
+ * getMarketplaceStatsV2) and _mustGetService (record/status/invoke) is Map-only
+ * and nothing SELECTed the tables back — so a published service was invisible on
+ * the next invocation, and record/show/status threw "Service not found". Call
+ * after ensureMarketplaceTables(db).
+ *
+ * V2 timing fields (startedAt/completedAt) are not persisted → default null.
+ */
+export function loadFromDb(db) {
+  if (!db) return 0;
+  ensureMarketplaceTables(db);
+  _services.clear();
+  _invocations.clear();
+
+  for (const r of db
+    .prepare(
+      `SELECT id, name, version, description, endpoint, pricing, status, owner, invocation_count, created_at, updated_at
+         FROM skill_services ORDER BY created_at ASC`,
+    )
+    .all()) {
+    // One corrupt pricing cell must not crash the whole service load.
+    let pricing = null;
+    try {
+      pricing = r.pricing ? JSON.parse(r.pricing) : null;
+    } catch {
+      pricing = null;
+    }
+    _services.set(r.id, {
+      id: r.id,
+      name: r.name,
+      version: r.version,
+      description: r.description || "",
+      endpoint: r.endpoint,
+      pricing,
+      status: r.status,
+      owner: r.owner,
+      invocationCount: Number(r.invocation_count) || 0,
+      createdAt: Number(r.created_at),
+      updatedAt: Number(r.updated_at),
+      _seq: ++_seq,
+    });
+  }
+
+  for (const r of db
+    .prepare(
+      `SELECT id, service_id, caller_id, input, output, status, duration_ms, error, created_at
+         FROM skill_invocations ORDER BY created_at ASC`,
+    )
+    .all()) {
+    let input = null;
+    let output = null;
+    try {
+      input = r.input == null ? null : JSON.parse(r.input);
+    } catch {
+      input = r.input;
+    }
+    try {
+      output = r.output == null ? null : JSON.parse(r.output);
+    } catch {
+      output = r.output;
+    }
+    _invocations.set(r.id, {
+      id: r.id,
+      serviceId: r.service_id,
+      callerId: r.caller_id,
+      input,
+      output,
+      status: r.status,
+      durationMs: r.duration_ms == null ? null : Number(r.duration_ms),
+      error: r.error,
+      createdAt: Number(r.created_at),
+      startedAt: null,
+      completedAt: null,
+      _seq: ++_seq,
+    });
+  }
+
+  return _services.size + _invocations.size;
+}
+
 /* ── Catalogs ──────────────────────────────────────────────── */
 
 export function listServiceStatus() {

package/src/lib/sla-manager.js

@@ -484,6 +484,94 @@ export function _resetState() {
   _maxActiveSlasPerOrg = DEFAULT_MAX_ACTIVE_SLAS_PER_ORG;
 }
 
+/**
+ * Rehydrate the in-memory Maps from the persisted sla_* tables. The CLI runs
+ * each `cc sla` subcommand in a fresh node process, so _contracts/_metrics/
+ * _violations start empty every invocation. Every write dual-writes (Map +
+ * INSERT into sla_contracts/sla_metrics/sla_violations) but every read (listSLAs/
+ * getSLA/getSLAMetrics/checkViolations/listViolations/calculateCompensation/
+ * generateReport) is Map-only and nothing SELECTed the tables back — so `sla
+ * list` reported none, and `show`/`record`/`metrics`/`report` threw "SLA not
+ * found" for a contract that genuinely exists on disk. Call after
+ * ensureSlaTables(db).
+ */
+export function loadFromDb(db) {
+  if (!db) return 0;
+  ensureSlaTables(db);
+  _contracts.clear();
+  _metrics.clear();
+  _violations.clear();
+
+  for (const r of db
+    .prepare(
+      `SELECT sla_id, org_id, tier, terms, monthly_fee, start_date, end_date, status, created_at, updated_at
+         FROM sla_contracts ORDER BY created_at ASC`,
+    )
+    .all()) {
+    // One corrupt terms cell must not sink the whole contract list.
+    let terms = {};
+    try {
+      terms = r.terms ? JSON.parse(r.terms) : {};
+    } catch {
+      terms = {};
+    }
+    _contracts.set(r.sla_id, {
+      slaId: r.sla_id,
+      orgId: r.org_id,
+      tier: r.tier,
+      terms,
+      monthlyFee: Number(r.monthly_fee) || 0,
+      startDate: Number(r.start_date),
+      endDate: Number(r.end_date),
+      status: r.status,
+      createdAt: Number(r.created_at),
+      updatedAt: Number(r.updated_at),
+      _seq: ++_seq,
+    });
+  }
+
+  for (const r of db
+    .prepare(
+      `SELECT metric_id, sla_id, term, value, recorded_at
+         FROM sla_metrics ORDER BY recorded_at ASC`,
+    )
+    .all()) {
+    if (!_metrics.has(r.sla_id)) _metrics.set(r.sla_id, []);
+    _metrics.get(r.sla_id).push({
+      metricId: r.metric_id,
+      slaId: r.sla_id,
+      term: r.term,
+      value: Number(r.value),
+      recordedAt: Number(r.recorded_at),
+    });
+  }
+
+  for (const r of db
+    .prepare(
+      `SELECT violation_id, sla_id, term, severity, expected_value, actual_value,
+              deviation_percent, compensation_amount, occurred_at, resolved_at
+         FROM sla_violations ORDER BY occurred_at ASC`,
+    )
+    .all()) {
+    _violations.set(r.violation_id, {
+      violationId: r.violation_id,
+      slaId: r.sla_id,
+      term: r.term,
+      severity: r.severity,
+      expectedValue: Number(r.expected_value),
+      actualValue: Number(r.actual_value),
+      deviationPercent:
+        r.deviation_percent == null ? null : Number(r.deviation_percent),
+      compensationAmount:
+        r.compensation_amount == null ? null : Number(r.compensation_amount),
+      occurredAt: Number(r.occurred_at),
+      resolvedAt: r.resolved_at == null ? null : Number(r.resolved_at),
+    });
+  }
+
+  return _contracts.size + _metrics.size + _violations.size;
+}
+
 /* ═══════════════════════════════════════════════════════════════
  * V2 (Phase 61) — Frozen enums + contract/violation state
  * machines + active-per-org cap + auto-expire + stats-v2.

package/src/lib/social-manager.js

@@ -54,6 +54,80 @@ export function ensureSocialTables(db) {
   `);
 }
 
+/**
+ * Hydrate the in-memory stores from the DB. The CLI is one-shot: every command
+ * runs in a fresh process, so the module-level Maps start empty. Write paths
+ * dual-write (Map + DB), but the read paths (listContacts/listFriends/listPosts/
+ * getChatMessages/getChatThreads/getSocialStats) read the Maps ONLY — so without
+ * this, a user's persisted contacts/friends/posts/messages are invisible on the
+ * next invocation. Mirrors social-graph.loadFromDb (the asymmetry tell: graph
+ * commands hydrate, social commands didn't). Call after ensureSocialTables(db).
+ */
+export function loadFromDb(db) {
+  if (!db) return 0;
+  _contacts.clear();
+  _friends.clear();
+  _posts.clear();
+  _messages.clear();
+
+  for (const r of db
+    .prepare(
+      `SELECT id, name, did, email, notes, created_at FROM social_contacts`,
+    )
+    .all()) {
+    _contacts.set(r.id, {
+      id: r.id,
+      name: r.name,
+      did: r.did || null,
+      email: r.email || null,
+      notes: r.notes || "",
+      createdAt: r.created_at,
+    });
+  }
+
+  for (const r of db
+    .prepare(`SELECT id, contact_id, status, created_at FROM social_friends`)
+    .all()) {
+    // Keyed by contact_id to match addFriend's _friends.set(contactId, ...).
+    _friends.set(r.contact_id, {
+      id: r.id,
+      contactId: r.contact_id,
+      status: r.status,
+      createdAt: r.created_at,
+    });
+  }
+
+  for (const r of db
+    .prepare(`SELECT id, author, content, likes, created_at FROM social_posts`)
+    .all()) {
+    _posts.set(r.id, {
+      id: r.id,
+      author: r.author,
+      content: r.content,
+      likes: r.likes,
+      createdAt: r.created_at,
+    });
+  }
+
+  for (const r of db
+    .prepare(
+      `SELECT id, thread_id, sender, recipient, content, read, created_at FROM social_messages`,
+    )
+    .all()) {
+    _messages.set(r.id, {
+      id: r.id,
+      threadId: r.thread_id,
+      sender: r.sender,
+      recipient: r.recipient,
+      content: r.content,
+      read: !!r.read,
+      createdAt: r.created_at,
+    });
+  }
+
+  return _contacts.size + _friends.size + _posts.size + _messages.size;
+}
+
 /* ── Contacts ──────────────────────────────────────────────── */
 
 export function addContact(db, name, did, email, notes) {

package/src/lib/stress-tester.js

@@ -95,6 +95,71 @@ export function ensureStressTables(db) {
   `);
 }
 
+/**
+ * Rehydrate _runs/_results from the persisted stress_test_runs/
+ * stress_test_results tables. The `cc` CLI runs every command in a fresh
+ * process, so without this the Maps start empty and a run recorded in a prior
+ * invocation is invisible (`cc stress list` shows "No stress tests recorded.";
+ * `cc stress show <id>` throws "Stress test not found"). Call after
+ * ensureStressTables(db).
+ */
+export function loadFromDb(db) {
+  if (!db) return 0;
+  _runs.clear();
+  _results.clear();
+
+  const resultRows = db.prepare(`SELECT * FROM stress_test_results`).all();
+  for (const row of resultRows) {
+    let bottlenecks = [];
+    let capacityRecommendations = [];
+    try {
+      bottlenecks = row.bottlenecks ? JSON.parse(row.bottlenecks) : [];
+    } catch {
+      bottlenecks = [];
+    }
+    try {
+      capacityRecommendations = row.capacity_recommendations
+        ? JSON.parse(row.capacity_recommendations)
+        : [];
+    } catch {
+      capacityRecommendations = [];
+    }
+    _results.set(row.test_id, {
+      resultId: row.result_id,
+      testId: row.test_id,
+      tps: row.tps,
+      avgResponseTime: row.avg_response_time,
+      p50ResponseTime: row.p50_response_time,
+      p95ResponseTime: row.p95_response_time,
+      p99ResponseTime: row.p99_response_time,
+      errorRate: row.error_rate,
+      bottlenecks,
+      capacityRecommendations,
+      createdAt: row.created_at,
+    });
+  }
+
+  const runRows = db.prepare(`SELECT * FROM stress_test_runs`).all();
+  for (const row of runRows) {
+    _runs.set(row.test_id, {
+      testId: row.test_id,
+      loadLevel: row.load_level,
+      concurrency: row.concurrency,
+      requestsPerSecond: row.requests_per_second,
+      duration: row.duration,
+      status: row.status,
+      startedAt: row.started_at,
+      completedAt: row.completed_at ?? null,
+      // _seq is a per-process monotonic tiebreaker; started_at is the primary
+      // sort key. Reassign in load order — ties (same ms) are the only case it
+      // affects and are cosmetic for history ordering.
+      _seq: ++_seq,
+    });
+  }
+
+  return _runs.size + _results.size;
+}
+
 /* ── Synthetic metrics ─────────────────────────────────────── */
 
 // Deterministic quasi-random: stable across runs for the same inputs. Tests

package/src/lib/tech-learning-engine.js

@@ -169,6 +169,81 @@ export function ensureTechLearningTables(db) {
   );
 }
 
+/**
+ * Rehydrate _profiles/_practices from the persisted tech_stack_profiles/
+ * learned_practices tables. The `cc` CLI runs every command in a fresh process,
+ * so without this the Maps start empty and a profile/practice recorded in a
+ * prior invocation is invisible (`cc tech profile` returns null, `cc tech
+ * practices` shows nothing, `cc tech recommend` can't infer the latest stack).
+ * Call after ensureTechLearningTables(db). The profile's frameworks/databases/
+ * tools/libraries are not stored as columns — they are reconstructed from the
+ * classified tech_stack exactly as analyzeTechStack derives them.
+ */
+export function loadFromDb(db) {
+  if (!db) return 0;
+  _profiles.clear();
+  _practices.clear();
+
+  const profileRows = db.prepare(`SELECT * FROM tech_stack_profiles`).all();
+  for (const row of profileRows) {
+    let classified = [];
+    let deps = [];
+    let languages = [];
+    try {
+      classified = row.tech_stack ? JSON.parse(row.tech_stack) : [];
+    } catch {
+      classified = [];
+    }
+    try {
+      deps = row.dependencies ? JSON.parse(row.dependencies) : [];
+    } catch {
+      deps = [];
+    }
+    try {
+      languages = row.languages ? JSON.parse(row.languages) : [];
+    } catch {
+      languages = [];
+    }
+    const byType = (t) =>
+      classified.filter((d) => d.type === t).map((d) => d.name);
+    _profiles.set(row.project_path, {
+      profileId: row.profile_id,
+      projectPath: row.project_path,
+      languages,
+      frameworks: byType(TECH_TYPES.FRAMEWORK),
+      databases: byType(TECH_TYPES.DATABASE),
+      tools: byType(TECH_TYPES.TOOL),
+      libraries: byType(TECH_TYPES.LIBRARY),
+      totalDependencies: deps.length,
+      analysisTimestamp: row.analysis_timestamp,
+      createdAt: row.created_at,
+      updatedAt: row.updated_at,
+      _seq: ++_seq,
+    });
+  }
+
+  const practiceRows = db.prepare(`SELECT * FROM learned_practices`).all();
+  for (const row of practiceRows) {
+    _practices.set(row.practice_id, {
+      practiceId: row.practice_id,
+      techType: row.tech_type,
+      techName: row.tech_name,
+      patternName: row.pattern_name,
+      level: row.level,
+      description: row.description ?? "",
+      codeExample: row.code_example ?? "",
+      usageCount: row.usage_count ?? 0,
+      score: row.score ?? 0,
+      source: row.source,
+      learnedAt: row.learned_at,
+      updatedAt: row.updated_at,
+      _seq: ++_seq,
+    });
+  }
+
+  return _profiles.size + _practices.size;
+}
+
 /* ── Parsers for dependency manifests ──────────────────────── */
 
 function _readIfExists(filePath) {

package/src/lib/tenant-saas.js

@@ -830,6 +830,113 @@ export function _resetState() {
   _seq = 0;
 }
 
+/**
+ * Rehydrate the in-memory Maps from the persisted saas_* tables. The CLI runs
+ * every subcommand in a fresh node process, so these module-level Maps start
+ * empty each invocation. Every write dual-writes (Map + INSERT OR REPLACE) but
+ * every read (getTenant/listTenants/getUsage/getActiveSubscription/
+ * listSubscriptions/getSaasStats) is Map-only, and nothing SELECTed the tables
+ * back — so a tenant created in one invocation was invisible in the next
+ * (`No tenants.` / `Tenant not found`), and every follow-up subscribe/record/
+ * check-quota/configure/delete threw "Tenant not found". Call after
+ * ensureTenantTables(db).
+ */
+export function loadFromDb(db) {
+  if (!db) return 0;
+  ensureTenantTables(db);
+  _tenants.clear();
+  _subscriptions.clear();
+  _usage.clear();
+  _slugIndex.clear();
+  _tenantSubs.clear();
+  _tenantUsage.clear();
+
+  for (const r of db
+    .prepare(
+      `SELECT id, name, slug, config, status, plan, db_path, owner_id,
+              created_at, updated_at, deleted_at
+         FROM saas_tenants ORDER BY created_at ASC`,
+    )
+    .all()) {
+    // One corrupt config cell must not sink the whole tenant list.
+    let config = null;
+    try {
+      config = r.config ? JSON.parse(r.config) : null;
+    } catch {
+      config = null;
+    }
+    _tenants.set(r.id, {
+      id: r.id,
+      name: r.name,
+      slug: r.slug,
+      config,
+      status: r.status,
+      plan: r.plan,
+      dbPath: r.db_path || null,
+      ownerId: r.owner_id || null,
+      createdAt: Number(r.created_at),
+      updatedAt: Number(r.updated_at),
+      deletedAt: r.deleted_at == null ? null : Number(r.deleted_at),
+      _seq: ++_seq,
+    });
+    if (r.slug) _slugIndex.set(r.slug, r.id);
+    _tenantSubs.set(r.id, new Set());
+    _tenantUsage.set(r.id, new Set());
+  }
+
+  for (const r of db
+    .prepare(
+      `SELECT id, tenant_id, metric, value, period, recorded_at
+         FROM saas_usage ORDER BY recorded_at ASC`,
+    )
+    .all()) {
+    _usage.set(r.id, {
+      id: r.id,
+      tenantId: r.tenant_id,
+      metric: r.metric,
+      value: Number(r.value),
+      period: r.period,
+      recordedAt: Number(r.recorded_at),
+      _seq: ++_seq,
+    });
+    if (!_tenantUsage.has(r.tenant_id))
+      _tenantUsage.set(r.tenant_id, new Set());
+    _tenantUsage.get(r.tenant_id).add(r.id);
+  }
+
+  for (const r of db
+    .prepare(
+      `SELECT id, tenant_id, plan, status, started_at, expires_at, cancelled_at,
+              payment_method, amount, created_at
+         FROM saas_subscriptions ORDER BY created_at ASC`,
+    )
+    .all()) {
+    let paymentMethod = null;
+    try {
+      paymentMethod = r.payment_method ? JSON.parse(r.payment_method) : null;
+    } catch {
+      paymentMethod = null;
+    }
+    _subscriptions.set(r.id, {
+      id: r.id,
+      tenantId: r.tenant_id,
+      plan: r.plan,
+      status: r.status,
+      startedAt: Number(r.started_at),
+      expiresAt: r.expires_at == null ? null : Number(r.expires_at),
+      cancelledAt: r.cancelled_at == null ? null : Number(r.cancelled_at),
+      paymentMethod,
+      amount: r.amount == null ? null : Number(r.amount),
+      createdAt: Number(r.created_at),
+      _seq: ++_seq,
+    });
+    if (!_tenantSubs.has(r.tenant_id)) _tenantSubs.set(r.tenant_id, new Set());
+    _tenantSubs.get(r.tenant_id).add(r.id);
+  }
+
+  return _tenants.size + _usage.size + _subscriptions.size;
+}
+
 /* ═══════════════════════════════════════════════════════════════
  * Phase 97 V2 — Tenant Maturity + Subscription Lifecycle
  * Strictly additive. Legacy surface above is preserved.

package/src/lib/terraform-manager.js

@@ -65,6 +65,73 @@ export function ensureTerraformTables(db) {
   `);
 }
 
+/**
+ * Rehydrate _workspaces/_runs from the persisted terraform_workspaces/
+ * terraform_runs tables. The `cc` CLI runs every command in a fresh process, so
+ * without this the Maps start empty and a workspace/run created in a prior
+ * invocation is invisible (`cc terraform workspaces`/`runs` show nothing;
+ * `cc terraform plan <id>` throws "Workspace not found" for a persisted
+ * workspace). Call after ensureTerraformTables(db).
+ */
+export function loadFromDb(db) {
+  if (!db) return 0;
+  _workspaces.clear();
+  _runs.clear();
+
+  const wsRows = db.prepare(`SELECT * FROM terraform_workspaces`).all();
+  for (const row of wsRows) {
+    let variables = {};
+    let providers = [];
+    try {
+      variables = row.variables ? JSON.parse(row.variables) : {};
+    } catch {
+      variables = {};
+    }
+    try {
+      providers = row.providers ? JSON.parse(row.providers) : [];
+    } catch {
+      providers = [];
+    }
+    _workspaces.set(row.id, {
+      id: row.id,
+      name: row.name,
+      description: row.description ?? "",
+      terraformVersion: row.terraform_version,
+      workingDirectory: row.working_directory,
+      autoApply: !!row.auto_apply,
+      status: row.status,
+      lastRunId: row.last_run_id ?? null,
+      lastRunAt: row.last_run_at ?? null,
+      stateVersion: row.state_version ?? 0,
+      variables,
+      providers,
+      createdAt: row.created_at ?? null,
+    });
+  }
+
+  const runRows = db.prepare(`SELECT * FROM terraform_runs`).all();
+  for (const row of runRows) {
+    _runs.set(row.id, {
+      id: row.id,
+      workspaceId: row.workspace_id,
+      runType: row.run_type,
+      status: row.status,
+      planOutput: row.plan_output ?? null,
+      applyOutput: row.apply_output ?? null,
+      resourcesAdded: row.resources_added ?? 0,
+      resourcesChanged: row.resources_changed ?? 0,
+      resourcesDestroyed: row.resources_destroyed ?? 0,
+      triggeredBy: row.triggered_by ?? null,
+      startedAt: row.started_at ?? null,
+      completedAt: row.completed_at ?? null,
+      errorMessage: row.error_message ?? null,
+      createdAt: row.created_at ?? null,
+    });
+  }
+
+  return _workspaces.size + _runs.size;
+}
+
 /* ── Workspace Management ─────────────────────────────────── */
 
 export function listWorkspaces(filter = {}) {