agentbnb 8.2.3 → 8.3.0

package/dist/chunk-5AIYALBX.js

@@ -0,0 +1,857 @@
+import {
+  ensureAgentsTable,
+  resolveCanonicalIdentity
+} from "./chunk-WTHMHNKC.js";
+import {
+  AgentBnBError,
+  AnyCardSchema,
+  CapabilityCardSchema
+} from "./chunk-I7KWA7OB.js";
+
+// src/registry/request-log.ts
+var SINCE_MS = {
+  "24h": 864e5,
+  "7d": 6048e5,
+  "30d": 2592e6
+};
+function createRequestLogTable(db) {
+  db.exec(`
+    CREATE TABLE IF NOT EXISTS request_log (
+      id TEXT PRIMARY KEY,
+      card_id TEXT NOT NULL,
+      card_name TEXT NOT NULL,
+      requester TEXT NOT NULL,
+      status TEXT NOT NULL CHECK(status IN ('success', 'failure', 'timeout')),
+      latency_ms INTEGER NOT NULL,
+      credits_charged INTEGER NOT NULL,
+      created_at TEXT NOT NULL
+    );
+
+    CREATE INDEX IF NOT EXISTS request_log_created_at_idx
+      ON request_log (created_at DESC);
+  `);
+  try {
+    db.exec("ALTER TABLE request_log ADD COLUMN skill_id TEXT");
+  } catch {
+  }
+  try {
+    db.exec("ALTER TABLE request_log ADD COLUMN action_type TEXT");
+  } catch {
+  }
+  try {
+    db.exec("ALTER TABLE request_log ADD COLUMN tier_invoked INTEGER");
+  } catch {
+  }
+  try {
+    db.exec("ALTER TABLE request_log ADD COLUMN failure_reason TEXT");
+  } catch {
+  }
+  try {
+    db.exec("ALTER TABLE request_log ADD COLUMN team_id TEXT");
+  } catch {
+  }
+  try {
+    db.exec("ALTER TABLE request_log ADD COLUMN role TEXT");
+  } catch {
+  }
+  try {
+    db.exec("ALTER TABLE request_log ADD COLUMN capability_type TEXT");
+  } catch {
+  }
+}
+function insertRequestLog(db, entry) {
+  const stmt = db.prepare(`
+    INSERT INTO request_log (id, card_id, card_name, requester, status, latency_ms, credits_charged, created_at, skill_id, action_type, tier_invoked, failure_reason, team_id, role, capability_type)
+    VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+  `);
+  stmt.run(
+    entry.id,
+    entry.card_id,
+    entry.card_name,
+    entry.requester,
+    entry.status,
+    entry.latency_ms,
+    entry.credits_charged,
+    entry.created_at,
+    entry.skill_id ?? null,
+    entry.action_type ?? null,
+    entry.tier_invoked ?? null,
+    entry.failure_reason ?? null,
+    entry.team_id ?? null,
+    entry.role ?? null,
+    entry.capability_type ?? null
+  );
+}
+function getSkillRequestCount(db, skillId, windowMs) {
+  const cutoff = new Date(Date.now() - windowMs).toISOString();
+  const stmt = db.prepare(
+    `SELECT COUNT(*) as cnt FROM request_log
+     WHERE skill_id = ? AND created_at >= ? AND status = 'success' AND action_type IS NULL`
+  );
+  const row = stmt.get(skillId, cutoff);
+  return row.cnt;
+}
+function getActivityFeed(db, limit = 20, since) {
+  const effectiveLimit = Math.min(limit, 100);
+  if (since !== void 0) {
+    const stmt2 = db.prepare(`
+      SELECT r.id, r.card_name, r.requester, c.owner AS provider,
+             r.status, r.credits_charged, r.latency_ms, r.created_at, r.action_type
+      FROM request_log r
+      LEFT JOIN capability_cards c ON r.card_id = c.id
+      WHERE (r.action_type IS NULL OR r.action_type IN ('auto_share', 'agent_joined'))
+        AND r.created_at > ?
+      ORDER BY r.created_at DESC
+      LIMIT ?
+    `);
+    return stmt2.all(since, effectiveLimit);
+  }
+  const stmt = db.prepare(`
+    SELECT r.id, r.card_name, r.requester, c.owner AS provider,
+           r.status, r.credits_charged, r.latency_ms, r.created_at, r.action_type
+    FROM request_log r
+    LEFT JOIN capability_cards c ON r.card_id = c.id
+    WHERE (r.action_type IS NULL OR r.action_type IN ('auto_share', 'agent_joined'))
+    ORDER BY r.created_at DESC
+    LIMIT ?
+  `);
+  return stmt.all(effectiveLimit);
+}
+function getRequestLog(db, limit = 10, since) {
+  if (since !== void 0) {
+    const cutoff = new Date(Date.now() - SINCE_MS[since]).toISOString();
+    const stmt2 = db.prepare(`
+      SELECT id, card_id, card_name, requester, status, latency_ms, credits_charged, created_at, skill_id, action_type, tier_invoked, failure_reason, team_id, role, capability_type
+      FROM request_log
+      WHERE created_at >= ?
+      ORDER BY created_at DESC
+      LIMIT ?
+    `);
+    return stmt2.all(cutoff, limit);
+  }
+  const stmt = db.prepare(`
+    SELECT id, card_id, card_name, requester, status, latency_ms, credits_charged, created_at, skill_id, action_type, tier_invoked, failure_reason, team_id, role
+    FROM request_log
+    ORDER BY created_at DESC
+    LIMIT ?
+  `);
+  return stmt.all(limit);
+}
+
+// src/registry/store.ts
+import Database from "better-sqlite3";
+
+// src/feedback/store.ts
+import { randomUUID } from "crypto";
+function initFeedbackTable(db) {
+  db.exec(`
+    CREATE TABLE IF NOT EXISTS feedback (
+      id TEXT PRIMARY KEY,
+      transaction_id TEXT NOT NULL,
+      provider_agent TEXT NOT NULL,
+      skill_id TEXT NOT NULL,
+      requester_agent TEXT NOT NULL,
+      rating INTEGER NOT NULL,
+      latency_ms INTEGER NOT NULL,
+      result_quality TEXT NOT NULL,
+      quality_details TEXT,
+      would_reuse INTEGER NOT NULL,
+      cost_value_ratio TEXT NOT NULL,
+      timestamp TEXT NOT NULL,
+      created_at TEXT NOT NULL DEFAULT (datetime('now'))
+    );
+
+    CREATE INDEX IF NOT EXISTS feedback_provider_idx ON feedback(provider_agent);
+    CREATE INDEX IF NOT EXISTS feedback_skill_idx ON feedback(skill_id);
+  `);
+}
+function insertFeedback(db, feedback) {
+  const id = randomUUID();
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  db.prepare(`
+    INSERT INTO feedback (
+      id, transaction_id, provider_agent, skill_id, requester_agent,
+      rating, latency_ms, result_quality, quality_details,
+      would_reuse, cost_value_ratio, timestamp, created_at
+    ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+  `).run(
+    id,
+    feedback.transaction_id,
+    feedback.provider_agent,
+    feedback.skill_id,
+    feedback.requester_agent,
+    feedback.rating,
+    feedback.latency_ms,
+    feedback.result_quality,
+    feedback.quality_details ?? null,
+    feedback.would_reuse ? 1 : 0,
+    feedback.cost_value_ratio,
+    feedback.timestamp,
+    now
+  );
+  return id;
+}
+function getFeedbackForSkill(db, skillId, limit = 20) {
+  const rows = db.prepare(`
+    SELECT * FROM feedback
+    WHERE skill_id = ?
+    ORDER BY timestamp DESC
+    LIMIT ?
+  `).all(skillId, limit);
+  return rows.map(rowToFeedback);
+}
+function getFeedbackForProvider(db, providerAgent, sinceDays) {
+  let rows;
+  if (sinceDays !== void 0) {
+    rows = db.prepare(`
+      SELECT * FROM feedback
+      WHERE provider_agent = ?
+        AND timestamp >= datetime('now', ? || ' days')
+      ORDER BY timestamp DESC
+    `).all(providerAgent, `-${sinceDays}`);
+  } else {
+    rows = db.prepare(`
+      SELECT * FROM feedback
+      WHERE provider_agent = ?
+      ORDER BY timestamp DESC
+    `).all(providerAgent);
+  }
+  return rows.map(rowToFeedback);
+}
+function rowToFeedback(row) {
+  return {
+    transaction_id: row["transaction_id"],
+    provider_agent: row["provider_agent"],
+    skill_id: row["skill_id"],
+    requester_agent: row["requester_agent"],
+    rating: row["rating"],
+    latency_ms: row["latency_ms"],
+    result_quality: row["result_quality"],
+    quality_details: row["quality_details"] ?? void 0,
+    would_reuse: row["would_reuse"] === 1,
+    cost_value_ratio: row["cost_value_ratio"],
+    timestamp: row["timestamp"]
+  };
+}
+
+// src/evolution/store.ts
+import { randomUUID as randomUUID2 } from "crypto";
+function initEvolutionTable(db) {
+  db.exec(`
+    CREATE TABLE IF NOT EXISTS evolution_versions (
+      id TEXT PRIMARY KEY,
+      template_name TEXT NOT NULL,
+      template_version TEXT NOT NULL,
+      publisher_agent TEXT NOT NULL,
+      changelog TEXT NOT NULL,
+      core_memory_snapshot TEXT NOT NULL,
+      fitness_improvement REAL NOT NULL,
+      timestamp TEXT NOT NULL,
+      created_at TEXT NOT NULL DEFAULT (datetime('now'))
+    );
+
+    CREATE INDEX IF NOT EXISTS evolution_template_idx
+      ON evolution_versions(template_name, created_at DESC);
+  `);
+}
+function insertEvolution(db, ev) {
+  const id = randomUUID2();
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  db.prepare(`
+    INSERT INTO evolution_versions (
+      id, template_name, template_version, publisher_agent,
+      changelog, core_memory_snapshot, fitness_improvement, timestamp, created_at
+    ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)
+  `).run(
+    id,
+    ev.template_name,
+    ev.template_version,
+    ev.publisher_agent,
+    ev.changelog,
+    JSON.stringify(ev.core_memory_snapshot),
+    ev.fitness_improvement,
+    ev.timestamp,
+    now
+  );
+  return id;
+}
+function getLatestEvolution(db, templateName) {
+  const row = db.prepare(`
+    SELECT * FROM evolution_versions
+    WHERE template_name = ?
+    ORDER BY created_at DESC
+    LIMIT 1
+  `).get(templateName);
+  if (!row) return null;
+  return rowToEvolution(row);
+}
+function getEvolutionHistory(db, templateName, limit = 20) {
+  const rows = db.prepare(`
+    SELECT * FROM evolution_versions
+    WHERE template_name = ?
+    ORDER BY created_at DESC
+    LIMIT ?
+  `).all(templateName, limit);
+  return rows.map(rowToEvolution);
+}
+function rowToEvolution(row) {
+  return {
+    template_name: row["template_name"],
+    template_version: row["template_version"],
+    publisher_agent: row["publisher_agent"],
+    changelog: row["changelog"],
+    core_memory_snapshot: JSON.parse(row["core_memory_snapshot"]),
+    fitness_improvement: row["fitness_improvement"],
+    timestamp: row["timestamp"]
+  };
+}
+
+// src/registry/store.ts
+var V2_FTS_TRIGGERS = `
+  DROP TRIGGER IF EXISTS cards_ai;
+  DROP TRIGGER IF EXISTS cards_au;
+  DROP TRIGGER IF EXISTS cards_ad;
+
+  CREATE TRIGGER cards_ai AFTER INSERT ON capability_cards BEGIN
+    INSERT INTO cards_fts(rowid, id, owner, name, description, tags)
+    VALUES (
+      new.rowid,
+      new.id,
+      new.owner,
+      COALESCE(
+        (SELECT group_concat(
+            COALESCE(json_extract(value, '$.id'), '') || ' ' || COALESCE(json_extract(value, '$.name'), ''),
+            ' '
+         )
+         FROM json_each(json_extract(new.data, '$.skills'))),
+        json_extract(new.data, '$.name'),
+        ''
+      ),
+      COALESCE(
+        (SELECT group_concat(json_extract(value, '$.description'), ' ')
+         FROM json_each(json_extract(new.data, '$.skills'))),
+        json_extract(new.data, '$.description'),
+        ''
+      ),
+      COALESCE(
+        (SELECT group_concat(json_extract(value, '$.metadata.tags'), ' ')
+         FROM json_each(json_extract(new.data, '$.skills'))),
+        (SELECT group_concat(value, ' ')
+         FROM json_each(json_extract(new.data, '$.metadata.tags'))),
+        ''
+      )
+      || ' ' || COALESCE(
+        (SELECT group_concat(json_extract(skill.value, '$.capability_type'), ' ')
+         FROM json_each(json_extract(new.data, '$.skills')) AS skill),
+        ''
+      )
+      || ' ' || COALESCE(
+        (SELECT group_concat(cap_type.value, ' ')
+         FROM json_each(json_extract(new.data, '$.skills')) AS skill,
+              json_each(json_extract(skill.value, '$.capability_types')) AS cap_type),
+        ''
+      )
+    );
+  END;
+
+  CREATE TRIGGER cards_au AFTER UPDATE ON capability_cards BEGIN
+    INSERT INTO cards_fts(cards_fts, rowid, id, owner, name, description, tags)
+    VALUES (
+      'delete',
+      old.rowid,
+      old.id,
+      old.owner,
+      COALESCE(
+        (SELECT group_concat(
+            COALESCE(json_extract(value, '$.id'), '') || ' ' || COALESCE(json_extract(value, '$.name'), ''),
+            ' '
+         )
+         FROM json_each(json_extract(old.data, '$.skills'))),
+        json_extract(old.data, '$.name'),
+        ''
+      ),
+      COALESCE(
+        (SELECT group_concat(json_extract(value, '$.description'), ' ')
+         FROM json_each(json_extract(old.data, '$.skills'))),
+        json_extract(old.data, '$.description'),
+        ''
+      ),
+      COALESCE(
+        (SELECT group_concat(json_extract(value, '$.metadata.tags'), ' ')
+         FROM json_each(json_extract(old.data, '$.skills'))),
+        (SELECT group_concat(value, ' ')
+         FROM json_each(json_extract(old.data, '$.metadata.tags'))),
+        ''
+      )
+      || ' ' || COALESCE(
+        (SELECT group_concat(json_extract(skill.value, '$.capability_type'), ' ')
+         FROM json_each(json_extract(old.data, '$.skills')) AS skill),
+        ''
+      )
+      || ' ' || COALESCE(
+        (SELECT group_concat(cap_type.value, ' ')
+         FROM json_each(json_extract(old.data, '$.skills')) AS skill,
+              json_each(json_extract(skill.value, '$.capability_types')) AS cap_type),
+        ''
+      )
+    );
+    INSERT INTO cards_fts(rowid, id, owner, name, description, tags)
+    VALUES (
+      new.rowid,
+      new.id,
+      new.owner,
+      COALESCE(
+        (SELECT group_concat(
+            COALESCE(json_extract(value, '$.id'), '') || ' ' || COALESCE(json_extract(value, '$.name'), ''),
+            ' '
+         )
+         FROM json_each(json_extract(new.data, '$.skills'))),
+        json_extract(new.data, '$.name'),
+        ''
+      ),
+      COALESCE(
+        (SELECT group_concat(json_extract(value, '$.description'), ' ')
+         FROM json_each(json_extract(new.data, '$.skills'))),
+        json_extract(new.data, '$.description'),
+        ''
+      ),
+      COALESCE(
+        (SELECT group_concat(json_extract(value, '$.metadata.tags'), ' ')
+         FROM json_each(json_extract(new.data, '$.skills'))),
+        (SELECT group_concat(value, ' ')
+         FROM json_each(json_extract(new.data, '$.metadata.tags'))),
+        ''
+      )
+      || ' ' || COALESCE(
+        (SELECT group_concat(json_extract(skill.value, '$.capability_type'), ' ')
+         FROM json_each(json_extract(new.data, '$.skills')) AS skill),
+        ''
+      )
+      || ' ' || COALESCE(
+        (SELECT group_concat(cap_type.value, ' ')
+         FROM json_each(json_extract(new.data, '$.skills')) AS skill,
+              json_each(json_extract(skill.value, '$.capability_types')) AS cap_type),
+        ''
+      )
+    );
+  END;
+
+  CREATE TRIGGER cards_ad AFTER DELETE ON capability_cards BEGIN
+    INSERT INTO cards_fts(cards_fts, rowid, id, owner, name, description, tags)
+    VALUES (
+      'delete',
+      old.rowid,
+      old.id,
+      old.owner,
+      COALESCE(
+        (SELECT group_concat(
+            COALESCE(json_extract(value, '$.id'), '') || ' ' || COALESCE(json_extract(value, '$.name'), ''),
+            ' '
+         )
+         FROM json_each(json_extract(old.data, '$.skills'))),
+        json_extract(old.data, '$.name'),
+        ''
+      ),
+      COALESCE(
+        (SELECT group_concat(json_extract(value, '$.description'), ' ')
+         FROM json_each(json_extract(old.data, '$.skills'))),
+        json_extract(old.data, '$.description'),
+        ''
+      ),
+      COALESCE(
+        (SELECT group_concat(json_extract(value, '$.metadata.tags'), ' ')
+         FROM json_each(json_extract(old.data, '$.skills'))),
+        (SELECT group_concat(value, ' ')
+         FROM json_each(json_extract(old.data, '$.metadata.tags'))),
+        ''
+      )
+      || ' ' || COALESCE(
+        (SELECT group_concat(json_extract(skill.value, '$.capability_type'), ' ')
+         FROM json_each(json_extract(old.data, '$.skills')) AS skill),
+        ''
+      )
+      || ' ' || COALESCE(
+        (SELECT group_concat(cap_type.value, ' ')
+         FROM json_each(json_extract(old.data, '$.skills')) AS skill,
+              json_each(json_extract(skill.value, '$.capability_types')) AS cap_type),
+        ''
+      )
+    );
+  END;
+`;
+function openDatabase(path = ":memory:") {
+  const db = new Database(path);
+  db.pragma("journal_mode = WAL");
+  db.pragma("foreign_keys = ON");
+  db.exec(`
+    CREATE TABLE IF NOT EXISTS capability_cards (
+      id TEXT PRIMARY KEY,
+      owner TEXT NOT NULL,
+      data TEXT NOT NULL,
+      created_at TEXT NOT NULL,
+      updated_at TEXT NOT NULL
+    );
+
+    CREATE TABLE IF NOT EXISTS pending_requests (
+      id TEXT PRIMARY KEY,
+      skill_query TEXT NOT NULL,
+      max_cost_credits REAL NOT NULL,
+      selected_peer TEXT,
+      selected_card_id TEXT,
+      selected_skill_id TEXT,
+      credits REAL NOT NULL,
+      status TEXT NOT NULL DEFAULT 'pending',
+      params TEXT,
+      created_at TEXT NOT NULL,
+      resolved_at TEXT
+    );
+
+    CREATE VIRTUAL TABLE IF NOT EXISTS cards_fts USING fts5(
+      id UNINDEXED,
+      owner,
+      name,
+      description,
+      tags,
+      content=""
+    );
+
+    -- Expression index for capability_type lookups (used by Conductor routing).
+    -- Turns json_extract full-table-scan into O(log n) B-tree lookup.
+    CREATE INDEX IF NOT EXISTS idx_cards_capability_type
+      ON capability_cards(json_extract(data, '$.capability_type'));
+
+    -- Owner index for listCards(owner) and other owner-scoped queries.
+    CREATE INDEX IF NOT EXISTS idx_cards_owner
+      ON capability_cards(owner);
+  `);
+  createRequestLogTable(db);
+  ensureAgentsTable(db);
+  initFeedbackTable(db);
+  initEvolutionTable(db);
+  runMigrations(db);
+  return db;
+}
+function runMigrations(db) {
+  const version = db.pragma("user_version")[0]?.user_version ?? 0;
+  if (version < 2) {
+    migrateV1toV2(db);
+    return;
+  }
+  if (version < 3) {
+    migrateV2toV3(db);
+  }
+}
+function migrateV1toV2(db) {
+  const migrate = db.transaction(() => {
+    const rows = db.prepare("SELECT rowid, id, data FROM capability_cards").all();
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    for (const row of rows) {
+      const parsed = JSON.parse(row.data);
+      if (parsed["spec_version"] === "2.0") continue;
+      const v1 = parsed;
+      const v2 = {
+        spec_version: "2.0",
+        id: v1.id,
+        owner: v1.owner,
+        agent_name: v1.name,
+        skills: [
+          {
+            id: `skill-${v1.id}`,
+            name: v1.name,
+            description: v1.description,
+            level: v1.level,
+            inputs: v1.inputs,
+            outputs: v1.outputs,
+            pricing: v1.pricing,
+            availability: { online: v1.availability.online },
+            powered_by: v1.powered_by,
+            metadata: v1.metadata,
+            _internal: v1._internal
+          }
+        ],
+        availability: v1.availability,
+        created_at: v1.created_at,
+        updated_at: now
+      };
+      db.prepare("UPDATE capability_cards SET data = ?, updated_at = ? WHERE id = ?").run(
+        JSON.stringify(v2),
+        now,
+        v2.id
+      );
+    }
+    db.exec(V2_FTS_TRIGGERS);
+    rebuildCardsFts(db);
+    db.pragma("user_version = 3");
+  });
+  migrate();
+}
+function migrateV2toV3(db) {
+  const migrate = db.transaction(() => {
+    db.exec(V2_FTS_TRIGGERS);
+    rebuildCardsFts(db);
+    db.pragma("user_version = 3");
+  });
+  migrate();
+}
+function rebuildCardsFts(db) {
+  db.exec(`INSERT INTO cards_fts(cards_fts) VALUES('delete-all')`);
+  const allRows = db.prepare("SELECT rowid, id, owner, data FROM capability_cards").all();
+  const ftsInsert = db.prepare(
+    "INSERT INTO cards_fts(rowid, id, owner, name, description, tags) VALUES (?, ?, ?, ?, ?, ?)"
+  );
+  for (const row of allRows) {
+    const data = JSON.parse(row.data);
+    const skills = data["skills"] ?? [];
+    let name;
+    let description;
+    let tags;
+    if (skills.length > 0) {
+      name = skills.map((s) => `${String(s["id"] ?? "")} ${String(s["name"] ?? "")}`.trim()).join(" ");
+      description = skills.map((s) => String(s["description"] ?? "")).join(" ");
+      tags = [
+        // tags from metadata.tags[]
+        ...skills.flatMap((s) => {
+          const meta = s["metadata"];
+          return meta?.["tags"] ?? [];
+        }),
+        // capability_type (singular)
+        ...skills.map((s) => s["capability_type"]).filter((v) => typeof v === "string" && v.length > 0),
+        // capability_types[] (plural)
+        ...skills.flatMap((s) => s["capability_types"] ?? [])
+      ].join(" ");
+    } else {
+      name = String(data["name"] ?? "");
+      description = String(data["description"] ?? "");
+      const meta = data["metadata"];
+      const rawTags = meta?.["tags"] ?? [];
+      tags = rawTags.join(" ");
+    }
+    ftsInsert.run(row.rowid, row.id, row.owner, name, description, tags);
+  }
+}
+function insertCard(db, card) {
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  const withTimestamps = attachCanonicalAgentId(db, {
+    ...card,
+    created_at: card.created_at ?? now,
+    updated_at: now
+  });
+  const parsed = CapabilityCardSchema.safeParse(withTimestamps);
+  if (!parsed.success) {
+    throw new AgentBnBError(
+      `Card validation failed: ${parsed.error.message}`,
+      "VALIDATION_ERROR"
+    );
+  }
+  const stmt = db.prepare(`
+    INSERT INTO capability_cards (id, owner, data, created_at, updated_at)
+    VALUES (?, ?, ?, ?, ?)
+  `);
+  stmt.run(
+    parsed.data.id,
+    parsed.data.owner,
+    JSON.stringify(parsed.data),
+    parsed.data.created_at ?? now,
+    parsed.data.updated_at ?? now
+  );
+}
+function getCard(db, id) {
+  const stmt = db.prepare("SELECT data FROM capability_cards WHERE id = ?");
+  const row = stmt.get(id);
+  if (!row) return null;
+  return JSON.parse(row.data);
+}
+function attachCanonicalAgentId(db, card) {
+  const resolved = resolveCanonicalIdentity(db, card.owner);
+  if (!resolved.resolved) {
+    return card;
+  }
+  if (card.agent_id === resolved.agent_id) {
+    return card;
+  }
+  return {
+    ...card,
+    agent_id: resolved.agent_id
+  };
+}
+function canManageCardByIdentifier(db, card, identifier) {
+  if (card.owner === identifier) return true;
+  const requester = resolveCanonicalIdentity(db, identifier);
+  if (!requester.resolved) {
+    return typeof card.agent_id === "string" && card.agent_id.length > 0 && card.agent_id === identifier;
+  }
+  if (typeof card.agent_id === "string" && card.agent_id.length > 0) {
+    return requester.agent_id === card.agent_id;
+  }
+  const cardOwnerIdentity = resolveCanonicalIdentity(db, card.owner);
+  return cardOwnerIdentity.resolved && cardOwnerIdentity.agent_id === requester.agent_id;
+}
+function updateCard(db, id, owner, updates) {
+  const existing = getCard(db, id);
+  if (!existing) {
+    throw new AgentBnBError(`Card not found: ${id}`, "NOT_FOUND");
+  }
+  if (!canManageCardByIdentifier(db, existing, owner)) {
+    throw new AgentBnBError("Forbidden: you do not own this card", "FORBIDDEN");
+  }
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  const merged = attachCanonicalAgentId(db, { ...existing, ...updates, updated_at: now });
+  const parsed = AnyCardSchema.safeParse(merged);
+  if (!parsed.success) {
+    throw new AgentBnBError(
+      `Card validation failed: ${parsed.error.message}`,
+      "VALIDATION_ERROR"
+    );
+  }
+  const stmt = db.prepare(`
+    UPDATE capability_cards
+    SET data = ?, updated_at = ?
+    WHERE id = ?
+  `);
+  stmt.run(JSON.stringify(parsed.data), now, id);
+}
+function deleteCard(db, id, owner) {
+  const existing = getCard(db, id);
+  if (!existing) {
+    throw new AgentBnBError(`Card not found: ${id}`, "NOT_FOUND");
+  }
+  if (!canManageCardByIdentifier(db, existing, owner)) {
+    throw new AgentBnBError("Forbidden: you do not own this card", "FORBIDDEN");
+  }
+  db.prepare("DELETE FROM capability_cards WHERE id = ?").run(id);
+}
+function updateReputation(db, cardId, success, latencyMs) {
+  const existing = getCard(db, cardId);
+  if (!existing) return;
+  const ALPHA = 0.1;
+  const observed = success ? 1 : 0;
+  const prevSuccessRate = existing.metadata?.success_rate;
+  const prevLatency = existing.metadata?.avg_latency_ms;
+  const newSuccessRate = prevSuccessRate === void 0 ? observed : ALPHA * observed + (1 - ALPHA) * prevSuccessRate;
+  const newLatency = prevLatency === void 0 ? latencyMs : ALPHA * latencyMs + (1 - ALPHA) * prevLatency;
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  const updatedMetadata = {
+    ...existing.metadata,
+    success_rate: Math.round(newSuccessRate * 1e3) / 1e3,
+    avg_latency_ms: Math.round(newLatency)
+  };
+  const updatedCard = { ...existing, metadata: updatedMetadata, updated_at: now };
+  const stmt = db.prepare(`
+    UPDATE capability_cards
+    SET data = ?, updated_at = ?
+    WHERE id = ?
+  `);
+  stmt.run(JSON.stringify(updatedCard), now, cardId);
+}
+function updateSkillAvailability(db, cardId, skillId, online) {
+  const row = db.prepare("SELECT data FROM capability_cards WHERE id = ?").get(cardId);
+  if (!row) return;
+  const card = JSON.parse(row.data);
+  const skills = card["skills"];
+  if (!skills) return;
+  const skill = skills.find((s) => s["id"] === skillId);
+  if (!skill) return;
+  const existing = skill["availability"] ?? {};
+  skill["availability"] = { ...existing, online };
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  db.prepare("UPDATE capability_cards SET data = ?, updated_at = ? WHERE id = ?").run(
+    JSON.stringify(card),
+    now,
+    cardId
+  );
+}
+function updateSkillIdleRate(db, cardId, skillId, idleRate) {
+  const row = db.prepare("SELECT data FROM capability_cards WHERE id = ?").get(cardId);
+  if (!row) return;
+  const card = JSON.parse(row.data);
+  const skills = card["skills"];
+  if (!skills) return;
+  const skill = skills.find((s) => s["id"] === skillId);
+  if (!skill) return;
+  const existing = skill["_internal"] ?? {};
+  skill["_internal"] = {
+    ...existing,
+    idle_rate: idleRate,
+    idle_rate_computed_at: (/* @__PURE__ */ new Date()).toISOString()
+  };
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  db.prepare("UPDATE capability_cards SET data = ?, updated_at = ? WHERE id = ?").run(
+    JSON.stringify(card),
+    now,
+    cardId
+  );
+}
+function listCards(db, owner) {
+  if (owner === void 0) {
+    const rows = db.prepare("SELECT data FROM capability_cards").all();
+    return rows.map((row) => JSON.parse(row.data));
+  }
+  const filtered = /* @__PURE__ */ new Map();
+  const resolved = resolveCanonicalIdentity(db, owner);
+  const ownerAliases = /* @__PURE__ */ new Set([owner]);
+  if (resolved.legacy_owner) {
+    ownerAliases.add(resolved.legacy_owner);
+  }
+  for (const alias of ownerAliases) {
+    const aliasRows = db.prepare("SELECT data FROM capability_cards WHERE owner = ?").all(alias);
+    for (const row of aliasRows) {
+      const parsed = JSON.parse(row.data);
+      filtered.set(parsed.id, parsed);
+    }
+  }
+  const agentIdentifiers = /* @__PURE__ */ new Set([owner]);
+  if (resolved.resolved) {
+    agentIdentifiers.add(resolved.agent_id);
+  }
+  for (const agentIdentifier of agentIdentifiers) {
+    const agentRows = db.prepare("SELECT data FROM capability_cards WHERE json_extract(data, '$.agent_id') = ?").all(agentIdentifier);
+    for (const row of agentRows) {
+      const parsed = JSON.parse(row.data);
+      filtered.set(parsed.id, parsed);
+    }
+  }
+  return [...filtered.values()];
+}
+function getCardsByCapabilityType(db, capabilityType) {
+  const rows = db.prepare(
+    "SELECT data FROM capability_cards WHERE json_extract(data, '$.capability_type') = ?"
+  ).all(capabilityType);
+  return rows.map((row) => JSON.parse(row.data));
+}
+function getCardsBySkillCapability(db, capabilityType) {
+  const rows = db.prepare("SELECT data FROM capability_cards").all();
+  return rows.map((row) => JSON.parse(row.data)).filter((card) => {
+    const skills = card["skills"];
+    if (!skills) return false;
+    return skills.some((skill) => {
+      if (skill["capability_type"] === capabilityType) return true;
+      const types = skill["capability_types"];
+      return Array.isArray(types) && types.includes(capabilityType);
+    });
+  });
+}
+
+export {
+  insertFeedback,
+  getFeedbackForSkill,
+  getFeedbackForProvider,
+  insertRequestLog,
+  getSkillRequestCount,
+  getActivityFeed,
+  getRequestLog,
+  insertEvolution,
+  getLatestEvolution,
+  getEvolutionHistory,
+  openDatabase,
+  insertCard,
+  getCard,
+  attachCanonicalAgentId,
+  updateCard,
+  deleteCard,
+  updateReputation,
+  updateSkillAvailability,
+  updateSkillIdleRate,
+  listCards,
+  getCardsByCapabilityType,
+  getCardsBySkillCapability
+};