chainlesschain 0.66.0 → 0.132.0

package/src/lib/skill-loader.js

@@ -356,3 +356,380 @@ export class CLISkillLoader {
     this._cache = null;
   }
 }
+
+// ─── V2 Governance Layer ────────────────────────────────────────────
+//
+// In-memory governance for skill registrations + execution tickets,
+// independent of the file-based 4-layer CLISkillLoader (which scans
+// bundled/marketplace/managed/workspace dirs). V2 tracks maturity
+// transitions, per-owner active-skill caps, per-skill pending-execution
+// caps, stamp-once timestamps, and bulk auto-flip routines.
+
+export const SKILL_MATURITY_V2 = Object.freeze({
+  PENDING: "pending",
+  ACTIVE: "active",
+  DEPRECATED: "deprecated",
+  ARCHIVED: "archived",
+});
+
+export const EXECUTION_LIFECYCLE_V2 = Object.freeze({
+  QUEUED: "queued",
+  RUNNING: "running",
+  SUCCEEDED: "succeeded",
+  FAILED: "failed",
+  CANCELLED: "cancelled",
+});
+
+const _SKILL_TRANSITIONS_V2 = new Map([
+  [
+    SKILL_MATURITY_V2.PENDING,
+    new Set([SKILL_MATURITY_V2.ACTIVE, SKILL_MATURITY_V2.ARCHIVED]),
+  ],
+  [
+    SKILL_MATURITY_V2.ACTIVE,
+    new Set([SKILL_MATURITY_V2.DEPRECATED, SKILL_MATURITY_V2.ARCHIVED]),
+  ],
+  [
+    SKILL_MATURITY_V2.DEPRECATED,
+    new Set([SKILL_MATURITY_V2.ACTIVE, SKILL_MATURITY_V2.ARCHIVED]),
+  ],
+  [SKILL_MATURITY_V2.ARCHIVED, new Set()],
+]);
+
+const _SKILL_TERMINALS_V2 = new Set([SKILL_MATURITY_V2.ARCHIVED]);
+
+const _EXEC_TRANSITIONS_V2 = new Map([
+  [
+    EXECUTION_LIFECYCLE_V2.QUEUED,
+    new Set([EXECUTION_LIFECYCLE_V2.RUNNING, EXECUTION_LIFECYCLE_V2.CANCELLED]),
+  ],
+  [
+    EXECUTION_LIFECYCLE_V2.RUNNING,
+    new Set([
+      EXECUTION_LIFECYCLE_V2.SUCCEEDED,
+      EXECUTION_LIFECYCLE_V2.FAILED,
+      EXECUTION_LIFECYCLE_V2.CANCELLED,
+    ]),
+  ],
+  [EXECUTION_LIFECYCLE_V2.SUCCEEDED, new Set()],
+  [EXECUTION_LIFECYCLE_V2.FAILED, new Set()],
+  [EXECUTION_LIFECYCLE_V2.CANCELLED, new Set()],
+]);
+
+const _EXEC_TERMINALS_V2 = new Set([
+  EXECUTION_LIFECYCLE_V2.SUCCEEDED,
+  EXECUTION_LIFECYCLE_V2.FAILED,
+  EXECUTION_LIFECYCLE_V2.CANCELLED,
+]);
+
+export const SKILL_DEFAULT_MAX_ACTIVE_PER_OWNER = 30;
+export const SKILL_DEFAULT_MAX_PENDING_EXECUTIONS_PER_SKILL = 5;
+export const SKILL_DEFAULT_SKILL_IDLE_MS = 30 * 24 * 60 * 60 * 1000; // 30 days
+export const SKILL_DEFAULT_EXEC_STUCK_MS = 15 * 60 * 1000; // 15 min
+
+const _stateV2 = {
+  skills: new Map(),
+  executions: new Map(),
+  maxActiveSkillsPerOwner: SKILL_DEFAULT_MAX_ACTIVE_PER_OWNER,
+  maxPendingExecutionsPerSkill: SKILL_DEFAULT_MAX_PENDING_EXECUTIONS_PER_SKILL,
+  skillIdleMs: SKILL_DEFAULT_SKILL_IDLE_MS,
+  execStuckMs: SKILL_DEFAULT_EXEC_STUCK_MS,
+};
+
+function _posIntSkillV2(n, label) {
+  const v = Math.floor(Number(n));
+  if (!Number.isFinite(v) || v <= 0) {
+    throw new Error(`${label} must be a positive integer, got ${n}`);
+  }
+  return v;
+}
+
+export function getMaxActiveSkillsPerOwnerV2() {
+  return _stateV2.maxActiveSkillsPerOwner;
+}
+
+export function setMaxActiveSkillsPerOwnerV2(n) {
+  _stateV2.maxActiveSkillsPerOwner = _posIntSkillV2(
+    n,
+    "maxActiveSkillsPerOwner",
+  );
+}
+
+export function getMaxPendingExecutionsPerSkillV2() {
+  return _stateV2.maxPendingExecutionsPerSkill;
+}
+
+export function setMaxPendingExecutionsPerSkillV2(n) {
+  _stateV2.maxPendingExecutionsPerSkill = _posIntSkillV2(
+    n,
+    "maxPendingExecutionsPerSkill",
+  );
+}
+
+export function getSkillIdleMsV2() {
+  return _stateV2.skillIdleMs;
+}
+
+export function setSkillIdleMsV2(ms) {
+  _stateV2.skillIdleMs = _posIntSkillV2(ms, "skillIdleMs");
+}
+
+export function getExecStuckMsV2() {
+  return _stateV2.execStuckMs;
+}
+
+export function setExecStuckMsV2(ms) {
+  _stateV2.execStuckMs = _posIntSkillV2(ms, "execStuckMs");
+}
+
+function _copySkillV2(s) {
+  return { ...s, metadata: { ...s.metadata } };
+}
+
+function _copyExecV2(e) {
+  return { ...e, metadata: { ...e.metadata } };
+}
+
+export function getActiveSkillCountV2(ownerId) {
+  let count = 0;
+  for (const s of _stateV2.skills.values()) {
+    if (s.ownerId === ownerId && s.status === SKILL_MATURITY_V2.ACTIVE) count++;
+  }
+  return count;
+}
+
+export function getPendingExecutionCountV2(skillId) {
+  let count = 0;
+  for (const e of _stateV2.executions.values()) {
+    if (
+      e.skillId === skillId &&
+      (e.status === EXECUTION_LIFECYCLE_V2.QUEUED ||
+        e.status === EXECUTION_LIFECYCLE_V2.RUNNING)
+    ) {
+      count++;
+    }
+  }
+  return count;
+}
+
+export function registerSkillV2(id, { ownerId, name, layer, metadata } = {}) {
+  if (!id) throw new Error("skill id is required");
+  if (!ownerId) throw new Error("ownerId is required");
+  if (!name) throw new Error("name is required");
+  if (_stateV2.skills.has(id)) throw new Error(`skill ${id} already exists`);
+  const now = Date.now();
+  const skill = {
+    id,
+    ownerId,
+    name,
+    layer: layer || "workspace",
+    status: SKILL_MATURITY_V2.PENDING,
+    createdAt: now,
+    lastSeenAt: now,
+    activatedAt: null,
+    archivedAt: null,
+    metadata: metadata ? { ...metadata } : {},
+  };
+  _stateV2.skills.set(id, skill);
+  return _copySkillV2(skill);
+}
+
+export function getSkillV2(id) {
+  const s = _stateV2.skills.get(id);
+  return s ? _copySkillV2(s) : null;
+}
+
+export function listSkillsV2({ ownerId, status, layer } = {}) {
+  const out = [];
+  for (const s of _stateV2.skills.values()) {
+    if (ownerId && s.ownerId !== ownerId) continue;
+    if (status && s.status !== status) continue;
+    if (layer && s.layer !== layer) continue;
+    out.push(_copySkillV2(s));
+  }
+  return out;
+}
+
+export function setSkillStatusV2(id, next) {
+  const s = _stateV2.skills.get(id);
+  if (!s) throw new Error(`skill ${id} not found`);
+  const allowed = _SKILL_TRANSITIONS_V2.get(s.status);
+  if (!allowed || !allowed.has(next)) {
+    throw new Error(`invalid skill transition: ${s.status} → ${next}`);
+  }
+  if (
+    s.status === SKILL_MATURITY_V2.PENDING &&
+    next === SKILL_MATURITY_V2.ACTIVE
+  ) {
+    const count = getActiveSkillCountV2(s.ownerId);
+    if (count >= _stateV2.maxActiveSkillsPerOwner) {
+      throw new Error(
+        `owner ${s.ownerId} active-skill cap reached (${count}/${_stateV2.maxActiveSkillsPerOwner})`,
+      );
+    }
+  }
+  const now = Date.now();
+  s.status = next;
+  s.lastSeenAt = now;
+  if (next === SKILL_MATURITY_V2.ACTIVE && !s.activatedAt) s.activatedAt = now;
+  if (_SKILL_TERMINALS_V2.has(next) && !s.archivedAt) s.archivedAt = now;
+  return _copySkillV2(s);
+}
+
+export function activateSkillV2(id) {
+  return setSkillStatusV2(id, SKILL_MATURITY_V2.ACTIVE);
+}
+
+export function deprecateSkillV2(id) {
+  return setSkillStatusV2(id, SKILL_MATURITY_V2.DEPRECATED);
+}
+
+export function archiveSkillV2(id) {
+  return setSkillStatusV2(id, SKILL_MATURITY_V2.ARCHIVED);
+}
+
+export function touchSkillV2(id) {
+  const s = _stateV2.skills.get(id);
+  if (!s) throw new Error(`skill ${id} not found`);
+  s.lastSeenAt = Date.now();
+  return _copySkillV2(s);
+}
+
+export function createExecutionV2(id, { skillId, kind, metadata } = {}) {
+  if (!id) throw new Error("execution id is required");
+  if (!skillId) throw new Error("skillId is required");
+  if (_stateV2.executions.has(id))
+    throw new Error(`execution ${id} already exists`);
+  const skill = _stateV2.skills.get(skillId);
+  if (!skill) throw new Error(`skill ${skillId} not found`);
+  const pending = getPendingExecutionCountV2(skillId);
+  if (pending >= _stateV2.maxPendingExecutionsPerSkill) {
+    throw new Error(
+      `skill ${skillId} pending-execution cap reached (${pending}/${_stateV2.maxPendingExecutionsPerSkill})`,
+    );
+  }
+  const now = Date.now();
+  const exec = {
+    id,
+    skillId,
+    kind: kind || "invoke",
+    status: EXECUTION_LIFECYCLE_V2.QUEUED,
+    createdAt: now,
+    lastSeenAt: now,
+    startedAt: null,
+    settledAt: null,
+    metadata: metadata ? { ...metadata } : {},
+  };
+  _stateV2.executions.set(id, exec);
+  return _copyExecV2(exec);
+}
+
+export function getExecutionV2(id) {
+  const e = _stateV2.executions.get(id);
+  return e ? _copyExecV2(e) : null;
+}
+
+export function listExecutionsV2({ skillId, status } = {}) {
+  const out = [];
+  for (const e of _stateV2.executions.values()) {
+    if (skillId && e.skillId !== skillId) continue;
+    if (status && e.status !== status) continue;
+    out.push(_copyExecV2(e));
+  }
+  return out;
+}
+
+export function setExecutionStatusV2(id, next) {
+  const e = _stateV2.executions.get(id);
+  if (!e) throw new Error(`execution ${id} not found`);
+  const allowed = _EXEC_TRANSITIONS_V2.get(e.status);
+  if (!allowed || !allowed.has(next)) {
+    throw new Error(`invalid execution transition: ${e.status} → ${next}`);
+  }
+  const now = Date.now();
+  e.status = next;
+  e.lastSeenAt = now;
+  if (next === EXECUTION_LIFECYCLE_V2.RUNNING && !e.startedAt)
+    e.startedAt = now;
+  if (_EXEC_TERMINALS_V2.has(next) && !e.settledAt) e.settledAt = now;
+  return _copyExecV2(e);
+}
+
+export function startExecutionV2(id) {
+  return setExecutionStatusV2(id, EXECUTION_LIFECYCLE_V2.RUNNING);
+}
+
+export function succeedExecutionV2(id) {
+  return setExecutionStatusV2(id, EXECUTION_LIFECYCLE_V2.SUCCEEDED);
+}
+
+export function failExecutionV2(id) {
+  return setExecutionStatusV2(id, EXECUTION_LIFECYCLE_V2.FAILED);
+}
+
+export function cancelExecutionV2(id) {
+  return setExecutionStatusV2(id, EXECUTION_LIFECYCLE_V2.CANCELLED);
+}
+
+export function autoDeprecateIdleSkillsV2({ now = Date.now() } = {}) {
+  const flipped = [];
+  for (const s of _stateV2.skills.values()) {
+    if (
+      s.status === SKILL_MATURITY_V2.ACTIVE &&
+      now - s.lastSeenAt > _stateV2.skillIdleMs
+    ) {
+      s.status = SKILL_MATURITY_V2.DEPRECATED;
+      s.lastSeenAt = now;
+      flipped.push(_copySkillV2(s));
+    }
+  }
+  return flipped;
+}
+
+export function autoFailStuckExecutionsV2({ now = Date.now() } = {}) {
+  const flipped = [];
+  for (const e of _stateV2.executions.values()) {
+    if (
+      e.status === EXECUTION_LIFECYCLE_V2.RUNNING &&
+      now - e.lastSeenAt > _stateV2.execStuckMs
+    ) {
+      e.status = EXECUTION_LIFECYCLE_V2.FAILED;
+      e.lastSeenAt = now;
+      if (!e.settledAt) e.settledAt = now;
+      flipped.push(_copyExecV2(e));
+    }
+  }
+  return flipped;
+}
+
+export function getSkillLoaderStatsV2() {
+  const skillsByStatus = {};
+  for (const v of Object.values(SKILL_MATURITY_V2)) skillsByStatus[v] = 0;
+  for (const s of _stateV2.skills.values()) skillsByStatus[s.status]++;
+
+  const executionsByStatus = {};
+  for (const v of Object.values(EXECUTION_LIFECYCLE_V2))
+    executionsByStatus[v] = 0;
+  for (const e of _stateV2.executions.values()) executionsByStatus[e.status]++;
+
+  return {
+    totalSkillsV2: _stateV2.skills.size,
+    totalExecutionsV2: _stateV2.executions.size,
+    maxActiveSkillsPerOwner: _stateV2.maxActiveSkillsPerOwner,
+    maxPendingExecutionsPerSkill: _stateV2.maxPendingExecutionsPerSkill,
+    skillIdleMs: _stateV2.skillIdleMs,
+    execStuckMs: _stateV2.execStuckMs,
+    skillsByStatus,
+    executionsByStatus,
+  };
+}
+
+export function _resetStateSkillLoaderV2() {
+  _stateV2.skills.clear();
+  _stateV2.executions.clear();
+  _stateV2.maxActiveSkillsPerOwner = SKILL_DEFAULT_MAX_ACTIVE_PER_OWNER;
+  _stateV2.maxPendingExecutionsPerSkill =
+    SKILL_DEFAULT_MAX_PENDING_EXECUTIONS_PER_SKILL;
+  _stateV2.skillIdleMs = SKILL_DEFAULT_SKILL_IDLE_MS;
+  _stateV2.execStuckMs = SKILL_DEFAULT_EXEC_STUCK_MS;
+}

package/src/lib/skill-marketplace.js

@@ -394,4 +394,329 @@ export function _resetState() {
   _services.clear();
   _invocations.clear();
   _seq = 0;
+  _maxConcurrentInvocationsPerService =
+    DEFAULT_MAX_CONCURRENT_INVOCATIONS_PER_SERVICE;
+}
+
+/* ═══════════════════════════════════════════════════════════════
+ * V2 (Phase 65) — Frozen enums + async invocation lifecycle +
+ * per-service concurrency cap + patch-merged setInvocationStatus +
+ * stats-v2. Strictly additive on top of the legacy surface above.
+ * ═══════════════════════════════════════════════════════════════ */
+
+export const SERVICE_STATUS_V2 = Object.freeze({
+  DRAFT: "draft",
+  PUBLISHED: "published",
+  DEPRECATED: "deprecated",
+  SUSPENDED: "suspended",
+});
+
+export const INVOCATION_STATUS_V2 = Object.freeze({
+  PENDING: "pending",
+  RUNNING: "running",
+  SUCCESS: "success",
+  FAILED: "failed",
+  TIMEOUT: "timeout",
+});
+
+export const PRICING_MODEL_V2 = Object.freeze({
+  FREE: "free",
+  PAY_PER_CALL: "pay_per_call",
+  SUBSCRIPTION: "subscription",
+  TIERED: "tiered",
+});
+
+const DEFAULT_MAX_CONCURRENT_INVOCATIONS_PER_SERVICE = 10;
+let _maxConcurrentInvocationsPerService =
+  DEFAULT_MAX_CONCURRENT_INVOCATIONS_PER_SERVICE;
+export const MARKETPLACE_DEFAULT_MAX_CONCURRENT_INVOCATIONS =
+  DEFAULT_MAX_CONCURRENT_INVOCATIONS_PER_SERVICE;
+
+export function setMaxConcurrentInvocations(n) {
+  if (typeof n !== "number" || !Number.isFinite(n) || n < 1) {
+    throw new Error("maxConcurrentInvocations must be a positive integer");
+  }
+  _maxConcurrentInvocationsPerService = Math.floor(n);
+  return _maxConcurrentInvocationsPerService;
+}
+
+export function getMaxConcurrentInvocations() {
+  return _maxConcurrentInvocationsPerService;
+}
+
+export function getActiveInvocationCount(serviceId) {
+  let count = 0;
+  for (const inv of _invocations.values()) {
+    if (
+      (serviceId == null || inv.serviceId === serviceId) &&
+      (inv.status === INVOCATION_STATUS_V2.PENDING ||
+        inv.status === INVOCATION_STATUS_V2.RUNNING)
+    ) {
+      count++;
+    }
+  }
+  return count;
+}
+
+// Invocation state machine:
+//   pending → { running, failed, timeout }
+//   running → { success, failed, timeout }
+//   success/failed/timeout are terminal.
+const _invocationTerminal = new Set([
+  INVOCATION_STATUS_V2.SUCCESS,
+  INVOCATION_STATUS_V2.FAILED,
+  INVOCATION_STATUS_V2.TIMEOUT,
+]);
+const _invocationAllowed = new Map([
+  [
+    INVOCATION_STATUS_V2.PENDING,
+    new Set([
+      INVOCATION_STATUS_V2.RUNNING,
+      INVOCATION_STATUS_V2.FAILED,
+      INVOCATION_STATUS_V2.TIMEOUT,
+    ]),
+  ],
+  [
+    INVOCATION_STATUS_V2.RUNNING,
+    new Set([
+      INVOCATION_STATUS_V2.SUCCESS,
+      INVOCATION_STATUS_V2.FAILED,
+      INVOCATION_STATUS_V2.TIMEOUT,
+    ]),
+  ],
+  [INVOCATION_STATUS_V2.SUCCESS, new Set([])],
+  [INVOCATION_STATUS_V2.FAILED, new Set([])],
+  [INVOCATION_STATUS_V2.TIMEOUT, new Set([])],
+]);
+
+/**
+ * beginInvocationV2 — creates a PENDING invocation row (no output/duration).
+ * Caller drives the transition via startInvocation (→ RUNNING),
+ * completeInvocation (→ SUCCESS), failInvocation / timeoutInvocation,
+ * or the generic setInvocationStatus.
+ */
+export function beginInvocationV2(db, config = {}) {
+  const serviceId = String(config.serviceId || "").trim();
+  if (!serviceId) throw new Error("serviceId is required");
+  const service = _mustGetService(serviceId);
+  if (service.status !== SERVICE_STATUS_V2.PUBLISHED) {
+    throw new Error(
+      `Cannot invoke non-published service (status=${service.status})`,
+    );
+  }
+
+  const activeCount = getActiveInvocationCount(serviceId);
+  if (activeCount >= _maxConcurrentInvocationsPerService) {
+    throw new Error(
+      `Max concurrent invocations reached: ${activeCount}/${_maxConcurrentInvocationsPerService}`,
+    );
+  }
+
+  const callerId = config.callerId ? String(config.callerId).trim() : null;
+  const input = config.input ?? null;
+  const now = Number(config.now ?? Date.now());
+  const id = config.id || crypto.randomUUID();
+
+  const invocation = {
+    id,
+    serviceId,
+    callerId,
+    input,
+    output: null,
+    status: INVOCATION_STATUS_V2.PENDING,
+    durationMs: null,
+    error: null,
+    startedAt: null,
+    completedAt: null,
+    createdAt: now,
+    _seq: ++_seq,
+  };
+  _invocations.set(id, invocation);
+
+  if (db) {
+    db.prepare(
+      `INSERT INTO skill_invocations (id, service_id, caller_id, input, output, status, duration_ms, error, created_at)
+       VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)`,
+    ).run(
+      id,
+      serviceId,
+      callerId,
+      input == null ? null : JSON.stringify(input),
+      null,
+      INVOCATION_STATUS_V2.PENDING,
+      null,
+      null,
+      now,
+    );
+  }
+
+  return _strip(invocation);
+}
+
+function _mustGetInvocation(invocationId) {
+  const inv = _invocations.get(invocationId);
+  if (!inv) throw new Error(`Invocation not found: ${invocationId}`);
+  return inv;
+}
+
+function _persistInvocation(db, invocationId, fields) {
+  if (!db) return;
+  const setClauses = Object.keys(fields)
+    .map((k) => `${k} = ?`)
+    .join(", ");
+  const values = Object.values(fields).map((v) =>
+    v && typeof v === "object" ? JSON.stringify(v) : v,
+  );
+  db.prepare(`UPDATE skill_invocations SET ${setClauses} WHERE id = ?`).run(
+    ...values,
+    invocationId,
+  );
+}
+
+export function startInvocation(db, invocationId, opts = {}) {
+  return setInvocationStatus(db, invocationId, INVOCATION_STATUS_V2.RUNNING, {
+    startedAt: Number(opts.now ?? Date.now()),
+  });
+}
+
+export function completeInvocationV2(db, invocationId, opts = {}) {
+  return setInvocationStatus(db, invocationId, INVOCATION_STATUS_V2.SUCCESS, {
+    output: opts.output ?? null,
+    durationMs: opts.durationMs == null ? null : Number(opts.durationMs),
+  });
+}
+
+export function failInvocationV2(db, invocationId, errorMessage, opts = {}) {
+  return setInvocationStatus(db, invocationId, INVOCATION_STATUS_V2.FAILED, {
+    error: errorMessage ? String(errorMessage) : null,
+    durationMs: opts.durationMs == null ? null : Number(opts.durationMs),
+  });
+}
+
+export function timeoutInvocationV2(db, invocationId, opts = {}) {
+  return setInvocationStatus(db, invocationId, INVOCATION_STATUS_V2.TIMEOUT, {
+    error: opts.error ? String(opts.error) : "timeout",
+    durationMs: opts.durationMs == null ? null : Number(opts.durationMs),
+  });
+}
+
+export function setInvocationStatus(db, invocationId, newStatus, patch = {}) {
+  const inv = _mustGetInvocation(invocationId);
+
+  if (!Object.values(INVOCATION_STATUS_V2).includes(newStatus)) {
+    throw new Error(`Unknown invocation status: ${newStatus}`);
+  }
+
+  const allowed = _invocationAllowed.get(inv.status);
+  if (!allowed || !allowed.has(newStatus)) {
+    throw new Error(
+      `Invalid invocation status transition: ${inv.status} → ${newStatus}`,
+    );
+  }
+
+  const now = Date.now();
+  inv.status = newStatus;
+
+  const dbFields = { status: newStatus };
+
+  if (patch.output !== undefined) {
+    inv.output = patch.output;
+    dbFields.output =
+      patch.output == null ? null : JSON.stringify(patch.output);
+  }
+  if (patch.error !== undefined) {
+    inv.error = patch.error;
+    dbFields.error = patch.error;
+  }
+  if (patch.durationMs !== undefined) {
+    const d = patch.durationMs == null ? null : Number(patch.durationMs);
+    if (d != null && (Number.isNaN(d) || d < 0)) {
+      throw new Error(`Invalid durationMs: ${patch.durationMs}`);
+    }
+    inv.durationMs = d;
+    dbFields.duration_ms = d;
+  }
+  if (patch.startedAt !== undefined) {
+    inv.startedAt = patch.startedAt;
+  }
+
+  if (_invocationTerminal.has(newStatus) && inv.completedAt == null) {
+    inv.completedAt = now;
+    // Bump the service's invocation counter once on terminal.
+    const service = _services.get(inv.serviceId);
+    if (service) {
+      service.invocationCount = (service.invocationCount || 0) + 1;
+      service.updatedAt = now;
+      _persistService(db, inv.serviceId, {
+        invocation_count: service.invocationCount,
+        updated_at: now,
+      });
+    }
+  }
+
+  _persistInvocation(db, invocationId, dbFields);
+
+  return _strip(inv);
+}
+
+export function getMarketplaceStatsV2() {
+  const services = [..._services.values()];
+  const invocations = [..._invocations.values()];
+
+  const servicesByStatus = {};
+  for (const s of Object.values(SERVICE_STATUS_V2)) servicesByStatus[s] = 0;
+  for (const s of services)
+    servicesByStatus[s.status] = (servicesByStatus[s.status] || 0) + 1;
+
+  const invocationsByStatus = {};
+  for (const s of Object.values(INVOCATION_STATUS_V2))
+    invocationsByStatus[s] = 0;
+  for (const inv of invocations)
+    invocationsByStatus[inv.status] =
+      (invocationsByStatus[inv.status] || 0) + 1;
+
+  const servicesByPricing = {};
+  for (const p of Object.values(PRICING_MODEL_V2)) servicesByPricing[p] = 0;
+  for (const s of services) {
+    const model =
+      s.pricing && typeof s.pricing === "object" && s.pricing.model
+        ? String(s.pricing.model)
+        : PRICING_MODEL_V2.FREE;
+    if (servicesByPricing[model] == null) servicesByPricing[model] = 0;
+    servicesByPricing[model]++;
+  }
+
+  let totalDuration = 0;
+  let durationSamples = 0;
+  for (const inv of invocations) {
+    if (inv.durationMs != null && inv.status === INVOCATION_STATUS_V2.SUCCESS) {
+      totalDuration += inv.durationMs;
+      durationSamples++;
+    }
+  }
+  const avgDurationMs =
+    durationSamples > 0
+      ? Number((totalDuration / durationSamples).toFixed(1))
+      : 0;
+  const successRate =
+    invocations.length > 0
+      ? Number(
+          (
+            invocationsByStatus[INVOCATION_STATUS_V2.SUCCESS] /
+            invocations.length
+          ).toFixed(3),
+        )
+      : 0;
+
+  return {
+    totalServices: services.length,
+    totalInvocations: invocations.length,
+    activeInvocations: getActiveInvocationCount(),
+    maxConcurrentInvocations: _maxConcurrentInvocationsPerService,
+    servicesByStatus,
+    invocationsByStatus,
+    servicesByPricing,
+    avgDurationMs,
+    successRate,
+  };
 }