@getbourdon/participants 0.1.1 → 0.2.0

package/dist/index.cjs

@@ -22,14 +22,21 @@ 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,
@@ -37,14 +44,14 @@ __export(index_exports, {
   ParticipantVersionMismatchError: () => ParticipantVersionMismatchError,
   PayloadCache: () => PayloadCache,
   SPEC_VERSION: () => SPEC_VERSION,
-  Visibility: () => import_l54.Visibility,
-  applyVisibility: () => import_l54.applyVisibility,
+  Visibility: () => import_l59.Visibility,
+  applyVisibility: () => import_l59.applyVisibility,
   defaultCacheRoot: () => defaultCacheRoot,
   discoverParticipants: () => discoverParticipants,
   envAuthProvider: () => envAuthProvider,
   epochToIsoDate: () => epochToIsoDate,
   epochToIsoDatetime: () => epochToIsoDatetime,
-  filterForFederation: () => import_l54.filterForFederation,
+  filterForFederation: () => import_l59.filterForFederation,
   friendlyLabel: () => friendlyLabel,
   ghTokenProvider: () => ghTokenProvider,
   isParticipant: () => isParticipant,
@@ -54,9 +61,10 @@ __export(index_exports, {
   sqliteAvailable: () => sqliteAvailable,
   tableColumns: () => tableColumns,
   tableExists: () => tableExists,
-  toDict: () => import_l54.toDict,
+  toDict: () => import_l59.toDict,
   tryOpenReadonly: () => tryOpenReadonly,
-  validateManifest: () => import_l54.validateManifest
+  validateManifest: () => import_l59.validateManifest,
+  verifyInstance: () => verifyInstance
 });
 module.exports = __toCommonJS(index_exports);
 
@@ -1389,13 +1397,1820 @@ function isoDate(value) {
   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
+  HermesParticipant,
+  OpenClawParticipant
 ];
-var logger = {
+var logger3 = {
   warn(msg) {
     console.warn(`[bourdon.participants] ${msg}`);
   }
@@ -1407,7 +3222,7 @@ function discoverParticipants(ctors = FIRST_PARTY) {
     try {
       instance = new Ctor();
     } catch (err) {
-      logger.warn(
+      logger3.warn(
         `Skipping participant ${Ctor.name || "<anonymous>"}: construction failed: ${String(err)}`
       );
       continue;
@@ -1425,19 +3240,26 @@ function resolvePluginParticipants() {
 }
 
 // src/index.ts
-var import_l54 = require("@getbourdon/l5");
+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,
@@ -1464,6 +3286,7 @@ var import_l54 = require("@getbourdon/l5");
   tableExists,
   toDict,
   tryOpenReadonly,
-  validateManifest
+  validateManifest,
+  verifyInstance
 });
 //# sourceMappingURL=index.cjs.map