@getbourdon/participants 0.1.0 → 0.1.1

package/dist/index.cjs

@@ -0,0 +1,1469 @@
+"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,
+  ClaudeCodeParticipant: () => ClaudeCodeParticipant,
+  DEFAULT_CACHE_TTL_SECONDS: () => DEFAULT_CACHE_TTL_SECONDS,
+  FIRST_PARTY: () => FIRST_PARTY,
+  GitHubCopilotParticipant: () => GitHubCopilotParticipant,
+  HermesParticipant: () => HermesParticipant,
+  NETWORK_CONTRACT_VERSION: () => NETWORK_CONTRACT_VERSION,
+  NetworkParticipant: () => NetworkParticipant,
+  NetworkUnavailable: () => NetworkUnavailable,
+  ParticipantAuthError: () => ParticipantAuthError,
+  ParticipantDiscoveryError: () => ParticipantDiscoveryError,
+  ParticipantError: () => ParticipantError,
+  ParticipantExportError: () => ParticipantExportError,
+  ParticipantVersionMismatchError: () => ParticipantVersionMismatchError,
+  PayloadCache: () => PayloadCache,
+  SPEC_VERSION: () => SPEC_VERSION,
+  Visibility: () => import_l54.Visibility,
+  applyVisibility: () => import_l54.applyVisibility,
+  defaultCacheRoot: () => defaultCacheRoot,
+  discoverParticipants: () => discoverParticipants,
+  envAuthProvider: () => envAuthProvider,
+  epochToIsoDate: () => epochToIsoDate,
+  epochToIsoDatetime: () => epochToIsoDatetime,
+  filterForFederation: () => import_l54.filterForFederation,
+  friendlyLabel: () => friendlyLabel,
+  ghTokenProvider: () => ghTokenProvider,
+  isParticipant: () => isParticipant,
+  openReadonly: () => openReadonly,
+  projectKeyFromCwd: () => projectKeyFromCwd,
+  resolvePluginParticipants: () => resolvePluginParticipants,
+  sqliteAvailable: () => sqliteAvailable,
+  tableColumns: () => tableColumns,
+  tableExists: () => tableExists,
+  toDict: () => import_l54.toDict,
+  tryOpenReadonly: () => tryOpenReadonly,
+  validateManifest: () => import_l54.validateManifest
+});
+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/registry.ts
+var FIRST_PARTY = [
+  ClaudeCodeParticipant,
+  GitHubCopilotParticipant,
+  HermesParticipant
+];
+var logger = {
+  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) {
+      logger.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_l54 = require("@getbourdon/l5");
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  CONTRACT_VERSION,
+  CacheEntry,
+  ClaudeCodeParticipant,
+  DEFAULT_CACHE_TTL_SECONDS,
+  FIRST_PARTY,
+  GitHubCopilotParticipant,
+  HermesParticipant,
+  NETWORK_CONTRACT_VERSION,
+  NetworkParticipant,
+  NetworkUnavailable,
+  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
+});
+//# sourceMappingURL=index.cjs.map