@getbourdon/participants 0.1.0 → 0.2.0

package/dist/index.cjs

@@ -0,0 +1,3292 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  CONTRACT_VERSION: () => CONTRACT_VERSION,
+  CacheEntry: () => CacheEntry,
+  CascadeParticipant: () => CascadeParticipant,
+  ClaudeCodeParticipant: () => ClaudeCodeParticipant,
+  CopilotCliParticipant: () => CopilotCliParticipant,
+  CopilotParticipant: () => CopilotParticipant,
+  CursorParticipant: () => CursorParticipant,
+  DEFAULT_CACHE_TTL_SECONDS: () => DEFAULT_CACHE_TTL_SECONDS,
+  FIRST_PARTY: () => FIRST_PARTY,
+  GitHubCopilotParticipant: () => GitHubCopilotParticipant,
+  HermesParticipant: () => HermesParticipant,
+  MIN_PATCHED_VERSION: () => MIN_PATCHED_VERSION,
+  NETWORK_CONTRACT_VERSION: () => NETWORK_CONTRACT_VERSION,
+  NetworkParticipant: () => NetworkParticipant,
+  NetworkUnavailable: () => NetworkUnavailable,
+  OpenClawApiClient: () => OpenClawApiClient,
+  OpenClawParticipant: () => OpenClawParticipant,
+  ParticipantAuthError: () => ParticipantAuthError,
+  ParticipantDiscoveryError: () => ParticipantDiscoveryError,
+  ParticipantError: () => ParticipantError,
+  ParticipantExportError: () => ParticipantExportError,
+  ParticipantVersionMismatchError: () => ParticipantVersionMismatchError,
+  PayloadCache: () => PayloadCache,
+  SPEC_VERSION: () => SPEC_VERSION,
+  Visibility: () => import_l59.Visibility,
+  applyVisibility: () => import_l59.applyVisibility,
+  defaultCacheRoot: () => defaultCacheRoot,
+  discoverParticipants: () => discoverParticipants,
+  envAuthProvider: () => envAuthProvider,
+  epochToIsoDate: () => epochToIsoDate,
+  epochToIsoDatetime: () => epochToIsoDatetime,
+  filterForFederation: () => import_l59.filterForFederation,
+  friendlyLabel: () => friendlyLabel,
+  ghTokenProvider: () => ghTokenProvider,
+  isParticipant: () => isParticipant,
+  openReadonly: () => openReadonly,
+  projectKeyFromCwd: () => projectKeyFromCwd,
+  resolvePluginParticipants: () => resolvePluginParticipants,
+  sqliteAvailable: () => sqliteAvailable,
+  tableColumns: () => tableColumns,
+  tableExists: () => tableExists,
+  toDict: () => import_l59.toDict,
+  tryOpenReadonly: () => tryOpenReadonly,
+  validateManifest: () => import_l59.validateManifest,
+  verifyInstance: () => verifyInstance
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/base.ts
+var CONTRACT_VERSION = "0.1";
+var SPEC_VERSION = "0.1";
+var ParticipantError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = new.target.name;
+  }
+};
+var ParticipantDiscoveryError = class extends ParticipantError {
+};
+var ParticipantExportError = class extends ParticipantError {
+};
+var ParticipantVersionMismatchError = class extends ParticipantDiscoveryError {
+};
+function isParticipant(obj) {
+  if (obj === null || typeof obj !== "object") return false;
+  const o = obj;
+  return typeof o["agentId"] === "string" && typeof o["agentType"] === "string" && typeof o["exportL5"] === "function" && typeof o["healthCheck"] === "function";
+}
+
+// src/sqlite-base.ts
+var import_node_fs = require("fs");
+var import_node_module = require("module");
+var import_meta = {};
+var moduleUrl = typeof import_meta !== "undefined" && import_meta.url || (typeof __filename !== "undefined" ? __filename : process.cwd());
+var nodeRequire = (0, import_node_module.createRequire)(moduleUrl);
+var driver;
+function loadDriver() {
+  if (driver !== void 0) return driver;
+  try {
+    driver = nodeRequire("better-sqlite3");
+  } catch {
+    driver = null;
+  }
+  return driver;
+}
+function sqliteAvailable() {
+  return loadDriver() !== null;
+}
+function openReadonly(dbPath, opts = {}) {
+  const Ctor = loadDriver();
+  if (!Ctor) {
+    throw new Error("better-sqlite3 native addon is not available");
+  }
+  return new Ctor(dbPath, {
+    readonly: true,
+    fileMustExist: true,
+    timeout: opts.timeoutMs ?? 2e3
+  });
+}
+function tryOpenReadonly(dbPath, opts = {}) {
+  try {
+    if (!(0, import_node_fs.statSync)(dbPath).isFile()) return null;
+  } catch {
+    return null;
+  }
+  try {
+    return openReadonly(dbPath, opts);
+  } catch {
+    return null;
+  }
+}
+function tableExists(db, name) {
+  try {
+    const row = db.prepare("SELECT 1 FROM sqlite_master WHERE type='table' AND name=? LIMIT 1").get(name);
+    return row !== void 0;
+  } catch {
+    return false;
+  }
+}
+function tableColumns(db, table) {
+  try {
+    const rows = db.prepare(`PRAGMA table_info(${table})`).all();
+    return new Set(rows.map((r) => r.name));
+  } catch {
+    return /* @__PURE__ */ new Set();
+  }
+}
+function toFiniteNumber(value) {
+  if (value === null || value === void 0) return null;
+  const n = typeof value === "number" ? value : Number(value);
+  return Number.isFinite(n) ? n : null;
+}
+function epochToIsoDate(value) {
+  const n = toFiniteNumber(value);
+  if (n === null) return null;
+  const d = new Date(n * 1e3);
+  if (Number.isNaN(d.getTime())) return null;
+  return d.toISOString().slice(0, 10);
+}
+function epochToIsoDatetime(value) {
+  const n = toFiniteNumber(value);
+  if (n === null) return null;
+  const d = new Date(n * 1e3);
+  if (Number.isNaN(d.getTime())) return null;
+  return d.toISOString().replace(/\.\d{3}Z$/, "+00:00").replace(/Z$/, "+00:00");
+}
+function basenameOf(p) {
+  const trimmed = p.replace(/[\\/]+$/, "");
+  const parts = trimmed.split(/[\\/]/);
+  return parts[parts.length - 1] ?? "";
+}
+function projectKeyFromCwd(cwd, genericNames = /* @__PURE__ */ new Set()) {
+  if (!cwd) return null;
+  const name = basenameOf(cwd).trim().toLowerCase();
+  if (!name || genericNames.has(name)) return null;
+  return name;
+}
+function friendlyLabel(key) {
+  return key.replace(/[-_]+/g, " ").trim().replace(/\S+/g, (w) => w.charAt(0).toUpperCase() + w.slice(1).toLowerCase());
+}
+
+// src/network-base.ts
+var import_node_fs2 = require("fs");
+var import_node_os = require("os");
+var import_node_path = require("path");
+var NETWORK_CONTRACT_VERSION = "0.3";
+var DEFAULT_CACHE_TTL_SECONDS = 15 * 60;
+var NetworkUnavailable = class extends ParticipantError {
+};
+var ParticipantAuthError = class extends ParticipantError {
+};
+function envAuthProvider(varName) {
+  return () => process.env[varName] || null;
+}
+function defaultCacheRoot() {
+  const xdg = process.env.XDG_CACHE_HOME;
+  const base = xdg ? xdg : (0, import_node_path.join)((0, import_node_os.homedir)(), ".cache");
+  return (0, import_node_path.join)(base, "bourdon");
+}
+var CacheEntry = class {
+  constructor(fetchedAt, payload) {
+    this.fetchedAt = fetchedAt;
+    this.payload = payload;
+  }
+  fetchedAt;
+  payload;
+  get ageSeconds() {
+    return Math.max(0, Date.now() / 1e3 - this.fetchedAt);
+  }
+  isFresh(ttlSeconds) {
+    return this.ageSeconds < ttlSeconds;
+  }
+};
+var PayloadCache = class {
+  slug;
+  root;
+  path;
+  constructor(slug, rootDir) {
+    this.slug = slug;
+    this.root = (0, import_node_path.join)(rootDir ?? defaultCacheRoot(), slug);
+    this.path = (0, import_node_path.join)(this.root, "payload.json");
+  }
+  read() {
+    let raw;
+    try {
+      raw = JSON.parse((0, import_node_fs2.readFileSync)(this.path, "utf8"));
+    } catch {
+      return null;
+    }
+    if (typeof raw !== "object" || raw === null || !("payload" in raw)) return null;
+    const obj = raw;
+    let fetchedAt = Number(obj["fetched_at"] ?? 0);
+    if (!Number.isFinite(fetchedAt)) fetchedAt = 0;
+    const payload = obj["payload"];
+    if (typeof payload !== "object" || payload === null || Array.isArray(payload)) return null;
+    return new CacheEntry(fetchedAt, payload);
+  }
+  write(payload) {
+    try {
+      (0, import_node_fs2.mkdirSync)(this.root, { recursive: true });
+      const tmp = `${this.path}.tmp`;
+      (0, import_node_fs2.writeFileSync)(tmp, JSON.stringify({ fetched_at: Date.now() / 1e3, payload }), "utf8");
+      (0, import_node_fs2.renameSync)(tmp, this.path);
+    } catch {
+    }
+  }
+};
+var NetworkParticipant = class {
+  participantSlug = "network";
+  agentId = "network";
+  agentType = "other";
+  cacheTtlSeconds = DEFAULT_CACHE_TTL_SECONDS;
+  nativePath = "network://";
+  authProvider;
+  cacheRoot;
+  cacheInstance;
+  constructor(opts = {}) {
+    this.authProvider = opts.authProvider ?? null;
+    this.cacheRoot = opts.cacheRoot;
+  }
+  /** Lazily built so it reads the SUBCLASS's `participantSlug` — subclass field
+   * initializers run after `super()`, so building the cache in the constructor
+   * would capture the base "network" slug instead. */
+  get cache() {
+    if (!this.cacheInstance) {
+      this.cacheInstance = new PayloadCache(this.participantSlug, this.cacheRoot);
+    }
+    return this.cacheInstance;
+  }
+  // -- Core fetch-with-cache-and-degrade -------------------------------------
+  /**
+   * Resolve (payload, source) where source is 'cache' | 'network' | 'stale-cache'.
+   *   1. Fresh cache hit           → 'cache'        (no network)
+   *   2. Miss/expired + token      → 'network'      (fetch + refresh cache)
+   *   3. Net fails + any cache     → 'stale-cache'  (serve last good payload)
+   *   4. Net fails + no cache      → raise
+   * Auth errors are never swallowed — they propagate so health surfaces
+   * 'blocked' rather than serving stale data behind a dead token.
+   */
+  getPayload() {
+    const cached = this.cache.read();
+    if (cached !== null && cached.isFresh(this.cacheTtlSeconds)) {
+      return { payload: cached.payload, source: "cache" };
+    }
+    const token = this.authProvider ? this.authProvider() : null;
+    if (!token) {
+      if (cached !== null) return { payload: cached.payload, source: "stale-cache" };
+      throw new ParticipantAuthError(
+        `${this.participantSlug}: no auth token available and no cache`
+      );
+    }
+    let payload;
+    try {
+      payload = this.fetchPayload(token);
+    } catch (err) {
+      if (err instanceof ParticipantAuthError) throw err;
+      if (err instanceof NetworkUnavailable) {
+        if (cached !== null) return { payload: cached.payload, source: "stale-cache" };
+        throw err;
+      }
+      throw err;
+    }
+    this.cache.write(payload);
+    return { payload, source: "network" };
+  }
+  // -- Participant protocol ---------------------------------------------------
+  discover() {
+    const { source } = this.getPayload();
+    return {
+      path: this.nativePath,
+      version: `${this.participantSlug}-network-v1`,
+      metadata: { source, contract_version: NETWORK_CONTRACT_VERSION }
+    };
+  }
+  exportL5(_since) {
+    const { payload } = this.getPayload();
+    return this.payloadToL5(payload);
+  }
+  exportSessions(since, limit = 100) {
+    const manifest = this.exportL5(since);
+    let sessions = manifest.recent_sessions ?? [];
+    if (since) {
+      const cutoff = since.toISOString().slice(0, 10);
+      sessions = sessions.filter((s) => (s.date || "") >= cutoff);
+    }
+    return sessions.slice(0, limit);
+  }
+  healthCheck() {
+    let source;
+    try {
+      source = this.getPayload().source;
+    } catch (err) {
+      if (err instanceof ParticipantAuthError) {
+        return {
+          status: "blocked",
+          reason: String(err.message),
+          details: { participant: this.participantSlug },
+          proposedFix: `Provide a valid credential for ${this.participantSlug} (see the adapter docs for the auth path) and re-run \`bourdon export-all\`.`
+        };
+      }
+      if (err instanceof NetworkUnavailable) {
+        return {
+          status: "degraded",
+          reason: `network unavailable and no cache: ${err.message}`,
+          details: { participant: this.participantSlug },
+          proposedFix: "Check connectivity, then re-run `bourdon export-all`."
+        };
+      }
+      return {
+        status: "blocked",
+        reason: `unexpected error resolving payload: ${String(err)}`,
+        details: { participant: this.participantSlug },
+        proposedFix: `${this.participantSlug} raised an unexpected error during healthCheck; its fetchPayload should only raise ParticipantAuthError / NetworkUnavailable.`
+      };
+    }
+    const cached = this.cache.read();
+    const details = { participant: this.participantSlug, source };
+    if (cached !== null) {
+      details["cache_age_seconds"] = Math.round(cached.ageSeconds * 10) / 10;
+      details["cache_fetched_at"] = new Date(cached.fetchedAt * 1e3).toISOString().replace(/\.\d{3}Z$/, "+00:00");
+    }
+    if (source === "stale-cache") {
+      return {
+        status: "degraded",
+        reason: "serving stale cache (network unavailable or no token)",
+        details,
+        proposedFix: "Restore connectivity / refresh the token to update."
+      };
+    }
+    return { status: "ok", details };
+  }
+};
+
+// src/readers/hermes.ts
+var import_node_fs3 = require("fs");
+var import_node_os2 = require("os");
+var import_node_path2 = require("path");
+var import_l5 = require("@getbourdon/l5");
+var import_redaction = require("@getbourdon/redaction");
+var AGENT_ID = "hermes";
+var AGENT_TYPE = "code-assistant";
+var DISPLAY_NAME = "Hermes Agent";
+var ROLE_NARRATIVE = "General-purpose tool-calling assistant (Nous Research). Operates across CLI, TUI, and messaging gateways (Slack/Telegram/Discord/WhatsApp); runs terminal, file, web, and delegation toolsets. Carries durable cross-session memory and a curated skill library. Federates session + memory context, not vendor account.";
+var DEFAULT_SESSION_LIMIT = 100;
+var MEMORY_FILENAMES = ["memory.md", "user.md"];
+var DEFAULT_POLICY = (0, import_l5.makeVisibilityPolicy)({
+  default: import_l5.Visibility.TEAM,
+  private_tags: ["personal", "financial", "credential", "secret", "health", "family", "legal"],
+  team_tags: ["hermes-memory", "hermes-session", "hermes-project"]
+});
+var GENERIC_PROJECT_NAMES = /* @__PURE__ */ new Set([
+  "",
+  "root",
+  "home",
+  "tmp",
+  "temp",
+  "desktop",
+  "documents",
+  "downloads",
+  "src"
+]);
+function defaultNativePath(home) {
+  if (home) return (0, import_node_path2.join)(home, ".hermes");
+  const env = process.env.HERMES_HOME;
+  if (env) return env;
+  return (0, import_node_path2.join)((0, import_node_os2.homedir)(), ".hermes");
+}
+function isDir(p) {
+  try {
+    return (0, import_node_fs3.statSync)(p).isDirectory();
+  } catch {
+    return false;
+  }
+}
+function isFile(p) {
+  try {
+    return (0, import_node_fs3.statSync)(p).isFile();
+  } catch {
+    return false;
+  }
+}
+function bounded(value, limit = 240) {
+  const cleaned = (0, import_redaction.redactText)((value || "").replace(/\s+/g, " ").trim(), limit);
+  return cleaned.trim();
+}
+function projectKey(cwd) {
+  return projectKeyFromCwd(cwd, GENERIC_PROJECT_NAMES);
+}
+function collectSessionRows(stateDb, limit = DEFAULT_SESSION_LIMIT) {
+  if (!isFile(stateDb)) return [];
+  const conn = tryOpenReadonly(stateDb);
+  if (!conn) return [];
+  const out = [];
+  try {
+    if (!tableExists(conn, "sessions")) return [];
+    const cols = tableColumns(conn, "sessions");
+    const archivedClause = cols.has("archived") ? "WHERE COALESCE(archived, 0) = 0" : "";
+    const rows = conn.prepare(
+      `SELECT id, source, model, title, cwd, started_at, ended_at,
+                message_count, tool_call_count
+         FROM sessions
+         ${archivedClause}
+         ORDER BY started_at DESC
+         LIMIT ?`
+    ).all(limit);
+    for (const r of rows) {
+      const day = epochToIsoDate(r["started_at"]);
+      if (!day) continue;
+      out.push({
+        id: String(r["id"]),
+        source: String(r["source"] ?? "").toLowerCase(),
+        model: r["model"],
+        title: r["title"] ?? null,
+        cwd: r["cwd"] ?? null,
+        date: day,
+        messageCount: Number(r["message_count"] ?? 0) || 0,
+        toolCallCount: Number(r["tool_call_count"] ?? 0) || 0
+      });
+    }
+  } catch {
+  } finally {
+    conn.close();
+  }
+  return out;
+}
+function toolNamesForSession(conn, sessionId) {
+  if (!tableExists(conn, "messages")) return [];
+  try {
+    const rows = conn.prepare(
+      `SELECT DISTINCT tool_name FROM messages
+         WHERE session_id = ? AND tool_name IS NOT NULL AND tool_name != ''`
+    ).all(sessionId);
+    const names = /* @__PURE__ */ new Set();
+    for (const r of rows) {
+      if (r.tool_name) names.add(r.tool_name);
+    }
+    return [...names].sort();
+  } catch {
+    return [];
+  }
+}
+var BULLET_RE = /^\s*[-*]\s+(.*)$/;
+function parseMemoryFile(path) {
+  let text;
+  try {
+    text = (0, import_node_fs3.readFileSync)(path, "utf8");
+  } catch {
+    return [];
+  }
+  const entries = [];
+  for (const line of text.split(/\r?\n/)) {
+    const m = BULLET_RE.exec(line);
+    const candidate = m ? m[1] ?? "" : line.trim();
+    if (candidate && !candidate.startsWith("#")) entries.push(candidate);
+  }
+  return entries;
+}
+function collectMemoryEntries(home) {
+  const memDir = (0, import_node_path2.join)(home, "memories");
+  const result = [];
+  if (!isDir(memDir)) return result;
+  for (const fname of MEMORY_FILENAMES) {
+    const path = (0, import_node_path2.join)(memDir, fname);
+    if (isFile(path)) {
+      const entries = parseMemoryFile(path);
+      if (entries.length) {
+        const stem = fname.replace(/\.md$/, "");
+        result.push([stem, entries]);
+      }
+    }
+  }
+  return result;
+}
+function buildSession(record, toolNames) {
+  const key = projectKey(record.cwd);
+  const focus = [];
+  if (key) focus.push(key);
+  const keyActions = [];
+  if (record.title) keyActions.push(bounded(record.title, 160));
+  if (toolNames.length) {
+    keyActions.push("Tools: " + toolNames.slice(0, 8).join(", "));
+  } else if (record.toolCallCount) {
+    keyActions.push(`${record.toolCallCount} tool call(s)`);
+  }
+  return (0, import_l5.makeSession)({
+    date: record.date,
+    cwd: record.cwd || void 0,
+    project_focus: focus,
+    key_actions: keyActions,
+    visibility: import_l5.Visibility.TEAM
+  });
+}
+function memoryEntity(store, entry) {
+  const tag = store === "user" ? "hermes-user-memory" : "hermes-memory";
+  return (0, import_l5.makeEntity)({
+    name: bounded(entry, 80),
+    type: store === "user" ? "preference" : "fact",
+    summary: bounded(entry, 240),
+    tags: [tag],
+    visibility: import_l5.Visibility.TEAM
+  });
+}
+function projectEntities(records) {
+  const counts = /* @__PURE__ */ new Map();
+  for (const r of records) {
+    const key = projectKey(r.cwd);
+    if (key) counts.set(key, (counts.get(key) ?? 0) + 1);
+  }
+  const entities = [];
+  for (const [key, count] of counts) {
+    let last;
+    for (const r of records) {
+      if (projectKey(r.cwd) === key) {
+        if (last === void 0 || r.date > last) last = r.date;
+      }
+    }
+    entities.push(
+      (0, import_l5.makeEntity)({
+        name: friendlyLabel(key),
+        type: "project",
+        summary: `Workspace observed across ${count} Hermes session(s).`,
+        aliases: [key],
+        last_touched: last,
+        tags: ["hermes-project"],
+        visibility: import_l5.Visibility.TEAM
+      })
+    );
+  }
+  return entities;
+}
+var HermesParticipant = class {
+  agentId = AGENT_ID;
+  agentType = AGENT_TYPE;
+  displayName = DISPLAY_NAME;
+  nativePath;
+  home;
+  static defaultNativePath(home) {
+    return defaultNativePath(home);
+  }
+  /** `hermesHome` is the `.hermes` directory itself (matching the Python ctor). */
+  constructor(hermesHome) {
+    if (hermesHome) {
+      this.home = hermesHome;
+    } else {
+      const path = defaultNativePath();
+      this.home = isDir(path) ? path : null;
+    }
+    this.nativePath = this.home ?? (0, import_node_path2.join)((0, import_node_os2.homedir)(), ".hermes");
+  }
+  sources() {
+    const home = this.home;
+    const stateDb = home ? (0, import_node_path2.join)(home, "state.db") : null;
+    const memDir = home ? (0, import_node_path2.join)(home, "memories") : null;
+    const skillsDir = home ? (0, import_node_path2.join)(home, "skills") : null;
+    return {
+      hermes_home: home,
+      state_db: stateDb && isFile(stateDb) ? stateDb : null,
+      memories_dir: memDir && isDir(memDir) ? memDir : null,
+      skills_dir: skillsDir && isDir(skillsDir) ? skillsDir : null
+    };
+  }
+  discover() {
+    const sources = this.sources();
+    if (!Object.values(sources).some((v) => v)) {
+      throw new ParticipantDiscoveryError(
+        "No Hermes memory sources found. Expected ~/.hermes/ (set $HERMES_HOME to override)."
+      );
+    }
+    if (!sources["state_db"] && !sources["memories_dir"]) {
+      throw new ParticipantDiscoveryError(
+        `Hermes home '${this.nativePath}' exists but has no state.db or memories/ \u2014 nothing to federate yet.`
+      );
+    }
+    return {
+      path: this.nativePath,
+      version: "hermes-home-v1",
+      metadata: { sources }
+    };
+  }
+  exportSessions(since, limit = DEFAULT_SESSION_LIMIT) {
+    if (this.home === null) return [];
+    const stateDb = (0, import_node_path2.join)(this.home, "state.db");
+    const cutoff = since ? since.toISOString().slice(0, 10) : null;
+    const records = collectSessionRows(stateDb, limit);
+    if (!records.length) return [];
+    const conn = tryOpenReadonly(stateDb);
+    const out = [];
+    try {
+      for (const rec of records) {
+        if (cutoff && rec.date < cutoff) continue;
+        const tools = conn ? toolNamesForSession(conn, rec.id) : [];
+        out.push(buildSession(rec, tools));
+      }
+    } finally {
+      if (conn) conn.close();
+    }
+    return out;
+  }
+  exportL5(since) {
+    const store = this.discover();
+    const sources = store.metadata["sources"] ?? {};
+    const capabilities = Object.entries(sources).filter(([k, v]) => v && k !== "hermes_home").map(([k]) => k).sort();
+    const home = this.home;
+    const records = home ? collectSessionRows((0, import_node_path2.join)(home, "state.db"), DEFAULT_SESSION_LIMIT) : [];
+    const entities = projectEntities(records);
+    const seen = /* @__PURE__ */ new Set();
+    for (const e of entities) {
+      seen.add(`${e.type || "topic"}\0${e.name.toLowerCase()}`);
+    }
+    if (home) {
+      for (const [storeName, entries] of collectMemoryEntries(home)) {
+        for (const entry of entries) {
+          const ent = memoryEntity(storeName, entry);
+          const key = `${ent.type || "topic"}\0${ent.name.toLowerCase()}`;
+          if (seen.has(key)) continue;
+          seen.add(key);
+          entities.push(ent);
+        }
+      }
+    }
+    const visible = (0, import_l5.filterForFederation)(entities, DEFAULT_POLICY);
+    const sessions = this.exportSessions(
+      since ?? /* @__PURE__ */ new Date(0),
+      DEFAULT_SESSION_LIMIT
+    );
+    return (0, import_l5.makeManifest)({
+      spec_version: SPEC_VERSION,
+      agent: (0, import_l5.makeAgentInfo)({
+        id: this.agentId,
+        type: this.agentType,
+        role_narrative: ROLE_NARRATIVE,
+        spec_version_compat: CONTRACT_VERSION
+      }),
+      last_updated: (/* @__PURE__ */ new Date()).toISOString(),
+      capabilities,
+      recent_sessions: sessions,
+      known_entities: visible,
+      visibility_policy: DEFAULT_POLICY
+    });
+  }
+  healthCheck() {
+    const details = {
+      hermes_home: this.nativePath,
+      state_db: "missing",
+      memories_dir: "missing",
+      skills_dir: "missing"
+    };
+    try {
+      if (this.home === null) {
+        return {
+          status: "blocked",
+          reason: "~/.hermes/ not found \u2014 Hermes Agent not installed here",
+          details,
+          proposedFix: "Install Hermes Agent and run a session once, then `bourdon export-all`."
+        };
+      }
+      const sources = this.sources();
+      for (const key of ["state_db", "memories_dir", "skills_dir"]) {
+        if (sources[key]) details[key] = sources[key];
+      }
+      if (sources["state_db"]) {
+        const records = collectSessionRows((0, import_node_path2.join)(this.home, "state.db"), 1);
+        if (records.length) return { status: "ok", details };
+        return {
+          status: "degraded",
+          reason: "state.db present but no readable sessions yet",
+          details,
+          proposedFix: "Run at least one Hermes session, then `bourdon export-all`."
+        };
+      }
+      if (sources["memories_dir"]) {
+        return {
+          status: "degraded",
+          reason: "memories/ present but state.db missing \u2014 session history unavailable",
+          details
+        };
+      }
+      return {
+        status: "blocked",
+        reason: "Hermes home has neither state.db nor memories/",
+        details,
+        proposedFix: "Run a Hermes session to populate ~/.hermes/state.db."
+      };
+    } catch (err) {
+      return {
+        status: "degraded",
+        reason: `unexpected error: ${String(err)}`,
+        details
+      };
+    }
+  }
+};
+
+// src/readers/claude-code.ts
+var import_node_fs4 = require("fs");
+var import_node_os3 = require("os");
+var import_node_path3 = require("path");
+var import_yaml = require("yaml");
+var import_l52 = require("@getbourdon/l5");
+var import_redaction2 = require("@getbourdon/redaction");
+var AGENT_ID2 = "claude-code";
+var AGENT_TYPE2 = "code-assistant";
+var ROLE_NARRATIVE2 = "Agentic manager and code-assistant. Coordinates the RADLAB agent fleet, reviews PRs, and consults on architectural decisions. Capable of authoring code but typically reviews + delegates to specialised code-assistants like Codex for prime-code execution.";
+var DEFAULT_POLICY2 = (0, import_l52.makeVisibilityPolicy)({
+  default: import_l52.Visibility.PUBLIC,
+  private_tags: ["personal", "financial", "credential", "health", "family", "legal"],
+  team_tags: ["internal-roadmap"]
+});
+var PRIVATE_BY_DEFAULT_TYPES = /* @__PURE__ */ new Set([
+  "person",
+  "user",
+  "individual",
+  "contact",
+  "family-member",
+  "family_member"
+]);
+var MAX_SUMMARY_CHARS = 500;
+var MAX_OBSERVATIONS_IN_SUMMARY = 2;
+function isDir2(p) {
+  try {
+    return (0, import_node_fs4.statSync)(p).isDirectory();
+  } catch {
+    return false;
+  }
+}
+function isFile2(p) {
+  try {
+    return (0, import_node_fs4.statSync)(p).isFile();
+  } catch {
+    return false;
+  }
+}
+function resolveClaudeBrainPath() {
+  const envOverride = process.env.CLAUDE_BRAIN;
+  if (envOverride && isDir2(envOverride)) return envOverride;
+  const homeCandidate = (0, import_node_path3.join)(homeDir(), "claude-brain");
+  if (isDir2(homeCandidate)) return homeCandidate;
+  const cwdCandidate = (0, import_node_path3.join)(process.cwd(), "claude-brain");
+  if (isDir2(cwdCandidate)) return cwdCandidate;
+  return null;
+}
+function homeDir() {
+  try {
+    return (0, import_node_os3.homedir)();
+  } catch {
+    return process.env.HOME || process.env.USERPROFILE || ".";
+  }
+}
+function resolveAutoMemoryPath() {
+  try {
+    const base = (0, import_node_path3.join)(homeDir(), ".claude", "projects");
+    if (!isDir2(base)) return null;
+    for (const child of (0, import_node_fs4.readdirSync)(base)) {
+      const memMarker = (0, import_node_path3.join)(base, child, "memory", "MEMORY.md");
+      if (isFile2(memMarker)) return (0, import_node_path3.join)(base, child, "memory");
+    }
+  } catch {
+    return null;
+  }
+  return null;
+}
+function resolveKnowledgeGraphPath() {
+  const candidate = (0, import_node_path3.join)(homeDir(), "claude-memory", "memory.jsonl");
+  return isFile2(candidate) ? candidate : null;
+}
+function isPrivateType(entityType) {
+  if (!entityType) return false;
+  const normalized = entityType.split("/").pop()?.trim().toLowerCase() ?? "";
+  return PRIVATE_BY_DEFAULT_TYPES.has(normalized);
+}
+var FRONTMATTER_OPEN = "---\n";
+var FRONTMATTER_CLOSE = "\n---\n";
+function parseFrontmatter(text) {
+  if (!text.startsWith(FRONTMATTER_OPEN)) return { frontmatter: {}, body: text };
+  const end = text.indexOf(FRONTMATTER_CLOSE, FRONTMATTER_OPEN.length);
+  if (end === -1) return { frontmatter: {}, body: text };
+  const fmText = text.slice(FRONTMATTER_OPEN.length, end);
+  const body = text.slice(end + FRONTMATTER_CLOSE.length);
+  let parsed;
+  try {
+    parsed = (0, import_yaml.parse)(fmText);
+  } catch {
+    return { frontmatter: {}, body: text };
+  }
+  const fm = typeof parsed === "object" && parsed !== null && !Array.isArray(parsed) ? parsed : {};
+  return { frontmatter: fm, body };
+}
+var H1_RE = /^#[ \t]+(.+?)[ \t]*$/m;
+var STATUS_SECTION_RE = /^##[ \t]+(?:Current[ \t]+)?Status[^\n]*$/im;
+var STATUS_DATE_RE = /\b(\d{4}-\d{2}-\d{2})\b/;
+var TITLE_SPLIT_RE = /\s*[-—–:]+\s+/;
+function extractH1Title(body) {
+  const match = H1_RE.exec(body);
+  if (!match) return null;
+  const title = (match[1] ?? "").trim();
+  const head = title.split(TITLE_SPLIT_RE)[0] ?? title;
+  return head.trim();
+}
+function extractFirstParagraph(body, maxChars = MAX_SUMMARY_CHARS) {
+  const paragraph = [];
+  for (const line of body.split(/\r?\n/)) {
+    const stripped = line.trim();
+    if (!stripped) {
+      if (paragraph.length) break;
+      continue;
+    }
+    if (stripped.startsWith("#")) continue;
+    paragraph.push(stripped);
+    if (paragraph.reduce((acc, s) => acc + s.length + 1, 0) > maxChars) break;
+  }
+  return paragraph.join(" ").trim().slice(0, maxChars).trim();
+}
+function extractStatusTag(body) {
+  const match = STATUS_SECTION_RE.exec(body);
+  if (!match) return [];
+  const region = body.slice(match.index, match.index + 400).toLowerCase();
+  const tags = [];
+  for (const keyword of ["archived", "canceled", "cancelled", "active", "shipped", "blocked"]) {
+    if (region.includes(keyword)) tags.push(keyword.replace("cancelled", "canceled"));
+  }
+  return [...new Set(tags)];
+}
+var END_OF_LIFE_TAGS = /* @__PURE__ */ new Set(["archived", "canceled"]);
+function extractStatusDate(body) {
+  const match = STATUS_SECTION_RE.exec(body);
+  if (!match) return null;
+  const region = body.slice(match.index, match.index + 400);
+  const dateMatch = STATUS_DATE_RE.exec(region);
+  return dateMatch ? dateMatch[1] ?? null : null;
+}
+function parseProjectOverview(overviewPath) {
+  let text;
+  try {
+    text = (0, import_node_fs4.readFileSync)(overviewPath, "utf8");
+  } catch {
+    return null;
+  }
+  const { body } = parseFrontmatter(text);
+  const title = extractH1Title(body) || (0, import_node_path3.basename)((0, import_node_path3.join)(overviewPath, ".."));
+  const summary = extractFirstParagraph(body);
+  const tags = extractStatusTag(body);
+  let validTo = null;
+  if (tags.some((t) => END_OF_LIFE_TAGS.has(t))) {
+    validTo = extractStatusDate(body);
+    if (validTo === null) {
+      try {
+        const mtime = (0, import_node_fs4.statSync)(overviewPath).mtime;
+        validTo = mtime.toISOString().slice(0, 10);
+      } catch {
+        validTo = null;
+      }
+    }
+  }
+  return (0, import_l52.makeEntity)({
+    name: title,
+    type: "project",
+    summary: summary || void 0,
+    tags,
+    valid_to: validTo ?? void 0
+  });
+}
+function parseProjectsDir(brainPath) {
+  const projectsDir = (0, import_node_path3.join)(brainPath, "PROJECTS");
+  if (!isDir2(projectsDir)) return [];
+  const entities = [];
+  for (const name of (0, import_node_fs4.readdirSync)(projectsDir).sort()) {
+    const projectDir = (0, import_node_path3.join)(projectsDir, name);
+    if (!isDir2(projectDir)) continue;
+    const overview = (0, import_node_path3.join)(projectDir, "OVERVIEW.md");
+    if (!isFile2(overview)) continue;
+    const entity = parseProjectOverview(overview);
+    if (entity) entities.push(entity);
+  }
+  return entities;
+}
+var LOG_FILENAME_RE = /^(\d{4}-\d{2}-\d{2})(?:-(\w+?))?(?:-.*)?\.md$/;
+function parseLogFile(logPath) {
+  const m = LOG_FILENAME_RE.exec((0, import_node_path3.basename)(logPath));
+  if (!m) return null;
+  const sessionDate = m[1] ?? "";
+  let text;
+  try {
+    text = (0, import_node_fs4.readFileSync)(logPath, "utf8");
+  } catch {
+    return null;
+  }
+  const { body } = parseFrontmatter(text);
+  const headline = extractFirstParagraph(body, 250);
+  return (0, import_l52.makeSession)({
+    date: sessionDate,
+    key_actions: headline ? [headline] : [],
+    files_touched: [`LOG/${(0, import_node_path3.basename)(logPath)}`]
+  });
+}
+function parseLogsDir(brainPath, since, limit = 100) {
+  const logDir = (0, import_node_path3.join)(brainPath, "LOG");
+  if (!isDir2(logDir)) return [];
+  const candidates = [];
+  for (const fname of (0, import_node_fs4.readdirSync)(logDir)) {
+    if (!fname.endsWith(".md")) continue;
+    const m = LOG_FILENAME_RE.exec(fname);
+    if (!m) continue;
+    const d = m[1] ?? "";
+    if (since) {
+      if (d < since.toISOString().slice(0, 10)) continue;
+    }
+    candidates.push([d, (0, import_node_path3.join)(logDir, fname)]);
+  }
+  candidates.sort((a, b) => a[0] < b[0] ? 1 : a[0] > b[0] ? -1 : 0);
+  const sessions = [];
+  for (const [, logFile] of candidates.slice(0, limit)) {
+    const session = parseLogFile(logFile);
+    if (session) sessions.push(session);
+  }
+  return sessions;
+}
+function parseAutoMemoryEntity(mdPath) {
+  let text;
+  try {
+    text = (0, import_node_fs4.readFileSync)(mdPath, "utf8");
+  } catch {
+    return null;
+  }
+  const { frontmatter, body } = parseFrontmatter(text);
+  const name = frontmatter["name"] || extractH1Title(body) || (0, import_node_path3.basename)(mdPath).replace(/\.md$/, "");
+  const entityType = frontmatter["type"];
+  const summaryRaw = frontmatter["description"] || extractFirstParagraph(body);
+  const rawTags = frontmatter["tags"];
+  const tags = Array.isArray(rawTags) ? rawTags.map((t) => String(t)) : [];
+  const visibility = isPrivateType(entityType) ? import_l52.Visibility.PRIVATE : void 0;
+  return (0, import_l52.makeEntity)({
+    name: String(name),
+    type: entityType ? String(entityType) : void 0,
+    summary: summaryRaw ? String(summaryRaw).slice(0, MAX_SUMMARY_CHARS).trim() : void 0,
+    tags,
+    visibility
+  });
+}
+function parseAutoMemory(memoryPath) {
+  if (!isDir2(memoryPath)) return [];
+  const entities = [];
+  for (const fname of (0, import_node_fs4.readdirSync)(memoryPath).sort()) {
+    if (!fname.endsWith(".md") || fname === "MEMORY.md") continue;
+    const entity = parseAutoMemoryEntity((0, import_node_path3.join)(memoryPath, fname));
+    if (entity) entities.push(entity);
+  }
+  return entities;
+}
+function graphEntityToBourdonEntity(record) {
+  const name = record["name"];
+  if (!name || typeof name !== "string") return null;
+  const entityTypeSlug = record["entityType"] || "";
+  const normalizedType = entityTypeSlug ? entityTypeSlug.split("/").pop() ?? null : null;
+  const observations = Array.isArray(record["observations"]) ? record["observations"] : [];
+  const safeObs = [];
+  for (const obs of observations.slice(0, MAX_OBSERVATIONS_IN_SUMMARY)) {
+    if (typeof obs !== "string") continue;
+    safeObs.push((0, import_redaction2.containsSecret)(obs) ? "[redacted -- contains credential-like content]" : obs);
+  }
+  const joined = safeObs.join(" | ").slice(0, MAX_SUMMARY_CHARS).trim();
+  const summary = joined || void 0;
+  const hasCredObs = observations.some((o) => typeof o === "string" && (0, import_redaction2.containsSecret)(o));
+  const visibility = isPrivateType(entityTypeSlug) || hasCredObs ? import_l52.Visibility.PRIVATE : void 0;
+  const tags = normalizedType && normalizedType !== name.toLowerCase() ? [normalizedType] : [];
+  return (0, import_l52.makeEntity)({
+    name,
+    type: normalizedType ?? void 0,
+    summary,
+    tags,
+    visibility
+  });
+}
+function parseKnowledgeGraph(graphPath) {
+  if (!isFile2(graphPath)) return [];
+  let raw;
+  try {
+    raw = (0, import_node_fs4.readFileSync)(graphPath, "utf8");
+  } catch {
+    return [];
+  }
+  const entities = [];
+  for (const lineRaw of raw.split(/\r?\n/)) {
+    const line = lineRaw.trim();
+    if (!line) continue;
+    let record;
+    try {
+      record = JSON.parse(line);
+    } catch {
+      continue;
+    }
+    if (typeof record !== "object" || record === null) continue;
+    const rec = record;
+    if (rec["type"] !== "entity") continue;
+    const entity = graphEntityToBourdonEntity(rec);
+    if (entity) entities.push(entity);
+  }
+  return entities;
+}
+var VIS_ORDER = {
+  [import_l52.Visibility.PRIVATE]: 0,
+  [import_l52.Visibility.TEAM]: 1,
+  [import_l52.Visibility.PUBLIC]: 2,
+  none: 3
+};
+function visRank(v) {
+  return v == null ? VIS_ORDER["none"] : VIS_ORDER[v];
+}
+function mergeEntities(into, other) {
+  if (!into.type && other.type) into.type = other.type;
+  if (other.summary && other.summary.trim() && other.summary.length > (into.summary?.length ?? 0)) {
+    into.summary = other.summary;
+  }
+  into.tags = [.../* @__PURE__ */ new Set([...into.tags ?? [], ...other.tags ?? []])];
+  if (visRank(other.visibility) < visRank(into.visibility)) {
+    into.visibility = other.visibility;
+  }
+  return into;
+}
+function dedupeEntities(sourceLists) {
+  const byKey = /* @__PURE__ */ new Map();
+  for (const source of sourceLists) {
+    for (const entity of source) {
+      const key = entity.name.trim().toLowerCase();
+      if (!key) continue;
+      const existing = byKey.get(key);
+      if (existing) {
+        mergeEntities(existing, entity);
+      } else {
+        byKey.set(
+          key,
+          (0, import_l52.makeEntity)({
+            name: entity.name,
+            type: entity.type,
+            aliases: [...entity.aliases ?? []],
+            summary: entity.summary,
+            last_touched: entity.last_touched,
+            tags: [...entity.tags ?? []],
+            visibility: entity.visibility
+            // valid_from / valid_to intentionally dropped (oracle behavior).
+          })
+        );
+      }
+    }
+  }
+  return [...byKey.values()].sort((a, b) => {
+    const an = a.name.toLowerCase();
+    const bn = b.name.toLowerCase();
+    return an < bn ? -1 : an > bn ? 1 : 0;
+  });
+}
+var ClaudeCodeParticipant = class {
+  agentId = AGENT_ID2;
+  agentType = AGENT_TYPE2;
+  nativePath;
+  /** Public so a hermetic test can seed the discovered sources directly (path
+   * RESOLUTION is not the parity contract — only the export output shape is). */
+  brainPath;
+  autoMemoryPath;
+  knowledgeGraphPath;
+  static defaultNativePath(home) {
+    return (0, import_node_path3.join)(home ?? homeDir(), ".claude");
+  }
+  constructor() {
+    this.nativePath = (0, import_node_path3.join)(homeDir(), "claude-brain");
+    this.brainPath = resolveClaudeBrainPath();
+    this.autoMemoryPath = resolveAutoMemoryPath();
+    this.knowledgeGraphPath = resolveKnowledgeGraphPath();
+  }
+  discover() {
+    const sources = {
+      claude_brain: this.brainPath,
+      auto_memory: this.autoMemoryPath,
+      knowledge_graph: this.knowledgeGraphPath
+    };
+    if (!Object.values(sources).some((v) => v)) {
+      throw new ParticipantDiscoveryError(
+        "No Claude Code memory sources found. Expected one of: ~/claude-brain/, ~/.claude/projects/*/memory/, ~/claude-memory/memory.jsonl."
+      );
+    }
+    return {
+      path: this.nativePath,
+      version: "claude-code-memory-v1",
+      metadata: { sources }
+    };
+  }
+  exportL5(since) {
+    const store = this.discover();
+    const sources = store.metadata["sources"];
+    const capabilities = Object.entries(sources).filter(([, v]) => v).map(([k]) => k).sort();
+    const autoMemoryEntities = this.autoMemoryPath ? parseAutoMemory(this.autoMemoryPath) : [];
+    const graphEntities = this.knowledgeGraphPath ? parseKnowledgeGraph(this.knowledgeGraphPath) : [];
+    const projectEntities2 = this.brainPath ? parseProjectsDir(this.brainPath) : [];
+    const allEntities = dedupeEntities([autoMemoryEntities, graphEntities, projectEntities2]);
+    const visibleEntities = (0, import_l52.filterForFederation)(allEntities, DEFAULT_POLICY2);
+    const sessions = this.brainPath ? parseLogsDir(this.brainPath, since) : [];
+    return (0, import_l52.makeManifest)({
+      spec_version: SPEC_VERSION,
+      agent: (0, import_l52.makeAgentInfo)({
+        id: this.agentId,
+        type: this.agentType,
+        instance: (0, import_node_os3.hostname)() || "unknown",
+        spec_version_compat: `>=${SPEC_VERSION}`,
+        role_narrative: ROLE_NARRATIVE2
+      }),
+      last_updated: (/* @__PURE__ */ new Date()).toISOString(),
+      capabilities,
+      recent_sessions: sessions,
+      known_entities: visibleEntities,
+      visibility_policy: DEFAULT_POLICY2
+    });
+  }
+  exportSessions(since, limit = 100) {
+    if (!this.brainPath) return [];
+    return parseLogsDir(this.brainPath, since, limit);
+  }
+  healthCheck() {
+    try {
+      const present = [this.brainPath, this.autoMemoryPath, this.knowledgeGraphPath].filter(
+        (p) => p !== null
+      ).length;
+      const details = {
+        claude_brain: this.brainPath ?? "missing",
+        auto_memory: this.autoMemoryPath ?? "missing",
+        knowledge_graph: this.knowledgeGraphPath ?? "missing"
+      };
+      if (present === 3) return { status: "ok", details };
+      if (present === 0) {
+        return {
+          status: "blocked",
+          reason: "No Claude Code memory sources found on this machine",
+          details,
+          proposedFix: "Run `bourdon setup` to wire the SessionEnd hook and bootstrap ~/agent-library/, then open Claude Code once to populate ~/.claude/projects/."
+        };
+      }
+      return {
+        status: "degraded",
+        reason: `${present}/3 Claude Code memory sources found`,
+        details,
+        proposedFix: "Run `bourdon setup` to (re-)wire missing sources, or set the CLAUDE_BRAIN env var to point at your claude-brain checkout."
+      };
+    } catch (err) {
+      return {
+        status: "degraded",
+        reason: `unexpected error: ${String(err)}`,
+        details: {}
+      };
+    }
+  }
+};
+
+// src/readers/github-copilot.ts
+var import_node_child_process = require("child_process");
+var import_l53 = require("@getbourdon/l5");
+var import_redaction3 = require("@getbourdon/redaction");
+var AGENT_ID3 = "github-copilot";
+var AGENT_TYPE3 = "code-assistant";
+var PARTICIPANT_SLUG = "github-copilot";
+var DISPLAY_NAME2 = "GitHub Copilot (cloud)";
+var ROLE_NARRATIVE3 = "Cloud-side GitHub Copilot: PR review and @copilot-authored comments/suggestions that live on github.com, not on the user's machine. Federated via the GitHub REST API rather than a local artifact.";
+var GITHUB_API_ROOT = "https://api.github.com";
+var DEFAULT_POLICY3 = (0, import_l53.makeVisibilityPolicy)({
+  default: import_l53.Visibility.TEAM,
+  private_tags: ["personal", "financial", "credential", "secret"],
+  team_tags: ["github-copilot", "pull-request"]
+});
+function ghTokenProvider() {
+  for (const varName of ["GITHUB_TOKEN", "GH_TOKEN"]) {
+    const val = process.env[varName];
+    if (val) return val;
+  }
+  try {
+    const out = (0, import_node_child_process.execFileSync)("gh", ["auth", "token"], {
+      encoding: "utf8",
+      timeout: 5e3,
+      stdio: ["ignore", "pipe", "ignore"]
+    });
+    const token = out.trim();
+    if (token) return token;
+  } catch {
+  }
+  return null;
+}
+function githubGet(path, token, timeoutSec = 10) {
+  const url = path.startsWith("http") ? path : `${GITHUB_API_ROOT}${path}`;
+  let resp;
+  try {
+    resp = curlGet(url, token, timeoutSec);
+  } catch (err) {
+    throw new NetworkUnavailable(`GitHub API unreachable: ${String(err)}`);
+  }
+  const remaining = resp.headers["x-ratelimit-remaining"];
+  if (resp.status === 429 || resp.status === 403 && String(remaining) === "0") {
+    throw new NetworkUnavailable(`GitHub API ${resp.status}: rate-limited`);
+  }
+  if (resp.status === 401 || resp.status === 403) {
+    throw new ParticipantAuthError(`GitHub API ${resp.status}: token invalid or lacks scope`);
+  }
+  if (resp.status >= 500) {
+    throw new NetworkUnavailable(`GitHub API ${resp.status}`);
+  }
+  if (resp.status >= 400) {
+    throw new NetworkUnavailable(`GitHub API ${resp.status}`);
+  }
+  try {
+    return JSON.parse(resp.body);
+  } catch (err) {
+    throw new NetworkUnavailable(`GitHub API returned a non-JSON body: ${String(err)}`);
+  }
+}
+function curlGet(url, token, timeoutSec) {
+  const raw = (0, import_node_child_process.execFileSync)(
+    "curl",
+    [
+      "-sS",
+      "-D",
+      "-",
+      "-o",
+      "-",
+      "--max-time",
+      String(timeoutSec),
+      "-H",
+      `Authorization: Bearer ${token}`,
+      "-H",
+      "Accept: application/vnd.github+json",
+      "-H",
+      "X-GitHub-Api-Version: 2022-11-28",
+      "-H",
+      "User-Agent: bourdon-github-copilot-participant",
+      "-w",
+      "\n__BOURDON_STATUS__%{http_code}",
+      url
+    ],
+    { encoding: "utf8", timeout: (timeoutSec + 2) * 1e3, maxBuffer: 8 * 1024 * 1024 }
+  );
+  const statusMatch = /\n__BOURDON_STATUS__(\d+)$/.exec(raw);
+  const status = statusMatch ? Number(statusMatch[1]) : 0;
+  const withoutStatus = statusMatch ? raw.slice(0, statusMatch.index) : raw;
+  const headerBodySplit = withoutStatus.indexOf("\r\n\r\n");
+  let headerBlock = "";
+  let body = withoutStatus;
+  if (headerBodySplit >= 0) {
+    headerBlock = withoutStatus.slice(0, headerBodySplit);
+    body = withoutStatus.slice(headerBodySplit + 4);
+  } else {
+    const lfSplit = withoutStatus.indexOf("\n\n");
+    if (lfSplit >= 0) {
+      headerBlock = withoutStatus.slice(0, lfSplit);
+      body = withoutStatus.slice(lfSplit + 2);
+    }
+  }
+  const headers = {};
+  for (const line of headerBlock.split(/\r?\n/)) {
+    const idx = line.indexOf(":");
+    if (idx > 0) {
+      headers[line.slice(0, idx).trim().toLowerCase()] = line.slice(idx + 1).trim();
+    }
+  }
+  return { status, headers, body };
+}
+var GitHubCopilotParticipant = class extends NetworkParticipant {
+  participantSlug = PARTICIPANT_SLUG;
+  agentId = AGENT_ID3;
+  agentType = AGENT_TYPE3;
+  nativePath = GITHUB_API_ROOT;
+  displayName = DISPLAY_NAME2;
+  maxResults;
+  constructor(opts = {}) {
+    super({
+      authProvider: opts.authProvider ?? ghTokenProvider,
+      cacheRoot: opts.cacheRoot
+    });
+    this.maxResults = opts.maxResults ?? 50;
+  }
+  static defaultNativePath() {
+    return GITHUB_API_ROOT;
+  }
+  fetchPayload(token) {
+    const me = githubGet("/user", token);
+    const login = me && typeof me === "object" ? me["login"] : null;
+    const q = "is:pr involves:@me commenter:copilot";
+    const encoded = encodeURIComponent(q);
+    const search = githubGet(
+      `/search/issues?q=${encoded}&sort=updated&per_page=${this.maxResults}`,
+      token
+    );
+    const items = search && typeof search === "object" ? search["items"] ?? [] : [];
+    return {
+      fetched_user: login ?? null,
+      fetched_at: (/* @__PURE__ */ new Date()).toISOString(),
+      items
+    };
+  }
+  payloadToL5(payload) {
+    const items = Array.isArray(payload["items"]) ? payload["items"] : [];
+    const sessions = [];
+    const entities = /* @__PURE__ */ new Map();
+    for (const item of items) {
+      if (typeof item !== "object" || item === null) continue;
+      const it = item;
+      const repo = repoFromItem(it);
+      const title = (0, import_redaction3.redactText)(String(it["title"] ?? ""), 160);
+      const number = it["number"];
+      const updated = isoDate(it["updated_at"]);
+      const focus = repo ? [repo] : [];
+      sessions.push(
+        (0, import_l53.makeSession)({
+          date: updated || "1970-01-01",
+          cwd: repo ? `github.com/${repo}` : void 0,
+          project_focus: focus,
+          key_actions: number != null ? [`PR #${String(number)}: ${title}`] : [title],
+          visibility: import_l53.Visibility.TEAM
+        })
+      );
+      if (repo && !entities.has(repo)) {
+        entities.set(
+          repo,
+          (0, import_l53.makeEntity)({
+            name: repo,
+            type: "repository",
+            summary: "GitHub repo with Copilot PR activity.",
+            aliases: repo.includes("/") ? [repo.split("/").pop() ?? ""] : [],
+            last_touched: updated ?? void 0,
+            tags: ["github-copilot", "pull-request"],
+            visibility: import_l53.Visibility.TEAM
+          })
+        );
+      }
+    }
+    sessions.sort((a, b) => a.date < b.date ? 1 : a.date > b.date ? -1 : 0);
+    return (0, import_l53.makeManifest)({
+      spec_version: SPEC_VERSION,
+      agent: (0, import_l53.makeAgentInfo)({
+        id: this.agentId,
+        type: this.agentType,
+        role_narrative: ROLE_NARRATIVE3,
+        instance: payload["fetched_user"] ?? void 0
+      }),
+      last_updated: (/* @__PURE__ */ new Date()).toISOString(),
+      capabilities: ["github-search", "pull-request-comments"],
+      recent_sessions: sessions.slice(0, this.maxResults),
+      known_entities: [...entities.values()],
+      visibility_policy: DEFAULT_POLICY3
+    });
+  }
+};
+function repoFromItem(item) {
+  const repoUrl = item["repository_url"];
+  if (typeof repoUrl === "string" && repoUrl.includes("/repos/")) {
+    return repoUrl.split("/repos/")[1] ?? null;
+  }
+  return null;
+}
+function isoDate(value) {
+  if (typeof value === "string" && value.length >= 10) return value.slice(0, 10);
+  return null;
+}
+
+// src/readers/cursor.ts
+var import_node_fs5 = require("fs");
+var import_node_os4 = require("os");
+var import_node_path4 = require("path");
+var import_l54 = require("@getbourdon/l5");
+var import_redaction4 = require("@getbourdon/redaction");
+var AGENT_ID4 = "cursor";
+var AGENT_TYPE4 = "code-assistant";
+var ROLE_NARRATIVE4 = "AI-first IDE. Bourdon reads the SQLite-backed composer/workspace state to surface recent sessions and project entities to other agents.";
+var DEFAULT_POLICY4 = (0, import_l54.makeVisibilityPolicy)({
+  default: import_l54.Visibility.TEAM,
+  private_tags: ["personal", "credential", "secret"],
+  team_tags: ["cursor", "workspace", "sqlite"]
+});
+var TOPIC_MIN_MENTIONS = 3;
+function homeDir2() {
+  try {
+    return (0, import_node_os4.homedir)();
+  } catch {
+    return process.env.HOME || process.env.USERPROFILE || ".";
+  }
+}
+function isDir3(p) {
+  try {
+    return (0, import_node_fs5.statSync)(p).isDirectory();
+  } catch {
+    return false;
+  }
+}
+function isFile3(p) {
+  try {
+    return (0, import_node_fs5.statSync)(p).isFile();
+  } catch {
+    return false;
+  }
+}
+function scrubText(value, limit = 256) {
+  return (0, import_redaction4.redactText)(value, limit);
+}
+function defaultCursorDir() {
+  const env = process.env.CURSOR_DIR;
+  if (env) return env;
+  switch (process.platform) {
+    case "darwin":
+      return (0, import_node_path4.join)(homeDir2(), "Library", "Application Support", "Cursor");
+    case "linux":
+      return (0, import_node_path4.join)(homeDir2(), ".config", "Cursor");
+    case "win32": {
+      const appdata = process.env.APPDATA;
+      return appdata ? (0, import_node_path4.join)(appdata, "Cursor") : null;
+    }
+    default:
+      return null;
+  }
+}
+function iterStateDbs(root) {
+  const candidates = [
+    (0, import_node_path4.join)(root, "state.vscdb"),
+    (0, import_node_path4.join)(root, "User", "globalStorage", "state.vscdb")
+  ];
+  const workspaceStorage = (0, import_node_path4.join)(root, "User", "workspaceStorage");
+  if (isDir3(workspaceStorage)) {
+    let children = [];
+    try {
+      children = (0, import_node_fs5.readdirSync)(workspaceStorage).sort();
+    } catch {
+      children = [];
+    }
+    for (const child of children) {
+      candidates.push((0, import_node_path4.join)(workspaceStorage, child, "state.vscdb"));
+    }
+  }
+  return candidates.filter((p) => isFile3(p));
+}
+function readItemTable(dbPath) {
+  const records = [];
+  let malformed = 0;
+  const conn = tryOpenReadonly(dbPath);
+  if (!conn) return { records, malformed };
+  let rows;
+  try {
+    if (!tableExists(conn, "ItemTable")) return { records, malformed };
+    rows = conn.prepare("SELECT key, value FROM ItemTable").all();
+  } catch {
+    return { records, malformed };
+  } finally {
+    conn.close();
+  }
+  for (const row of rows) {
+    const raw = row.value;
+    let text = null;
+    if (typeof raw === "string") text = raw;
+    else if (raw instanceof Uint8Array) text = Buffer.from(raw).toString("utf8");
+    if (text === null) {
+      malformed += 1;
+      continue;
+    }
+    let value;
+    try {
+      value = JSON.parse(text);
+    } catch {
+      malformed += 1;
+      continue;
+    }
+    records.push([String(row.key), value]);
+  }
+  return { records, malformed };
+}
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function firstString(value, keys) {
+  for (const key of keys) {
+    const candidate = value[key];
+    if (typeof candidate === "string" && candidate.trim()) return candidate.trim();
+  }
+  return "";
+}
+function firstMessageText(messages) {
+  if (!Array.isArray(messages)) return "";
+  for (const message of messages) {
+    if (!isRecord(message)) continue;
+    const content = message["content"] || message["text"];
+    if (typeof content === "string" && content.trim()) return content.trim();
+  }
+  return "";
+}
+function looksLikeComposerRecord(key, value) {
+  const loweredKey = key.toLowerCase();
+  if (loweredKey.includes("composer") || loweredKey.includes("aichat") || loweredKey.includes("chat")) {
+    return true;
+  }
+  if (isRecord(value)) {
+    const joinedKeys = Object.keys(value).join(" ").toLowerCase();
+    return joinedKeys.includes("message") && (joinedKeys.includes("workspace") || joinedKeys.includes("file"));
+  }
+  return false;
+}
+function parseDate(value) {
+  if (typeof value === "string") {
+    const normalized = value.replaceAll("Z", "+00:00");
+    const m = /^(\d{4}-\d{2}-\d{2})([T ].*)?$/.exec(normalized);
+    if (!m) return "";
+    const datePart = m[1] ?? "";
+    const dayProbe = /* @__PURE__ */ new Date(`${datePart}T00:00:00Z`);
+    if (Number.isNaN(dayProbe.getTime()) || dayProbe.toISOString().slice(0, 10) !== datePart) {
+      return "";
+    }
+    const probe = new Date(m[2] ? normalized.replace(" ", "T") : `${datePart}T00:00:00`);
+    if (Number.isNaN(probe.getTime())) return "";
+    return datePart;
+  }
+  if (typeof value === "number" && Number.isFinite(value)) {
+    const timestamp = value > 1e10 ? value / 1e3 : value;
+    const dt = new Date(timestamp * 1e3);
+    if (Number.isNaN(dt.getTime())) return "";
+    return dt.toISOString().slice(0, 10);
+  }
+  return "";
+}
+function dateFromRecord(value) {
+  for (const key of ["createdAt", "timestamp", "updatedAt", "lastUpdatedAt", "time"]) {
+    const parsed = parseDate(value[key]);
+    if (parsed) return parsed;
+  }
+  return (/* @__PURE__ */ new Date()).toISOString().slice(0, 10);
+}
+function stringsFromList(values) {
+  const strings = [];
+  for (const item of values) {
+    if (typeof item === "string" && item.trim()) {
+      strings.push(item.trim());
+    } else if (isRecord(item)) {
+      const path = firstString(item, ["path", "file", "uri", "relativePath"]);
+      if (path) strings.push(path);
+    }
+  }
+  return strings;
+}
+function dedupe(values) {
+  const seen = /* @__PURE__ */ new Set();
+  const out = [];
+  for (const value of values) {
+    if (!seen.has(value)) {
+      seen.add(value);
+      out.push(value);
+    }
+  }
+  return out;
+}
+function extractFiles(value) {
+  const files = [];
+  for (const key of ["files", "filePaths", "filesTouched", "references"]) {
+    const candidate = value[key];
+    if (Array.isArray(candidate)) files.push(...stringsFromList(candidate));
+  }
+  const messages = value["messages"];
+  if (Array.isArray(messages)) {
+    for (const message of messages) {
+      if (isRecord(message)) files.push(...extractFiles(message));
+    }
+  }
+  return dedupe(files);
+}
+function recordToSession(key, value) {
+  if (!looksLikeComposerRecord(key, value)) return null;
+  if (!isRecord(value)) return null;
+  let cwd = firstString(value, ["workspacePath", "workspace", "cwd", "folder", "rootPath"]);
+  if (!cwd && isRecord(value["workspace"])) {
+    cwd = firstString(value["workspace"], ["path", "folder", "cwd"]);
+  }
+  if (!cwd) cwd = "";
+  let action = firstString(value, ["title", "text", "prompt", "summary", "name"]);
+  if (!action) action = firstMessageText(value["messages"]);
+  if (!action) return null;
+  return {
+    date: dateFromRecord(value),
+    cwd,
+    keyActions: [scrubText(action)],
+    filesTouched: extractFiles(value)
+  };
+}
+function projectName(cwd) {
+  if (!cwd) return "";
+  const name = (0, import_node_path4.basename)(cwd).trim();
+  return name && name !== "." && name !== "/" ? name : "";
+}
+var STRIP_CHARS = /* @__PURE__ */ new Set([
+  ".",
+  ",",
+  ";",
+  ":",
+  "!",
+  "?",
+  '"',
+  "'",
+  "`",
+  "(",
+  ")",
+  "[",
+  "]",
+  "{",
+  "}",
+  "#",
+  "-",
+  "/"
+]);
+function stripChars(token) {
+  let start = 0;
+  let end = token.length;
+  while (start < end && STRIP_CHARS.has(token[start])) start += 1;
+  while (end > start && STRIP_CHARS.has(token[end - 1])) end -= 1;
+  return token.slice(start, end);
+}
+var TOPIC_STOPWORDS = /* @__PURE__ */ new Set([
+  "the",
+  "and",
+  "for",
+  "with",
+  "this",
+  "that",
+  "from",
+  "have",
+  "will",
+  "are",
+  "was",
+  "been",
+  "not",
+  "but",
+  "all",
+  "can",
+  "has",
+  "its",
+  "add",
+  "use",
+  "set",
+  "get",
+  "new",
+  "fix",
+  "run",
+  "now",
+  "also",
+  "into",
+  "make",
+  "just",
+  "like",
+  "need",
+  "want",
+  "work",
+  "code",
+  "file",
+  "test",
+  "data",
+  "type",
+  "should",
+  "would",
+  "could"
+]);
+function addTopicEntities(sessions, entities) {
+  const wordCounts = /* @__PURE__ */ new Map();
+  const wordLatest = /* @__PURE__ */ new Map();
+  for (const session of sessions) {
+    for (const action of session.keyActions) {
+      const words = /* @__PURE__ */ new Set();
+      for (const token of action.toLowerCase().split(/\s+/)) {
+        const cleaned = stripChars(token);
+        if (cleaned.length >= 4 && !TOPIC_STOPWORDS.has(cleaned) && new RegExp("^\\p{L}+$", "u").test(cleaned)) {
+          words.add(cleaned);
+        }
+      }
+      for (const word of words) {
+        wordCounts.set(word, (wordCounts.get(word) ?? 0) + 1);
+        if (session.date) {
+          const prev = wordLatest.get(word);
+          if (prev === void 0 || session.date > prev) wordLatest.set(word, session.date);
+        }
+      }
+    }
+  }
+  for (const [word, count] of wordCounts) {
+    if (count >= TOPIC_MIN_MENTIONS && !entities.has(word)) {
+      entities.set(word, {
+        name: word,
+        entityType: "topic",
+        aliases: [],
+        summary: `Recurring topic across ${count} Cursor sessions.`,
+        tags: ["cursor", "topic", "inferred"],
+        lastUpdated: wordLatest.get(word) ?? ""
+      });
+    }
+  }
+}
+function extractCursorMemories(cursorDir = null) {
+  const root = cursorDir ?? defaultCursorDir();
+  if (root === null || !isDir3(root)) {
+    return { sessions: [], entities: [], databasesScanned: [], malformedRecords: 0 };
+  }
+  const sessions = [];
+  const entitiesByName = /* @__PURE__ */ new Map();
+  const databasesScanned = [];
+  let malformedRecords = 0;
+  const projectLatest = /* @__PURE__ */ new Map();
+  for (const dbPath of iterStateDbs(root)) {
+    databasesScanned.push(dbPath);
+    const { records, malformed } = readItemTable(dbPath);
+    malformedRecords += malformed;
+    for (const [key, value] of records) {
+      const parsedSession = recordToSession(key, value);
+      if (parsedSession === null) continue;
+      sessions.push(parsedSession);
+      const name = projectName(parsedSession.cwd);
+      if (!name) continue;
+      const prev = projectLatest.get(name) ?? "";
+      if (!projectLatest.has(name) || parsedSession.date && parsedSession.date > prev) {
+        projectLatest.set(name, parsedSession.date);
+      }
+      const existing = entitiesByName.get(name);
+      const aliasSet = new Set(parsedSession.cwd ? [parsedSession.cwd] : []);
+      if (existing) {
+        for (const a of existing.aliases) aliasSet.add(a);
+      }
+      entitiesByName.set(name, {
+        name: scrubText(name, 120),
+        entityType: "project",
+        aliases: [...aliasSet].sort(),
+        summary: scrubText(`Cursor workspace inferred from ${parsedSession.cwd}.`),
+        tags: ["cursor", "workspace", "sqlite"],
+        lastUpdated: projectLatest.get(name) ?? ""
+      });
+    }
+  }
+  addTopicEntities(sessions, entitiesByName);
+  sessions.sort((a, b) => a.date < b.date ? 1 : a.date > b.date ? -1 : 0);
+  return {
+    sessions,
+    entities: [...entitiesByName.values()],
+    databasesScanned,
+    malformedRecords
+  };
+}
+function readShortIndex(path) {
+  if (!isFile3(path)) return [];
+  let payload;
+  try {
+    const raw = (0, import_node_fs5.readFileSync)(path, "utf8").replace(/^\uFEFF/, "");
+    payload = JSON.parse(raw);
+  } catch {
+    return [];
+  }
+  if (!isRecord(payload)) return [];
+  const entries = payload["entries"];
+  if (!Array.isArray(entries)) return [];
+  return entries.filter(
+    (e) => isRecord(e) && Boolean(e["topic_key"])
+  );
+}
+function shortIndexToEntities(workspaceRoot, _cursorDir) {
+  const paths = [];
+  if (workspaceRoot) {
+    paths.push((0, import_node_path4.join)(workspaceRoot, ".cursor", "memory", "short-index.json"));
+  }
+  const cursorHome = process.env.CURSOR_DIR ? process.env.CURSOR_DIR : null;
+  const homeBase = cursorHome ?? (0, import_node_path4.join)(homeDir2(), ".cursor");
+  paths.push((0, import_node_path4.join)(homeBase, "memory", "short-index.json"));
+  const merged = /* @__PURE__ */ new Map();
+  for (const path of paths) {
+    for (const entry of readShortIndex(path)) {
+      const key = String(entry["topic_key"]).trim().toLowerCase();
+      merged.set(key, entry);
+    }
+  }
+  const entities = [];
+  for (const entry of merged.values()) {
+    const nameRaw = entry["topic_name"] !== void 0 ? entry["topic_name"] : entry["topic_key"] ?? "";
+    const name = String(nameRaw).trim();
+    if (!name) continue;
+    const aliasesRaw = "triggers" in entry ? entry["triggers"] : "aliases" in entry ? entry["aliases"] : [];
+    const aliases = Array.isArray(aliasesRaw) ? aliasesRaw.map((a) => String(a).trim()).filter((s) => s.length > 0) : [];
+    const summary = String(entry["summary"] ?? "").trim();
+    const tagsRaw = entry["tags"] ?? [];
+    const tags = Array.isArray(tagsRaw) ? tagsRaw.map((t) => String(t).trim()).filter((s) => s.length > 0) : [];
+    tags.push("short-index");
+    const access = String(entry["access_level"] ?? "team").trim().toLowerCase();
+    const visibility = access === "private" ? import_l54.Visibility.PRIVATE : access === "public" ? import_l54.Visibility.PUBLIC : import_l54.Visibility.TEAM;
+    const lastTouched = String(entry["last_updated"] ?? "");
+    entities.push(
+      (0, import_l54.makeEntity)({
+        name,
+        type: "topic",
+        aliases,
+        summary: summary || void 0,
+        tags,
+        last_touched: lastTouched || void 0,
+        visibility
+      })
+    );
+  }
+  return entities;
+}
+function toSession(raw) {
+  return (0, import_l54.makeSession)({
+    date: raw.date || "",
+    cwd: raw.cwd || void 0,
+    project_focus: [],
+    key_actions: [...raw.keyActions],
+    files_touched: [...raw.filesTouched]
+  });
+}
+function toEntity(raw) {
+  return (0, import_l54.makeEntity)({
+    name: raw.name,
+    type: raw.entityType || void 0,
+    aliases: [...raw.aliases],
+    summary: raw.summary || void 0,
+    tags: [...raw.tags],
+    last_touched: raw.lastUpdated || void 0
+  });
+}
+function nowIsoSeconds() {
+  return (/* @__PURE__ */ new Date()).toISOString().replace(/\.\d{3}Z$/, "+00:00");
+}
+var CursorParticipant = class {
+  agentId = AGENT_ID4;
+  agentType = AGENT_TYPE4;
+  cursorDir;
+  workspaceRoot;
+  policy = DEFAULT_POLICY4;
+  /**
+   * Conventional Cursor config dir (`~/.cursor`) used by the setup wizard. The
+   * wizard probes `~/.cursor` for presence; the SQLite workspace state that
+   * `exportL5` actually reads lives at {@link defaultCursorDir}. Detection and
+   * extraction intentionally use different anchors.
+   */
+  static defaultNativePath(home) {
+    return (0, import_node_path4.join)(home ?? homeDir2(), ".cursor");
+  }
+  constructor(cursorDir, workspaceRoot) {
+    this.cursorDir = cursorDir ?? null;
+    this.workspaceRoot = workspaceRoot ?? null;
+  }
+  get nativePath() {
+    const path = this.cursorDir ?? defaultCursorDir();
+    return path ?? "";
+  }
+  discover() {
+    const path = this.cursorDir ?? defaultCursorDir();
+    if (path === null || !isDir3(path)) {
+      throw new ParticipantDiscoveryError(
+        `Cursor data directory not found at ${path === null ? "None" : `'${path}'`}. Pass an explicit cursor_dir to CursorParticipant() if Cursor stores its state somewhere non-standard.`
+      );
+    }
+    const dbs = iterStateDbs(path);
+    const dbDetails = dbs.map((db) => {
+      let size;
+      try {
+        size = (0, import_node_fs5.statSync)(db).size;
+      } catch {
+        size = -1;
+      }
+      return { path: db, size_bytes: size };
+    });
+    return {
+      path,
+      version: "unknown",
+      metadata: {
+        platform_default: defaultCursorDir() ?? "None",
+        databases_found: dbs.length,
+        databases: dbDetails
+      }
+    };
+  }
+  exportSessions(since, limit = 100) {
+    const memories = this.extract();
+    const out = [];
+    const sinceIso = since ? since.toISOString().slice(0, 10) : null;
+    for (const raw of memories.sessions) {
+      if (sinceIso && raw.date && raw.date < sinceIso) continue;
+      out.push(toSession(raw));
+      if (out.length >= limit) break;
+    }
+    return out;
+  }
+  exportL5(since) {
+    const memories = this.extract();
+    let sessions = memories.sessions.map(toSession);
+    if (since) {
+      const sinceIso = since.toISOString().slice(0, 10);
+      sessions = sessions.filter((s) => !s.date || s.date >= sinceIso);
+    }
+    const entities = memories.entities.map(toEntity);
+    const shortIndexEntities = shortIndexToEntities(this.workspaceRoot, this.cursorDir);
+    const seenNames = new Set(entities.map((e) => e.name.toLowerCase()));
+    for (const si of shortIndexEntities) {
+      const key = si.name.toLowerCase();
+      if (!seenNames.has(key)) {
+        entities.push(si);
+        seenNames.add(key);
+      }
+    }
+    const visibleEntities = (0, import_l54.filterForFederation)(entities, this.policy);
+    return (0, import_l54.makeManifest)({
+      spec_version: SPEC_VERSION,
+      agent: (0, import_l54.makeAgentInfo)({
+        id: AGENT_ID4,
+        type: AGENT_TYPE4,
+        role_narrative: ROLE_NARRATIVE4,
+        spec_version_compat: SPEC_VERSION
+      }),
+      last_updated: nowIsoSeconds(),
+      capabilities: ["composer-history", "workspace-state"],
+      recent_sessions: sessions,
+      known_entities: visibleEntities,
+      visibility_policy: this.policy
+    });
+  }
+  healthCheck() {
+    const path = this.cursorDir ?? defaultCursorDir();
+    if (path === null) {
+      return {
+        status: "blocked",
+        reason: "Cursor data directory not resolvable on this platform.",
+        details: {},
+        proposedFix: "Install Cursor (https://cursor.sh) and open it once. Set CURSOR_DIR if Cursor stores state outside the default location."
+      };
+    }
+    if (!isDir3(path)) {
+      return {
+        status: "blocked",
+        reason: `Cursor data directory not present at ${path}.`,
+        details: { expected_path: path },
+        proposedFix: "Install Cursor and open it once to create the data directory, or set CURSOR_DIR to the actual location."
+      };
+    }
+    let memories;
+    try {
+      memories = this.extract();
+    } catch (err) {
+      return {
+        status: "degraded",
+        reason: "Cursor data directory present but extraction failed.",
+        details: { error: String(err) },
+        proposedFix: "Close Cursor (its SQLite stores may be locked) then re-run `bourdon cursor export`. If extraction still fails, file an issue with the error above."
+      };
+    }
+    if (memories.databasesScanned.length === 0) {
+      return {
+        status: "degraded",
+        reason: "No Cursor SQLite stores found under the data directory.",
+        details: { path },
+        proposedFix: "Open Cursor and use it for at least one chat session, then re-run `bourdon cursor export`."
+      };
+    }
+    return {
+      status: "ok",
+      details: {
+        databases_scanned: memories.databasesScanned.length,
+        sessions_extracted: memories.sessions.length,
+        entities_extracted: memories.entities.length,
+        malformed_records: memories.malformedRecords
+      }
+    };
+  }
+  extract() {
+    return extractCursorMemories(this.cursorDir);
+  }
+};
+
+// src/readers/copilot.ts
+var import_node_fs6 = require("fs");
+var import_node_os5 = require("os");
+var import_node_path5 = require("path");
+var import_yaml2 = require("yaml");
+var import_l55 = require("@getbourdon/l5");
+var import_redaction5 = require("@getbourdon/redaction");
+var AGENT_ID5 = "copilot";
+var AGENT_TYPE5 = "code-assistant";
+var DISPLAY_NAME3 = "GitHub Copilot";
+var ROLE_NARRATIVE5 = "Inline completion and chat assistant present across every IDE the team uses. Works alongside the human at the keystroke level -- the ambient layer that recognises what is being typed before a full turn is even formed. Bourdon gives Copilot cross-session entity awareness it would otherwise lack entirely.";
+var CONVENTION_DIR_NAME = ".copilot-bourdon";
+var MEMORY_FILENAME = "memory.md";
+var FRONTMATTER_OPEN2 = "---\n";
+var FRONTMATTER_CLOSE2 = "\n---\n";
+var DEFAULT_POLICY5 = (0, import_l55.makeVisibilityPolicy)({
+  default: import_l55.Visibility.TEAM,
+  private_tags: ["personal", "financial", "credential", "health", "family", "legal"],
+  team_tags: ["copilot-memory", "workspace", "copilot"]
+});
+var logger = {
+  warn(msg) {
+    console.warn(`[bourdon.participants] ${msg}`);
+  }
+};
+function homeDir3() {
+  try {
+    return (0, import_node_os5.homedir)();
+  } catch {
+    return process.env.HOME || process.env.USERPROFILE || ".";
+  }
+}
+function isDir4(p) {
+  try {
+    return (0, import_node_fs6.statSync)(p).isDirectory();
+  } catch {
+    return false;
+  }
+}
+function isFile4(p) {
+  try {
+    return (0, import_node_fs6.statSync)(p).isFile();
+  } catch {
+    return false;
+  }
+}
+function defaultCopilotBourdonDir() {
+  const env = process.env.COPILOT_BOURDON_HOME;
+  if (env) return env;
+  return (0, import_node_path5.join)(homeDir3(), CONVENTION_DIR_NAME);
+}
+function defaultCopilotMemoryPath(copilotDir) {
+  return (0, import_node_path5.join)(copilotDir || defaultCopilotBourdonDir(), MEMORY_FILENAME);
+}
+function coerceStr(v) {
+  if (v instanceof Date) return v.toISOString().slice(0, 10);
+  return String(v);
+}
+function strOrUndef(v) {
+  const s = coerceStr(v || "");
+  return s || void 0;
+}
+function strList(v) {
+  if (!Array.isArray(v)) return [];
+  return v.filter((x) => typeof x === "string" && x.trim() !== "");
+}
+function isRecord2(v) {
+  return typeof v === "object" && v !== null && !Array.isArray(v);
+}
+function asArray(v) {
+  return Array.isArray(v) ? v : [];
+}
+function parseFrontmatter2(text, source) {
+  if (!text.startsWith(FRONTMATTER_OPEN2)) return {};
+  const end = text.indexOf(FRONTMATTER_CLOSE2, FRONTMATTER_OPEN2.length);
+  if (end === -1) return {};
+  const fmText = text.slice(FRONTMATTER_OPEN2.length, end);
+  let parsed;
+  try {
+    parsed = (0, import_yaml2.parse)(fmText);
+  } catch (err) {
+    const where = source ? ` in ${source}` : "";
+    const detail = String(err).replace(/\n/g, " ").slice(0, 200);
+    logger.warn(
+      `CopilotParticipant: malformed YAML frontmatter${where}; treating as no-frontmatter (${detail})`
+    );
+    return {};
+  }
+  return isRecord2(parsed) ? parsed : {};
+}
+function readMemoryFile(path) {
+  if (!isFile4(path)) return {};
+  let text;
+  try {
+    text = (0, import_node_fs6.readFileSync)(path, "utf8");
+  } catch (err) {
+    logger.warn(`CopilotParticipant: cannot read ${path}: ${String(err)}`);
+    return {};
+  }
+  return parseFrontmatter2(text, path);
+}
+function buildEntity(raw) {
+  if (!isRecord2(raw)) return null;
+  const name = raw["name"];
+  if (typeof name !== "string" || name.trim() === "") return null;
+  const summaryRaw = raw["summary"] || "";
+  const summary = summaryRaw ? (0, import_redaction5.redactText)(coerceStr(summaryRaw)) : void 0;
+  return (0, import_l55.makeEntity)({
+    name: name.trim(),
+    type: strOrUndef(raw["type"]),
+    aliases: strList(raw["aliases"]),
+    summary,
+    last_touched: strOrUndef(raw["last_touched"]),
+    tags: strList(raw["tags"]),
+    valid_from: strOrUndef(raw["valid_from"]),
+    valid_to: strOrUndef(raw["valid_to"])
+  });
+}
+function buildSession2(raw) {
+  if (!isRecord2(raw)) return null;
+  const dateVal = raw["date"];
+  if (!dateVal) return null;
+  const dateStr = coerceStr(dateVal).slice(0, 10);
+  return (0, import_l55.makeSession)({
+    date: dateStr,
+    cwd: strOrUndef(raw["cwd"]),
+    project_focus: strList(raw["project_focus"]),
+    key_actions: strList(raw["key_actions"]),
+    files_touched: strList(raw["files_touched"])
+  });
+}
+var CopilotParticipant = class {
+  agentId = AGENT_ID5;
+  agentType = AGENT_TYPE5;
+  displayName = DISPLAY_NAME3;
+  nativePath;
+  /** Conventional `~/.copilot-bourdon` dir used by the setup wizard's detection. */
+  static defaultNativePath(home) {
+    if (home !== void 0) return (0, import_node_path5.join)(home, CONVENTION_DIR_NAME);
+    return defaultCopilotBourdonDir();
+  }
+  copilotDir;
+  constructor(copilotDir) {
+    this.copilotDir = copilotDir ?? null;
+    this.nativePath = this.copilotDir || defaultCopilotBourdonDir();
+  }
+  discover() {
+    const path = this.copilotDir || defaultCopilotBourdonDir();
+    if (!isDir4(path)) {
+      throw new ParticipantDiscoveryError(
+        `Copilot convention directory not found at '${path}'. Run \`bourdon copilot init\` to create it with a starter template, or create ~/.copilot-bourdon/memory.md manually.`
+      );
+    }
+    const memPath = (0, import_node_path5.join)(path, MEMORY_FILENAME);
+    return {
+      path,
+      version: "convention-v1",
+      metadata: {
+        memory_file: memPath,
+        memory_file_present: isFile4(memPath)
+      }
+    };
+  }
+  exportSessions(since, limit = 100) {
+    const data = this.read();
+    const sinceIso = since ? since.toISOString().slice(0, 10) : null;
+    const sessions = [];
+    for (const raw of asArray(data["sessions"])) {
+      const session = buildSession2(raw);
+      if (session === null) continue;
+      if (sinceIso && session.date && session.date < sinceIso) continue;
+      sessions.push(session);
+      if (sessions.length >= limit) break;
+    }
+    return sessions;
+  }
+  exportL5(since) {
+    const data = this.read();
+    const entities = [];
+    for (const raw of asArray(data["entities"])) {
+      const entity = buildEntity(raw);
+      if (entity !== null) entities.push(entity);
+    }
+    const visibleEntities = (0, import_l55.filterForFederation)(entities, DEFAULT_POLICY5);
+    const sinceIso = since ? since.toISOString().slice(0, 10) : null;
+    const sessions = [];
+    for (const raw of asArray(data["sessions"])) {
+      const session = buildSession2(raw);
+      if (session === null) continue;
+      if (sinceIso && session.date && session.date < sinceIso) continue;
+      sessions.push(session);
+    }
+    return (0, import_l55.makeManifest)({
+      spec_version: SPEC_VERSION,
+      agent: (0, import_l55.makeAgentInfo)({
+        id: AGENT_ID5,
+        type: AGENT_TYPE5,
+        instance: (0, import_node_os5.hostname)() || "unknown",
+        spec_version_compat: `>=${SPEC_VERSION}`,
+        role_narrative: ROLE_NARRATIVE5
+      }),
+      last_updated: (/* @__PURE__ */ new Date()).toISOString(),
+      capabilities: ["inline-completion", "chat", "pr-review", "convention-memory"],
+      recent_sessions: sessions,
+      known_entities: visibleEntities,
+      visibility_policy: DEFAULT_POLICY5
+    });
+  }
+  healthCheck() {
+    const path = this.copilotDir || defaultCopilotBourdonDir();
+    if (!isDir4(path)) {
+      return {
+        status: "blocked",
+        reason: `Convention directory ${path} not found. Run \`bourdon copilot init\` to create it.`,
+        details: { expected_path: path },
+        proposedFix: "Run `bourdon copilot init` to create the convention directory."
+      };
+    }
+    const memPath = (0, import_node_path5.join)(path, MEMORY_FILENAME);
+    if (!isFile4(memPath)) {
+      return {
+        status: "degraded",
+        reason: `Memory file ${memPath} not found. Run \`bourdon copilot init\` to write a starter template.`,
+        details: { expected_memory_file: memPath },
+        proposedFix: "Run `bourdon copilot init` to write the starter memory.md template."
+      };
+    }
+    let data;
+    try {
+      data = this.read();
+    } catch (err) {
+      logger.warn(`CopilotParticipant health_check failed: ${String(err)}`);
+      return {
+        status: "degraded",
+        reason: "Memory file present but could not be parsed.",
+        details: { error: String(err) },
+        proposedFix: `Inspect ${memPath} for malformed YAML front-matter. The opening and closing \`---\` fences must wrap a valid YAML block. See docs/agent-integration-status.md for the schema.`
+      };
+    }
+    return {
+      status: "ok",
+      details: {
+        memory_file: memPath,
+        entity_count: asArray(data["entities"]).length,
+        session_count: asArray(data["sessions"]).length
+      }
+    };
+  }
+  // -- Internal ---------------------------------------------------------------
+  read() {
+    return readMemoryFile(defaultCopilotMemoryPath(this.copilotDir));
+  }
+};
+
+// src/readers/copilot-cli.ts
+var import_node_fs7 = require("fs");
+var import_node_os6 = require("os");
+var import_node_path6 = require("path");
+var import_l56 = require("@getbourdon/l5");
+var import_redaction6 = require("@getbourdon/redaction");
+var AGENT_ID6 = "copilot-cli";
+var AGENT_TYPE6 = "code-assistant";
+var DISPLAY_NAME4 = "GitHub Copilot CLI";
+var ROLE_NARRATIVE6 = "Terminal-native Copilot agent with full filesystem + tool access. Runs multi-turn sessions with checkpoints, file edits, and git operations. The CLI surface has the deepest tool integration of all Copilot surfaces \u2014 shell, grep, edit, git \u2014 and persists rich session history locally in SQLite.";
+var DEFAULT_POLICY6 = (0, import_l56.makeVisibilityPolicy)({
+  default: import_l56.Visibility.TEAM,
+  private_tags: ["personal", "financial", "credential", "health", "family", "legal"],
+  team_tags: ["copilot-cli", "copilot", "terminal", "workspace"]
+});
+var DB_FILENAME = "session-store.db";
+var COPILOT_DIR_NAME = ".copilot";
+var MAX_SUMMARY_CHARS2 = 260;
+var MAX_KEY_ACTIONS = 6;
+var MAX_KEY_ACTION_CHARS = 280;
+function defaultCopilotCliDir() {
+  const env = process.env.COPILOT_CLI_HOME;
+  if (env) return env;
+  return (0, import_node_path6.join)((0, import_node_os6.homedir)(), COPILOT_DIR_NAME);
+}
+function defaultCopilotCliDbPath(copilotDir) {
+  return (0, import_node_path6.join)(copilotDir ?? defaultCopilotCliDir(), DB_FILENAME);
+}
+function isFile5(p) {
+  try {
+    return (0, import_node_fs7.statSync)(p).isFile();
+  } catch {
+    return false;
+  }
+}
+function isDir5(p) {
+  try {
+    return (0, import_node_fs7.statSync)(p).isDirectory();
+  } catch {
+    return false;
+  }
+}
+function safeNativeMemoryText(value, limit = 180) {
+  return (0, import_redaction6.redactText)(value, limit);
+}
+function bounded2(value, limit) {
+  const normalized = value.split(/\s+/).filter(Boolean).join(" ");
+  if (normalized.length <= limit) return normalized;
+  return normalized.slice(0, limit - 1).replace(/\s+$/, "") + "\u2026";
+}
+function queryDb(db, sql, params = []) {
+  try {
+    return db.prepare(sql).all(...params);
+  } catch {
+    return [];
+  }
+}
+function extractSessions(db, since) {
+  let sql = "SELECT id, cwd, repository, branch, summary, created_at, updated_at FROM sessions";
+  const params = [];
+  if (since) {
+    sql += " WHERE created_at >= ?";
+    params.push(since);
+  }
+  sql += " ORDER BY created_at DESC LIMIT 200";
+  return queryDb(db, sql, params);
+}
+function extractSessionFiles(db, sessionId) {
+  const rows = queryDb(
+    db,
+    "SELECT file_path FROM session_files WHERE session_id = ? LIMIT 20",
+    [sessionId]
+  );
+  const out = [];
+  for (const r of rows) {
+    const fp = r["file_path"];
+    if (fp) out.push(String(fp));
+  }
+  return out;
+}
+function extractSessionRefs(db, sessionId) {
+  const rows = queryDb(
+    db,
+    "SELECT ref_type, ref_value FROM session_refs WHERE session_id = ?",
+    [sessionId]
+  );
+  return rows.map((r) => ({
+    ref_type: String(r["ref_type"] ?? ""),
+    ref_value: String(r["ref_value"] ?? "")
+  }));
+}
+function extractCheckpoints(db, sessionId) {
+  return queryDb(
+    db,
+    "SELECT checkpoint_number, title, overview FROM checkpoints WHERE session_id = ? ORDER BY checkpoint_number",
+    [sessionId]
+  );
+}
+function extractDynamicContext(db) {
+  return queryDb(
+    db,
+    "SELECT repository, branch, src, name, description, content, read_count, count FROM dynamic_context_items ORDER BY count DESC LIMIT 50"
+  );
+}
+function extractTurnCount(db, sessionId) {
+  const rows = queryDb(db, "SELECT COUNT(*) as cnt FROM turns WHERE session_id = ?", [sessionId]);
+  const first = rows[0];
+  return first ? Number(first["cnt"] ?? 0) || 0 : 0;
+}
+function sessionToBourdon(raw, files, refs, checkpoints, turnCount) {
+  const created = raw["created_at"] ? String(raw["created_at"]) : "";
+  const dateStr = created ? created.slice(0, 10) : "";
+  const keyActions = [];
+  if (raw["summary"]) {
+    keyActions.push(bounded2(safeNativeMemoryText(String(raw["summary"])), MAX_KEY_ACTION_CHARS));
+  }
+  for (const cp of checkpoints.slice(0, 3)) {
+    if (cp["title"]) {
+      keyActions.push(
+        bounded2(`checkpoint: ${safeNativeMemoryText(String(cp["title"]))}`, MAX_KEY_ACTION_CHARS)
+      );
+    }
+  }
+  if (turnCount) {
+    keyActions.push(`turns: ${turnCount}`);
+  }
+  for (const ref of refs.slice(0, 3)) {
+    const refLabel = `${ref.ref_type}: ${ref.ref_value}`;
+    keyActions.push(bounded2(refLabel, MAX_KEY_ACTION_CHARS));
+  }
+  const projectFocus = [];
+  if (raw["repository"]) projectFocus.push(String(raw["repository"]));
+  return (0, import_l56.makeSession)({
+    date: dateStr,
+    cwd: raw["cwd"] ? String(raw["cwd"]) : void 0,
+    project_focus: projectFocus,
+    key_actions: keyActions.slice(0, MAX_KEY_ACTIONS),
+    files_touched: files.slice(0, 20),
+    visibility: import_l56.Visibility.TEAM
+  });
+}
+function entitiesFromSessionsAndContext(sessions, dynamicContext) {
+  const entities = /* @__PURE__ */ new Map();
+  for (const raw of sessions) {
+    const repo = raw["repository"] ? String(raw["repository"]) : "";
+    if (repo && !entities.has(repo)) {
+      const created = raw["created_at"] ? String(raw["created_at"]) : "";
+      const lastTouched = created.slice(0, 10) || null;
+      entities.set(
+        repo,
+        (0, import_l56.makeEntity)({
+          name: repo,
+          type: "project",
+          summary: "Repository worked on via Copilot CLI.",
+          last_touched: lastTouched ?? void 0,
+          tags: ["copilot-cli", "project"],
+          visibility: import_l56.Visibility.TEAM
+        })
+      );
+    }
+  }
+  for (const ctx of dynamicContext) {
+    const name = ctx["name"] ? String(ctx["name"]) : "";
+    if (!name || entities.has(name)) continue;
+    const desc = ctx["description"] ? String(ctx["description"]) : "";
+    const content = ctx["content"] ? String(ctx["content"]) : "";
+    let summaryText = desc || content;
+    if (summaryText) {
+      summaryText = bounded2(safeNativeMemoryText(summaryText), MAX_SUMMARY_CHARS2);
+    }
+    entities.set(
+      name,
+      (0, import_l56.makeEntity)({
+        name,
+        type: "dynamic-context",
+        summary: summaryText || void 0,
+        last_touched: void 0,
+        tags: ["copilot-cli", "dynamic-context", ctx["src"] ? String(ctx["src"]) : "unknown"],
+        visibility: import_l56.Visibility.TEAM
+      })
+    );
+  }
+  return [...entities.values()];
+}
+function toUtcIso(d) {
+  return d.toISOString().replace(/\.\d{3}Z$/, "+00:00").replace(/Z$/, "+00:00");
+}
+var CopilotCliParticipant = class {
+  agentId = AGENT_ID6;
+  agentType = AGENT_TYPE6;
+  displayName = DISPLAY_NAME4;
+  nativePath;
+  copilotDir;
+  /** Conventional `~/.copilot` dir used by the setup wizard's detection. */
+  static defaultNativePath(home) {
+    if (home) return (0, import_node_path6.join)(home, COPILOT_DIR_NAME);
+    return defaultCopilotCliDir();
+  }
+  constructor(copilotDir) {
+    this.copilotDir = copilotDir ?? null;
+    this.nativePath = this.copilotDir ?? defaultCopilotCliDir();
+  }
+  // -- Protocol surface -------------------------------------------------------
+  discover() {
+    const dbPath = defaultCopilotCliDbPath(this.copilotDir);
+    if (!isFile5(dbPath)) {
+      throw new ParticipantDiscoveryError(
+        `Copilot CLI session-store.db not found at ${dbPath}. The Copilot CLI agent must be run at least once to create this database.`
+      );
+    }
+    let dbSize = 0;
+    try {
+      dbSize = (0, import_node_fs7.statSync)(dbPath).size;
+    } catch {
+      dbSize = 0;
+    }
+    return {
+      path: (0, import_node_path6.dirname)(dbPath),
+      version: "schema-v4",
+      metadata: { db_path: dbPath, db_size_bytes: dbSize }
+    };
+  }
+  exportSessions(since, limit = 100) {
+    const dbPath = defaultCopilotCliDbPath(this.copilotDir);
+    const db = tryOpenReadonly(dbPath);
+    if (!db) return [];
+    try {
+      const sinceIso = since ? toUtcIso(since) : null;
+      const rawSessions = extractSessions(db, sinceIso);
+      const sessions = [];
+      for (const raw of rawSessions.slice(0, limit)) {
+        const sid = String(raw["id"]);
+        const files = extractSessionFiles(db, sid);
+        const refs = extractSessionRefs(db, sid);
+        const checkpoints = extractCheckpoints(db, sid);
+        const turnCount = extractTurnCount(db, sid);
+        sessions.push(sessionToBourdon(raw, files, refs, checkpoints, turnCount));
+      }
+      return sessions;
+    } finally {
+      db.close();
+    }
+  }
+  exportL5(since) {
+    const dbPath = defaultCopilotCliDbPath(this.copilotDir);
+    const db = tryOpenReadonly(dbPath);
+    if (!db) return this.emptyManifest();
+    try {
+      const sinceIso = since ? toUtcIso(since) : null;
+      const rawSessions = extractSessions(db, sinceIso);
+      const dynamicContext = extractDynamicContext(db);
+      const sessions = [];
+      for (const raw of rawSessions.slice(0, 100)) {
+        const sid = String(raw["id"]);
+        const files = extractSessionFiles(db, sid);
+        const refs = extractSessionRefs(db, sid);
+        const checkpoints = extractCheckpoints(db, sid);
+        const turnCount = extractTurnCount(db, sid);
+        sessions.push(sessionToBourdon(raw, files, refs, checkpoints, turnCount));
+      }
+      const entities = entitiesFromSessionsAndContext(rawSessions, dynamicContext);
+      const visibleEntities = (0, import_l56.filterForFederation)(entities, DEFAULT_POLICY6);
+      return (0, import_l56.makeManifest)({
+        spec_version: SPEC_VERSION,
+        agent: (0, import_l56.makeAgentInfo)({
+          id: AGENT_ID6,
+          type: AGENT_TYPE6,
+          instance: (0, import_node_os6.hostname)() || "unknown",
+          spec_version_compat: `>=${SPEC_VERSION}`,
+          role_narrative: ROLE_NARRATIVE6
+        }),
+        last_updated: (/* @__PURE__ */ new Date()).toISOString(),
+        capabilities: [
+          "terminal-agent",
+          "file-edit",
+          "shell-execution",
+          "git-operations",
+          "multi-turn-sessions",
+          "checkpoints",
+          "dynamic-context"
+        ],
+        recent_sessions: sessions,
+        known_entities: visibleEntities,
+        visibility_policy: DEFAULT_POLICY6
+      });
+    } finally {
+      db.close();
+    }
+  }
+  healthCheck() {
+    try {
+      const copilotDir = this.copilotDir ?? defaultCopilotCliDir();
+      if (!isDir5(copilotDir)) {
+        return {
+          status: "blocked",
+          reason: `Copilot CLI directory not found at ${copilotDir}.`,
+          details: { expected_path: copilotDir },
+          proposedFix: "Run the Copilot CLI agent (`copilot` or `gh copilot`) at least once to create the session store."
+        };
+      }
+      const dbPath = defaultCopilotCliDbPath(copilotDir);
+      if (!isFile5(dbPath)) {
+        return {
+          status: "blocked",
+          reason: `session-store.db not found at ${dbPath}.`,
+          details: { expected_db: dbPath },
+          proposedFix: "Run the Copilot CLI agent at least once. The session-store.db is created on first use."
+        };
+      }
+      const db = tryOpenReadonly(dbPath);
+      if (!db) {
+        return {
+          status: "degraded",
+          reason: "Cannot copy session-store.db for reading.",
+          details: { db_path: dbPath },
+          proposedFix: "Check file permissions on the session-store.db."
+        };
+      }
+      try {
+        const rawSessions = extractSessions(db);
+        const dynamicContext = extractDynamicContext(db);
+        const totalTurns = queryDb(db, "SELECT COUNT(*) as cnt FROM turns");
+        const first = totalTurns[0];
+        let dbSize = 0;
+        try {
+          dbSize = (0, import_node_fs7.statSync)(dbPath).size;
+        } catch {
+          dbSize = 0;
+        }
+        return {
+          status: "ok",
+          details: {
+            db_path: dbPath,
+            db_size_bytes: dbSize,
+            session_count: rawSessions.length,
+            total_turns: first ? Number(first["cnt"] ?? 0) || 0 : 0,
+            dynamic_context_items: dynamicContext.length
+          }
+        };
+      } finally {
+        db.close();
+      }
+    } catch (err) {
+      return {
+        status: "degraded",
+        reason: `unexpected error: ${String(err)}`,
+        details: {}
+      };
+    }
+  }
+  // -- Internal ---------------------------------------------------------------
+  emptyManifest() {
+    return (0, import_l56.makeManifest)({
+      spec_version: SPEC_VERSION,
+      agent: (0, import_l56.makeAgentInfo)({
+        id: AGENT_ID6,
+        type: AGENT_TYPE6,
+        instance: (0, import_node_os6.hostname)() || "unknown",
+        spec_version_compat: `>=${SPEC_VERSION}`,
+        role_narrative: ROLE_NARRATIVE6
+      }),
+      last_updated: (/* @__PURE__ */ new Date()).toISOString(),
+      capabilities: [],
+      recent_sessions: [],
+      known_entities: [],
+      visibility_policy: DEFAULT_POLICY6
+    });
+  }
+};
+
+// src/readers/cascade.ts
+var import_node_fs8 = require("fs");
+var import_node_os7 = require("os");
+var import_node_path7 = require("path");
+var import_yaml3 = require("yaml");
+var import_l57 = require("@getbourdon/l5");
+var import_redaction7 = require("@getbourdon/redaction");
+var AGENT_ID7 = "cascade";
+var AGENT_TYPE7 = "code-assistant";
+var DISPLAY_NAME5 = "Cascade (Windsurf)";
+var ROLE_NARRATIVE7 = "Agentic AI coding assistant embedded in Windsurf IDE. Operates with multi-step planning, tool use (file editing, terminal, browser preview, code search), persistent memory, and workspace-level context awareness. Specializes in pair-programming workflows with concurrent read-plan-execute cycles.";
+var CONVENTION_DIR_NAME2 = ".cascade-bourdon";
+var MEMORY_FILENAME2 = "memory.md";
+var DEFAULT_POLICY7 = (0, import_l57.makeVisibilityPolicy)({
+  default: import_l57.Visibility.PUBLIC,
+  private_tags: ["personal", "credential", "financial", "secret", "private"]
+});
+var CASCADE_SENSITIVE_PATTERNS = [
+  ...import_redaction7.SENSITIVE_PATTERNS,
+  /\bsecret\b/i,
+  /sk[_-]test[_-]/i
+];
+var logger2 = {
+  warn(msg) {
+    console.warn(`[bourdon.participants] ${msg}`);
+  }
+};
+function homeDir4() {
+  try {
+    return (0, import_node_os7.homedir)();
+  } catch {
+    return process.env.HOME || process.env.USERPROFILE || ".";
+  }
+}
+function isDir6(p) {
+  try {
+    return (0, import_node_fs8.statSync)(p).isDirectory();
+  } catch {
+    return false;
+  }
+}
+function isFile6(p) {
+  try {
+    return (0, import_node_fs8.statSync)(p).isFile();
+  } catch {
+    return false;
+  }
+}
+function defaultCascadeDir() {
+  return (0, import_node_path7.join)(homeDir4(), CONVENTION_DIR_NAME2);
+}
+function parseFrontmatter3(text, source) {
+  if (!text.startsWith("---")) return {};
+  const end = text.indexOf("---", 3);
+  if (end === -1) return {};
+  const yamlBlock = text.slice(3, end).trim();
+  if (!yamlBlock) return {};
+  let data;
+  try {
+    data = (0, import_yaml3.parse)(yamlBlock);
+  } catch (exc) {
+    const where = source ? ` in ${source}` : "";
+    const detail = String(exc).replace(/\n/g, " ").slice(0, 200);
+    logger2.warn(
+      `CascadeParticipant: malformed YAML frontmatter${where}; treating as no-frontmatter (${detail})`
+    );
+    return {};
+  }
+  return typeof data === "object" && data !== null && !Array.isArray(data) ? data : {};
+}
+function scrubCredential(text) {
+  if (!text) return text;
+  if (CASCADE_SENSITIVE_PATTERNS.some((p) => p.test(text))) {
+    return import_redaction7.REDACTED;
+  }
+  return (0, import_redaction7.redactText)(text);
+}
+function asList(v) {
+  if (!v) return [];
+  if (Array.isArray(v)) return v;
+  if (typeof v === "string") return Array.from(v);
+  return [];
+}
+function isRecord3(v) {
+  return typeof v === "object" && v !== null && !Array.isArray(v);
+}
+function buildEntity2(raw) {
+  if (!isRecord3(raw)) return null;
+  const name = raw["name"];
+  if (typeof name !== "string" || !name.trim()) return null;
+  let summary;
+  const rawSummary = raw["summary"];
+  if (typeof rawSummary === "string") summary = scrubCredential(rawSummary);
+  return (0, import_l57.makeEntity)({
+    name: name.trim(),
+    type: typeof raw["type"] === "string" ? raw["type"] : void 0,
+    summary,
+    aliases: asList(raw["aliases"]),
+    tags: asList(raw["tags"]),
+    last_touched: raw["last_touched"] ? String(raw["last_touched"]) : void 0,
+    valid_from: raw["valid_from"] ? String(raw["valid_from"]) : void 0,
+    valid_to: raw["valid_to"] ? String(raw["valid_to"]) : void 0,
+    visibility: void 0
+  });
+}
+function buildSession3(raw) {
+  if (!isRecord3(raw)) return null;
+  const dateVal = raw["date"];
+  if (!dateVal) return null;
+  const dateStr = String(dateVal).slice(0, 10);
+  return (0, import_l57.makeSession)({
+    date: dateStr,
+    cwd: raw["cwd"] == null ? void 0 : raw["cwd"],
+    key_actions: asList(raw["key_actions"]),
+    files_touched: asList(raw["files_touched"]),
+    project_focus: asList(raw["project_focus"]),
+    visibility: void 0
+  });
+}
+function parseSessionDate(date) {
+  if (!/^\d{4}-\d{2}-\d{2}$/.test(date)) return null;
+  const ms = Date.parse(`${date}T00:00:00Z`);
+  return Number.isNaN(ms) ? null : new Date(ms);
+}
+function buildSessions(rawSessions, since) {
+  const list = Array.isArray(rawSessions) ? rawSessions : [];
+  const sessions = [];
+  for (const raw of list) {
+    const session = buildSession3(raw);
+    if (session === null) continue;
+    if (since !== void 0) {
+      const d = parseSessionDate(session.date);
+      if (d !== null && d.getTime() < since.getTime()) continue;
+    }
+    sessions.push(session);
+  }
+  return sessions;
+}
+function inspectCascadeMemory(cascadeDir) {
+  const memoryPath = (0, import_node_path7.join)(cascadeDir, MEMORY_FILENAME2);
+  if (!isFile6(memoryPath)) return { present: false, error: "missing" };
+  let text;
+  try {
+    text = (0, import_node_fs8.readFileSync)(memoryPath, "utf8");
+  } catch (e) {
+    return { present: true, readable: false, error: String(e) };
+  }
+  const data = parseFrontmatter3(text, memoryPath);
+  if (Object.keys(data).length === 0) {
+    return {
+      present: true,
+      readable: true,
+      frontmatter_valid: false,
+      entity_count: 0,
+      session_count: 0
+    };
+  }
+  const entities = data["entities"];
+  const sessions = data["sessions"];
+  return {
+    present: true,
+    readable: true,
+    frontmatter_valid: true,
+    entity_count: Array.isArray(entities) ? entities.length : 0,
+    session_count: Array.isArray(sessions) ? sessions.length : 0
+  };
+}
+var CascadeParticipant = class {
+  agentId = AGENT_ID7;
+  agentType = AGENT_TYPE7;
+  displayName = DISPLAY_NAME5;
+  dir;
+  policy;
+  static defaultNativePath(home) {
+    if (home !== void 0) return (0, import_node_path7.join)(home, CONVENTION_DIR_NAME2);
+    return defaultCascadeDir();
+  }
+  constructor(cascadeDir, policy) {
+    this.dir = cascadeDir ?? defaultCascadeDir();
+    this.policy = policy ?? DEFAULT_POLICY7;
+  }
+  /** Path to the Cascade-Bourdon convention directory. */
+  get nativePath() {
+    return this.dir;
+  }
+  memoryPath() {
+    return (0, import_node_path7.join)(this.dir, MEMORY_FILENAME2);
+  }
+  readFrontmatter() {
+    const path = this.memoryPath();
+    if (!isFile6(path)) return {};
+    let text;
+    try {
+      text = (0, import_node_fs8.readFileSync)(path, "utf8");
+    } catch {
+      return {};
+    }
+    return parseFrontmatter3(text, path);
+  }
+  discover() {
+    if (!isDir6(this.dir)) {
+      throw new ParticipantDiscoveryError(
+        `Cascade-Bourdon directory not found: ${this.dir}`
+      );
+    }
+    const memoryPresent = isFile6(this.memoryPath());
+    return {
+      path: this.dir,
+      version: "unknown",
+      metadata: {
+        memory_file: this.memoryPath(),
+        memory_file_present: memoryPresent
+      }
+    };
+  }
+  exportL5(since) {
+    const data = this.readFrontmatter();
+    const rawEntities = data["entities"];
+    const entityList = Array.isArray(rawEntities) ? rawEntities : [];
+    const entities = [];
+    for (const raw of entityList) {
+      const entity = buildEntity2(raw);
+      if (entity !== null) entities.push(entity);
+    }
+    const sessions = buildSessions(data["sessions"], since);
+    const visibleEntities = (0, import_l57.filterForFederation)(entities, this.policy);
+    return (0, import_l57.makeManifest)({
+      spec_version: SPEC_VERSION,
+      agent: (0, import_l57.makeAgentInfo)({
+        id: AGENT_ID7,
+        type: AGENT_TYPE7,
+        role_narrative: ROLE_NARRATIVE7
+      }),
+      last_updated: (/* @__PURE__ */ new Date()).toISOString(),
+      known_entities: visibleEntities,
+      recent_sessions: sessions,
+      capabilities: ["chat", "code-editing", "terminal", "planning", "search"]
+    });
+  }
+  exportSessions(since, limit) {
+    const data = this.readFrontmatter();
+    const sessions = buildSessions(data["sessions"], since);
+    sessions.sort((a, b) => a.date < b.date ? 1 : a.date > b.date ? -1 : 0);
+    if (limit !== void 0) return sessions.slice(0, limit);
+    return sessions;
+  }
+  healthCheck() {
+    if (!isDir6(this.dir)) {
+      return {
+        status: "blocked",
+        reason: "Cascade-Bourdon directory not found",
+        details: { expected_path: this.dir },
+        proposedFix: "Run `bourdon cascade init` to create the convention directory + starter memory.md."
+      };
+    }
+    const report = inspectCascadeMemory(this.dir);
+    if (!report["present"]) {
+      return {
+        status: "degraded",
+        reason: "Memory file not found; run `bourdon cascade init` to create it",
+        details: report,
+        proposedFix: "Run `bourdon cascade init` to write the starter memory.md template."
+      };
+    }
+    if (!report["readable"]) {
+      return {
+        status: "degraded",
+        reason: `Memory file not readable: ${String(report["error"])}`,
+        details: report,
+        proposedFix: `Check filesystem permissions on ${(0, import_node_path7.join)(this.dir, "memory.md")} (should be readable by your user).`
+      };
+    }
+    if (!report["frontmatter_valid"]) {
+      return {
+        status: "degraded",
+        reason: "Memory file has no valid YAML front-matter",
+        details: report,
+        proposedFix: `Inspect ${(0, import_node_path7.join)(this.dir, "memory.md")} -- the opening and closing \`---\` fences must wrap a valid YAML block. Run \`bourdon cascade init --force\` to reset to the template (WARNING: this overwrites existing content).`
+      };
+    }
+    return {
+      status: "ok",
+      details: report
+    };
+  }
+};
+
+// src/readers/openclaw.ts
+var import_node_child_process2 = require("child_process");
+var import_node_os8 = require("os");
+var import_node_path8 = require("path");
+var import_l58 = require("@getbourdon/l5");
+var import_redaction8 = require("@getbourdon/redaction");
+var AGENT_ID8 = "openclaw";
+var AGENT_TYPE8 = "other";
+var DISPLAY_NAME6 = "OpenClaw (quarantined)";
+var ROLE_NARRATIVE8 = "OpenClaw personal AI assistant \u2014 federated as a QUARANTINED member: its reads are limited to granted namespaces and its writes are staged for operator review.";
+var MIN_PATCHED_VERSION = "2026.1.29";
+var DEFAULT_OPENCLAW_URL = "http://127.0.0.1:8080";
+var SESSION_LIMIT = 50;
+var ENTITY_LIMIT = 100;
+function isRecord4(v) {
+  return typeof v === "object" && v !== null && !Array.isArray(v);
+}
+function safeNativeMemoryText2(value) {
+  return (0, import_redaction8.redactText)(value, 180);
+}
+function parseVersion(value) {
+  const parts = [];
+  for (const chunk of String(value ?? "").trim().split(".")) {
+    const match = /^(\d+)/.exec(chunk);
+    if (!match) break;
+    parts.push(Number(match[1]));
+  }
+  return parts.length > 0 ? parts : null;
+}
+function versionLessThan(a, b) {
+  const n = Math.max(a.length, b.length);
+  for (let i = 0; i < n; i += 1) {
+    const av = i < a.length ? a[i] : void 0;
+    const bv = i < b.length ? b[i] : void 0;
+    if (av === void 0) return true;
+    if (bv === void 0) return false;
+    if (av < bv) return true;
+    if (av > bv) return false;
+  }
+  return false;
+}
+function statusVersion(status) {
+  for (const key of ["version", "openclaw_version", "app_version"]) {
+    const value = status[key];
+    if (typeof value === "string" && value.trim()) return value.trim();
+  }
+  return "";
+}
+function statusAuthEnabled(status) {
+  for (const key of ["auth_enabled", "authEnabled"]) {
+    if (key in status) return Boolean(status[key]);
+  }
+  const auth = status["auth"];
+  if (isRecord4(auth)) return Boolean(auth["enabled"]);
+  return false;
+}
+function verifyInstance(status, url) {
+  const version = statusVersion(status);
+  const parsed = parseVersion(version);
+  const minimum = parseVersion(MIN_PATCHED_VERSION);
+  if (parsed === null) {
+    throw new ParticipantDiscoveryError(
+      `OpenClaw at ${url} did not report a parseable version (got ${JSON.stringify(version)}). Refusing handshake: cannot verify the CVE-2026-25253 patch level. Fix: upgrade OpenClaw to >= ${MIN_PATCHED_VERSION} and ensure /api/status reports it.`
+    );
+  }
+  if (versionLessThan(parsed, minimum)) {
+    throw new ParticipantDiscoveryError(
+      `OpenClaw at ${url} runs ${version}, which predates the CVE-2026-25253 patch (one-click RCE, CVSS 8.8). Refusing handshake. Fix: upgrade OpenClaw to >= ${MIN_PATCHED_VERSION}.`
+    );
+  }
+  if (!statusAuthEnabled(status)) {
+    throw new ParticipantDiscoveryError(
+      `OpenClaw at ${url} has authentication DISABLED (the exposed-instance default). Refusing handshake. Fix: enable auth in your OpenClaw config (set auth.enabled=true / OPENCLAW_AUTH=1), restart the instance, and set OPENCLAW_TOKEN for Bourdon.`
+    );
+  }
+  return version;
+}
+function before(dateText, since) {
+  const parsed = fromIsoformatUtc(dateText.replace(/Z/g, "+00:00"));
+  if (parsed === null) return false;
+  return parsed.getTime() < since.getTime();
+}
+function fromIsoformatUtc(text) {
+  const value = text.trim();
+  if (!value) return null;
+  const hasOffset = /[+-]\d{2}:?\d{2}$/.test(value);
+  const normalized = hasOffset || !value.includes("T") ? value : `${value}Z`;
+  const ms = Date.parse(normalized);
+  return Number.isNaN(ms) ? null : new Date(ms);
+}
+function nowIsoSeconds2() {
+  return (/* @__PURE__ */ new Date()).toISOString().replace(/\.\d{3}Z$/, "Z");
+}
+function curlGet2(url, token, timeoutSec) {
+  const args = ["-sS", "-o", "-", "--max-time", String(timeoutSec)];
+  if (token) {
+    args.push("-H", `Authorization: Bearer ${token}`);
+  }
+  args.push("-w", "\n__BOURDON_STATUS__%{http_code}", url);
+  const raw = (0, import_node_child_process2.execFileSync)("curl", args, {
+    encoding: "utf8",
+    timeout: (timeoutSec + 2) * 1e3,
+    maxBuffer: 8 * 1024 * 1024
+  });
+  const statusMatch = /\n__BOURDON_STATUS__(\d+)$/.exec(raw);
+  const status = statusMatch ? Number(statusMatch[1]) : 0;
+  const body = statusMatch ? raw.slice(0, statusMatch.index) : raw;
+  return { status, body };
+}
+var OpenClawApiClient = class {
+  url;
+  token;
+  timeout;
+  constructor(url, token, timeout = 5) {
+    this.url = url.replace(/\/+$/, "");
+    this.token = token;
+    this.timeout = timeout;
+  }
+  get(path) {
+    let resp;
+    try {
+      resp = curlGet2(this.url + path, this.token, this.timeout);
+    } catch (err) {
+      throw new ParticipantDiscoveryError(
+        `OpenClaw instance unreachable at ${this.url} (${String(err)})`
+      );
+    }
+    if (resp.status >= 400) {
+      throw new ParticipantDiscoveryError(
+        `OpenClaw API ${path} returned HTTP ${resp.status}`
+      );
+    }
+    if (resp.status === 0) {
+      throw new ParticipantDiscoveryError(
+        `OpenClaw instance unreachable at ${this.url} (no HTTP response)`
+      );
+    }
+    try {
+      return JSON.parse(resp.body);
+    } catch (err) {
+      throw new ParticipantDiscoveryError(
+        `OpenClaw instance unreachable at ${this.url} (${String(err)})`
+      );
+    }
+  }
+  status() {
+    const data = this.get("/api/status");
+    return isRecord4(data) ? data : {};
+  }
+  sessions() {
+    return this.readCollection("/api/sessions", "sessions");
+  }
+  memories() {
+    return this.readCollection("/api/memories", "memories");
+  }
+  /** Shared `sessions()`/`memories()` body: try/except-returns-[], unwrap the
+   * `{ "<key>": [...] }` envelope, and keep only object rows. */
+  readCollection(path, key) {
+    let data;
+    try {
+      data = this.get(path);
+    } catch (err) {
+      if (err instanceof ParticipantDiscoveryError) return [];
+      throw err;
+    }
+    if (isRecord4(data)) {
+      data = data[key] || [];
+    }
+    if (!Array.isArray(data)) return [];
+    return data.filter(isRecord4);
+  }
+};
+var OpenClawParticipant = class {
+  agentId = AGENT_ID8;
+  agentType = AGENT_TYPE8;
+  displayName = DISPLAY_NAME6;
+  /** Trust marker consumed by `bourdon agent add/set-tier` + export-all:
+   * registering as trusted needs --i-understand-the-risk; exports stage. */
+  quarantinedClass = true;
+  url;
+  client;
+  static defaultNativePath(home) {
+    return (0, import_node_path8.join)(home ?? (0, import_node_os8.homedir)(), ".openclaw");
+  }
+  constructor(url, token, client) {
+    this.url = (url || process.env.OPENCLAW_URL || DEFAULT_OPENCLAW_URL).replace(/\/+$/, "");
+    this.client = client ?? new OpenClawApiClient(this.url, token ?? process.env.OPENCLAW_TOKEN);
+  }
+  get nativePath() {
+    return this.url;
+  }
+  // -- protocol ----------------------------------------------------------------
+  discover() {
+    const status = this.client.status();
+    const version = verifyInstance(status, this.url);
+    return {
+      path: this.url,
+      version,
+      metadata: { auth_enabled: true, transport: "http" }
+    };
+  }
+  exportSessions(since, limit = SESSION_LIMIT) {
+    this.discover();
+    const sessions = [];
+    for (const row of this.client.sessions()) {
+      const date = String(row["updated_at"] || row["started_at"] || row["date"] || "").trim();
+      if (!date) continue;
+      if (since !== void 0 && before(date, since)) continue;
+      const title = safeNativeMemoryText2(String(row["title"] || row["summary"] || ""));
+      const projects = Array.isArray(row["projects"]) ? row["projects"].slice(0, 5) : [];
+      sessions.push(
+        (0, import_l58.makeSession)({
+          date,
+          cwd: void 0,
+          project_focus: projects.map((p) => safeNativeMemoryText2(String(p))),
+          key_actions: title ? [title] : []
+        })
+      );
+      if (sessions.length >= limit) break;
+    }
+    return sessions;
+  }
+  exportL5(since) {
+    const store = this.discover();
+    const entities = [];
+    for (const row of this.client.memories().slice(0, ENTITY_LIMIT)) {
+      const name = safeNativeMemoryText2(String(row["name"] || row["title"] || ""));
+      if (!name) continue;
+      const tags = Array.isArray(row["tags"]) ? row["tags"].slice(0, 8) : [];
+      entities.push(
+        (0, import_l58.makeEntity)({
+          name,
+          type: String(row["type"] || "topic"),
+          summary: safeNativeMemoryText2(String(row["summary"] || "")),
+          tags: tags.map((t) => safeNativeMemoryText2(String(t)))
+        })
+      );
+    }
+    const policy = (0, import_l58.makeVisibilityPolicy)({ default: import_l58.Visibility.TEAM });
+    return (0, import_l58.makeManifest)({
+      spec_version: SPEC_VERSION,
+      agent: (0, import_l58.makeAgentInfo)({
+        id: AGENT_ID8,
+        type: AGENT_TYPE8,
+        instance: this.url,
+        role_narrative: ROLE_NARRATIVE8
+      }),
+      last_updated: nowIsoSeconds2(),
+      capabilities: [`openclaw ${store.version}`],
+      recent_sessions: this.exportSessions(since),
+      known_entities: (0, import_l58.filterForFederation)(entities, policy),
+      visibility_policy: policy
+    });
+  }
+  healthCheck() {
+    let store;
+    try {
+      store = this.discover();
+    } catch (exc) {
+      if (exc instanceof ParticipantDiscoveryError) {
+        const reason = exc.message;
+        let fix = "see the refusal reason above";
+        if (reason.includes("upgrade OpenClaw")) {
+          fix = `upgrade the OpenClaw instance to >= ${MIN_PATCHED_VERSION}`;
+        } else if (reason.includes("authentication DISABLED")) {
+          fix = "enable auth on the OpenClaw instance, then set OPENCLAW_TOKEN";
+        } else if (reason.includes("unreachable")) {
+          fix = "start OpenClaw locally or set OPENCLAW_URL to the instance address";
+        }
+        return { status: "blocked", reason, proposedFix: fix, details: {} };
+      }
+      return {
+        status: "degraded",
+        reason: exc instanceof Error ? exc.message : String(exc),
+        details: {}
+      };
+    }
+    return {
+      status: "ok",
+      details: { url: this.url, version: store.version, quarantined: true }
+    };
+  }
+};
+
+// src/registry.ts
+var FIRST_PARTY = [
+  CascadeParticipant,
+  ClaudeCodeParticipant,
+  CopilotParticipant,
+  CopilotCliParticipant,
+  CursorParticipant,
+  GitHubCopilotParticipant,
+  HermesParticipant,
+  OpenClawParticipant
+];
+var logger3 = {
+  warn(msg) {
+    console.warn(`[bourdon.participants] ${msg}`);
+  }
+};
+function discoverParticipants(ctors = FIRST_PARTY) {
+  const found = /* @__PURE__ */ new Map();
+  for (const Ctor of [...ctors, ...resolvePluginParticipants()]) {
+    let instance;
+    try {
+      instance = new Ctor();
+    } catch (err) {
+      logger3.warn(
+        `Skipping participant ${Ctor.name || "<anonymous>"}: construction failed: ${String(err)}`
+      );
+      continue;
+    }
+    if (!isParticipant(instance)) continue;
+    if (!found.has(instance.agentId)) found.set(instance.agentId, instance);
+  }
+  return [...found.values()].sort(
+    (a, b) => a.agentId < b.agentId ? -1 : a.agentId > b.agentId ? 1 : 0
+  );
+}
+function resolvePluginParticipants() {
+  if (process.env.BOURDON_PLUGINS !== "1") return [];
+  return [];
+}
+
+// src/index.ts
+var import_l59 = require("@getbourdon/l5");
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  CONTRACT_VERSION,
+  CacheEntry,
+  CascadeParticipant,
+  ClaudeCodeParticipant,
+  CopilotCliParticipant,
+  CopilotParticipant,
+  CursorParticipant,
+  DEFAULT_CACHE_TTL_SECONDS,
+  FIRST_PARTY,
+  GitHubCopilotParticipant,
+  HermesParticipant,
+  MIN_PATCHED_VERSION,
+  NETWORK_CONTRACT_VERSION,
+  NetworkParticipant,
+  NetworkUnavailable,
+  OpenClawApiClient,
+  OpenClawParticipant,
+  ParticipantAuthError,
+  ParticipantDiscoveryError,
+  ParticipantError,
+  ParticipantExportError,
+  ParticipantVersionMismatchError,
+  PayloadCache,
+  SPEC_VERSION,
+  Visibility,
+  applyVisibility,
+  defaultCacheRoot,
+  discoverParticipants,
+  envAuthProvider,
+  epochToIsoDate,
+  epochToIsoDatetime,
+  filterForFederation,
+  friendlyLabel,
+  ghTokenProvider,
+  isParticipant,
+  openReadonly,
+  projectKeyFromCwd,
+  resolvePluginParticipants,
+  sqliteAvailable,
+  tableColumns,
+  tableExists,
+  toDict,
+  tryOpenReadonly,
+  validateManifest,
+  verifyInstance
+});
+//# sourceMappingURL=index.cjs.map