@getbourdon/participants 0.2.0 → 0.2.1

package/dist/index.cjs

@@ -23,9 +23,16 @@ __export(index_exports, {
   CONTRACT_VERSION: () => CONTRACT_VERSION,
   CacheEntry: () => CacheEntry,
   CascadeParticipant: () => CascadeParticipant,
+  ClaudeCodeAutomationsParticipant: () => ClaudeCodeAutomationsParticipant,
   ClaudeCodeParticipant: () => ClaudeCodeParticipant,
+  ClaudeDesktopCodeParticipant: () => ClaudeDesktopCodeParticipant,
+  ClaudeDesktopCoworkParticipant: () => ClaudeDesktopCoworkParticipant,
+  CodexAutomationsParticipant: () => CodexAutomationsParticipant,
+  CopilotAutomationsParticipant: () => CopilotAutomationsParticipant,
   CopilotCliParticipant: () => CopilotCliParticipant,
   CopilotParticipant: () => CopilotParticipant,
+  CopilotVscodeParticipant: () => CopilotVscodeParticipant,
+  CursorAutomationsParticipant: () => CursorAutomationsParticipant,
   CursorParticipant: () => CursorParticipant,
   DEFAULT_CACHE_TTL_SECONDS: () => DEFAULT_CACHE_TTL_SECONDS,
   FIRST_PARTY: () => FIRST_PARTY,
@@ -44,14 +51,14 @@ __export(index_exports, {
   ParticipantVersionMismatchError: () => ParticipantVersionMismatchError,
   PayloadCache: () => PayloadCache,
   SPEC_VERSION: () => SPEC_VERSION,
-  Visibility: () => import_l59.Visibility,
-  applyVisibility: () => import_l59.applyVisibility,
+  Visibility: () => import_l516.Visibility,
+  applyVisibility: () => import_l516.applyVisibility,
   defaultCacheRoot: () => defaultCacheRoot,
   discoverParticipants: () => discoverParticipants,
   envAuthProvider: () => envAuthProvider,
   epochToIsoDate: () => epochToIsoDate,
   epochToIsoDatetime: () => epochToIsoDatetime,
-  filterForFederation: () => import_l59.filterForFederation,
+  filterForFederation: () => import_l516.filterForFederation,
   friendlyLabel: () => friendlyLabel,
   ghTokenProvider: () => ghTokenProvider,
   isParticipant: () => isParticipant,
@@ -61,9 +68,9 @@ __export(index_exports, {
   sqliteAvailable: () => sqliteAvailable,
   tableColumns: () => tableColumns,
   tableExists: () => tableExists,
-  toDict: () => import_l59.toDict,
+  toDict: () => import_l516.toDict,
   tryOpenReadonly: () => tryOpenReadonly,
-  validateManifest: () => import_l59.validateManifest,
+  validateManifest: () => import_l516.validateManifest,
   verifyInstance: () => verifyInstance
 });
 module.exports = __toCommonJS(index_exports);
@@ -506,8 +513,8 @@ function collectMemoryEntries(home) {
     if (isFile(path)) {
       const entries = parseMemoryFile(path);
       if (entries.length) {
-        const stem = fname.replace(/\.md$/, "");
-        result.push([stem, entries]);
+        const stem2 = fname.replace(/\.md$/, "");
+        result.push([stem2, entries]);
       }
     }
   }
@@ -517,18 +524,18 @@ 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));
+  const keyActions3 = [];
+  if (record.title) keyActions3.push(bounded(record.title, 160));
   if (toolNames.length) {
-    keyActions.push("Tools: " + toolNames.slice(0, 8).join(", "));
+    keyActions3.push("Tools: " + toolNames.slice(0, 8).join(", "));
   } else if (record.toolCallCount) {
-    keyActions.push(`${record.toolCallCount} tool call(s)`);
+    keyActions3.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,
+    key_actions: keyActions3,
     visibility: import_l5.Visibility.TEAM
   });
 }
@@ -641,7 +648,7 @@ var HermesParticipant = class {
   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 capabilities3 = 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);
@@ -674,7 +681,7 @@ var HermesParticipant = class {
         spec_version_compat: CONTRACT_VERSION
       }),
       last_updated: (/* @__PURE__ */ new Date()).toISOString(),
-      capabilities,
+      capabilities: capabilities3,
       recent_sessions: sessions,
       known_entities: visible,
       visibility_policy: DEFAULT_POLICY
@@ -919,7 +926,7 @@ 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] ?? "";
+  const sessionDate3 = m[1] ?? "";
   let text;
   try {
     text = (0, import_node_fs4.readFileSync)(logPath, "utf8");
@@ -929,7 +936,7 @@ function parseLogFile(logPath) {
   const { body } = parseFrontmatter(text);
   const headline = extractFirstParagraph(body, 250);
   return (0, import_l52.makeSession)({
-    date: sessionDate,
+    date: sessionDate3,
     key_actions: headline ? [headline] : [],
     files_touched: [`LOG/${(0, import_node_path3.basename)(logPath)}`]
   });
@@ -1128,7 +1135,7 @@ var ClaudeCodeParticipant = class {
   exportL5(since) {
     const store = this.discover();
     const sources = store.metadata["sources"];
-    const capabilities = Object.entries(sources).filter(([, v]) => v).map(([k]) => k).sort();
+    const capabilities3 = 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) : [];
@@ -1145,7 +1152,7 @@ var ClaudeCodeParticipant = class {
         role_narrative: ROLE_NARRATIVE2
       }),
       last_updated: (/* @__PURE__ */ new Date()).toISOString(),
-      capabilities,
+      capabilities: capabilities3,
       recent_sessions: sessions,
       known_entities: visibleEntities,
       visibility_policy: DEFAULT_POLICY2
@@ -1799,8 +1806,8 @@ function shortIndexToEntities(workspaceRoot, _cursorDir) {
     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 homeBase2 = cursorHome ?? (0, import_node_path4.join)(homeDir2(), ".cursor");
+  paths.push((0, import_node_path4.join)(homeBase2, "memory", "short-index.json"));
   const merged = /* @__PURE__ */ new Map();
   for (const path of paths) {
     for (const entry of readShortIndex(path)) {
@@ -2370,23 +2377,23 @@ function extractTurnCount(db, sessionId) {
 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 = [];
+  const keyActions3 = [];
   if (raw["summary"]) {
-    keyActions.push(bounded2(safeNativeMemoryText(String(raw["summary"])), MAX_KEY_ACTION_CHARS));
+    keyActions3.push(bounded2(safeNativeMemoryText(String(raw["summary"])), MAX_KEY_ACTION_CHARS));
   }
   for (const cp of checkpoints.slice(0, 3)) {
     if (cp["title"]) {
-      keyActions.push(
+      keyActions3.push(
         bounded2(`checkpoint: ${safeNativeMemoryText(String(cp["title"]))}`, MAX_KEY_ACTION_CHARS)
       );
     }
   }
   if (turnCount) {
-    keyActions.push(`turns: ${turnCount}`);
+    keyActions3.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));
+    keyActions3.push(bounded2(refLabel, MAX_KEY_ACTION_CHARS));
   }
   const projectFocus = [];
   if (raw["repository"]) projectFocus.push(String(raw["repository"]));
@@ -2394,7 +2401,7 @@ function sessionToBourdon(raw, files, refs, checkpoints, turnCount) {
     date: dateStr,
     cwd: raw["cwd"] ? String(raw["cwd"]) : void 0,
     project_focus: projectFocus,
-    key_actions: keyActions.slice(0, MAX_KEY_ACTIONS),
+    key_actions: keyActions3.slice(0, MAX_KEY_ACTIONS),
     files_touched: files.slice(0, 20),
     visibility: import_l56.Visibility.TEAM
   });
@@ -3199,18 +3206,3169 @@ var OpenClawParticipant = class {
   }
 };
 
+// src/readers/claude-code-automations.ts
+var import_node_fs9 = require("fs");
+var import_node_os9 = require("os");
+var import_node_path9 = require("path");
+var import_l59 = require("@getbourdon/l5");
+var import_redaction9 = require("@getbourdon/redaction");
+var import_smol_toml = require("smol-toml");
+var AGENT_ID9 = "claude-code-automations";
+var AGENT_TYPE9 = "other";
+var ROLE_NARRATIVE9 = "Publishes read-only Claude Code automation run memory into Bourdon so scheduled /loop continuations, CronCreate jobs, GitHub Action runs of claude-code-action, and /schedule remote-routine summaries become visible alongside interactive Claude Code sessions.";
+var DEFAULT_POLICY8 = (0, import_l59.makeVisibilityPolicy)({
+  default: import_l59.Visibility.TEAM,
+  private_tags: ["personal", "financial", "credential", "health", "family", "legal"],
+  team_tags: ["claude-code-automation", "automation", "workspace"]
+});
+var AUTOMATIONS_DIR_NAME = "automations";
+var AUTOMATION_TOML = "automation.toml";
+var MEMORY_MD = "memory.md";
+var MAX_MEMORY_CHARS = 16e4;
+var MAX_KEY_ACTIONS_PER_RUN = 6;
+var MAX_KEY_ACTION_CHARS2 = 280;
+var RUN_HEADER_RE = /^(\d{4}-\d{2}-\d{2})(?:\b|$)(.*)$/;
+var HEADER_SUFFIX_STRIP = " -:\u2014";
+var PROJECT_HINTS = [
+  "ShipStable",
+  "ILTT",
+  "Prun",
+  "PRUN",
+  "OMNIvour",
+  "Castmore",
+  "Bourdon",
+  "RADLAB",
+  "CHIP",
+  "Claude Brain",
+  "Cursor",
+  "Copilot",
+  "Codex",
+  "Cascade"
+];
+var SIGNAL_PATTERNS = [
+  ["human-dashboard-action", /\b(human|ryan|dashboard|manual)\b/i],
+  ["release-gate", /\b(release|store|app review|play console|testflight)\b/i],
+  ["billing-drift", /\b(billing|stripe|revenuecat|iap|subscription)\b/i],
+  ["memory-coverage-gap", /\b(memory|l5|manifest|federated|bourdon)\b/i],
+  ["launch-decision", /\b(launch|go-live|pricing|prod|production)\b/i],
+  ["ci-signal", /\b(github action|workflow run|ci failure|gh action)\b/i]
+];
+var logger3 = {
+  warn(msg) {
+    console.warn(`[bourdon.participants] ${msg}`);
+  }
+};
+function homeDir5() {
+  try {
+    return (0, import_node_os9.homedir)();
+  } catch {
+    return process.env.HOME || process.env.USERPROFILE || ".";
+  }
+}
+function isDir7(p) {
+  try {
+    return (0, import_node_fs9.statSync)(p).isDirectory();
+  } catch {
+    return false;
+  }
+}
+function isFile7(p) {
+  try {
+    return (0, import_node_fs9.statSync)(p).isFile();
+  } catch {
+    return false;
+  }
+}
+function truthy(v) {
+  if (v === void 0 || v === null || v === false || v === 0 || v === "") return false;
+  if (Array.isArray(v)) return v.length > 0;
+  if (typeof v === "object") return Object.keys(v).length > 0;
+  return true;
+}
+function pyStr(v) {
+  if (v === true) return "True";
+  if (v === false) return "False";
+  if (v === null || v === void 0) return "None";
+  return String(v);
+}
+function strOr(a, b) {
+  return pyStr(truthy(a) ? a : b);
+}
+function rstrip(s) {
+  return s.replace(/\s+$/, "");
+}
+function stripChars2(s, chars) {
+  let start = 0;
+  let end = s.length;
+  while (start < end && chars.includes(s[start])) start++;
+  while (end > start && chars.includes(s[end - 1])) end--;
+  return s.slice(start, end);
+}
+function splitLines(s) {
+  const parts = s.split(/\r\n|\r|\n/);
+  if (parts.length > 0 && parts[parts.length - 1] === "") parts.pop();
+  return parts;
+}
+function defaultClaudeCodeAutomationsDir(claudeHome) {
+  if (claudeHome !== void 0) return (0, import_node_path9.join)(claudeHome, AUTOMATIONS_DIR_NAME);
+  const env = process.env.CLAUDE_HOME;
+  if (env) return (0, import_node_path9.join)(env, AUTOMATIONS_DIR_NAME);
+  return (0, import_node_path9.join)(homeDir5(), ".claude", AUTOMATIONS_DIR_NAME);
+}
+function readAutomationToml(path) {
+  let raw;
+  try {
+    raw = (0, import_smol_toml.parse)((0, import_node_fs9.readFileSync)(path, "utf8"));
+  } catch (exc) {
+    logger3.warn(
+      `ClaudeCodeAutomationsParticipant: cannot parse ${path}: ${String(exc)}`
+    );
+    return {};
+  }
+  return typeof raw === "object" && raw !== null && !Array.isArray(raw) ? raw : {};
+}
+function buildConfig(tomlPath) {
+  const raw = readAutomationToml(tomlPath);
+  const parent = (0, import_node_path9.dirname)(tomlPath);
+  const parentName = basenameOf2(parent);
+  const automationId = strOr(raw["id"], parentName).trim();
+  if (!automationId) return null;
+  const name = strOr(raw["name"], automationId).trim();
+  const status = strOr(raw["status"], "UNKNOWN").trim().toUpperCase();
+  const rrule = strOr(raw["rrule"], "").trim();
+  const kind = strOr(raw["kind"], "").trim();
+  const cwdsRaw = truthy(raw["cwds"]) ? raw["cwds"] : [];
+  const cwds = [];
+  if (Array.isArray(cwdsRaw)) {
+    for (const cwd of cwdsRaw) {
+      if (typeof cwd === "string" && cwd.trim()) cwds.push(cwd);
+    }
+  } else if (typeof cwdsRaw === "string") {
+    for (const ch of cwdsRaw) {
+      if (ch.trim()) cwds.push(ch);
+    }
+  }
+  const memoryPath = (0, import_node_path9.join)(parent, MEMORY_MD);
+  return {
+    automationId,
+    name,
+    status,
+    rrule,
+    kind,
+    cwds,
+    path: tomlPath,
+    memoryPath: isFile7(memoryPath) ? memoryPath : null
+  };
+}
+function basenameOf2(p) {
+  const cleaned = p.replace(/[/\\]+$/, "");
+  const idx = Math.max(cleaned.lastIndexOf("/"), cleaned.lastIndexOf("\\"));
+  return idx === -1 ? cleaned : cleaned.slice(idx + 1);
+}
+function iterConfigs(automationsDir) {
+  const configs = [];
+  if (!isDir7(automationsDir)) return configs;
+  const tomlPaths = [];
+  let entries;
+  try {
+    entries = (0, import_node_fs9.readdirSync)(automationsDir);
+  } catch {
+    return configs;
+  }
+  for (const entry of entries) {
+    const sub = (0, import_node_path9.join)(automationsDir, entry);
+    if (!isDir7(sub)) continue;
+    const tomlPath = (0, import_node_path9.join)(sub, AUTOMATION_TOML);
+    if (isFile7(tomlPath)) tomlPaths.push(tomlPath);
+  }
+  tomlPaths.sort((a, b) => a < b ? -1 : a > b ? 1 : 0);
+  for (const tomlPath of tomlPaths) {
+    const config = buildConfig(tomlPath);
+    if (config !== null) configs.push(config);
+  }
+  return configs;
+}
+function readMemoryText(path) {
+  if (path === null) return "";
+  let text;
+  try {
+    text = (0, import_node_fs9.readFileSync)(path, "utf8");
+  } catch (exc) {
+    logger3.warn(
+      `ClaudeCodeAutomationsParticipant: cannot read ${path}: ${String(exc)}`
+    );
+    return "";
+  }
+  return text.slice(-MAX_MEMORY_CHARS);
+}
+function extractMemoryRuns(config) {
+  const text = readMemoryText(config.memoryPath);
+  if (!text) return [];
+  const chunks = [];
+  let currentDate = "";
+  let currentLines = [];
+  for (const rawLine of splitLines(text)) {
+    const line = rstrip(rawLine);
+    const match = RUN_HEADER_RE.exec(line.trim());
+    if (match) {
+      if (currentDate) chunks.push([currentDate, currentLines]);
+      currentDate = match[1];
+      const suffix = stripChars2(match[2] ?? "", HEADER_SUFFIX_STRIP);
+      currentLines = suffix ? [suffix] : [];
+      continue;
+    }
+    if (currentDate) currentLines.push(line);
+  }
+  if (currentDate) chunks.push([currentDate, currentLines]);
+  const runs = [];
+  for (const [runDate, lines] of chunks) {
+    const actions = actionsFromLines(lines);
+    if (actions.length === 0) continue;
+    const body = actions.join(" ");
+    const title = titleFromActions(config, actions);
+    runs.push({
+      automation: config,
+      date: runDate,
+      title,
+      keyActions: actions,
+      projects: inferProjects(body),
+      signals: inferSignals(body)
+    });
+  }
+  return runs;
+}
+function actionsFromLines(lines) {
+  const actions = [];
+  for (const line of lines) {
+    let cleaned = line.trim();
+    if (!cleaned) continue;
+    cleaned = removePrefix(cleaned, "- ").trim();
+    const lowered = cleaned.toLowerCase();
+    if (!cleaned || lowered.startsWith("runtime")) continue;
+    if (lowered === "first run" || lowered === "follow-up") continue;
+    if (lowered.startsWith("run:")) cleaned = cleaned.slice(4).trim();
+    const safe = bounded3(safeNativeMemoryText3(cleaned), MAX_KEY_ACTION_CHARS2);
+    if (safe && !actions.includes(safe)) actions.push(safe);
+    if (actions.length >= MAX_KEY_ACTIONS_PER_RUN) break;
+  }
+  return actions;
+}
+function removePrefix(s, prefix) {
+  return s.startsWith(prefix) ? s.slice(prefix.length) : s;
+}
+function safeNativeMemoryText3(value) {
+  return (0, import_redaction9.redactText)(value, 180);
+}
+function titleFromActions(config, actions) {
+  if (actions.length === 0) return config.name;
+  const first = actions[0];
+  const prefix = `${config.name}: `;
+  if (first.startsWith(prefix)) return bounded3(first, 120);
+  return bounded3(prefix + first, 120);
+}
+function inferProjects(text) {
+  const projects = [];
+  const lowered = text.toLowerCase();
+  const seen = /* @__PURE__ */ new Set();
+  for (const project of PROJECT_HINTS) {
+    const key = project.toLowerCase();
+    if (lowered.includes(key) && !seen.has(key)) {
+      projects.push(project);
+      seen.add(key);
+    }
+  }
+  return projects;
+}
+function inferSignals(text) {
+  const signals = [];
+  for (const [name, pattern] of SIGNAL_PATTERNS) {
+    if (pattern.test(text)) signals.push(name);
+  }
+  return signals;
+}
+function bounded3(value, limit) {
+  const normalized = value.trim().replace(/\s+/g, " ");
+  if (normalized.length <= limit) return normalized;
+  return rstrip(normalized.slice(0, limit - 1)) + "...";
+}
+function sessionFromRun(run) {
+  const config = run.automation;
+  const keyActions3 = [
+    `automation_id: ${config.automationId}`,
+    `run: ${run.title}`,
+    ...run.keyActions
+  ];
+  const filesTouched = [config.path];
+  if (config.memoryPath !== null) filesTouched.push(config.memoryPath);
+  return (0, import_l59.makeSession)({
+    date: run.date,
+    cwd: config.cwds.length > 0 ? config.cwds[0] : (0, import_node_path9.dirname)(config.path),
+    project_focus: [...run.projects],
+    key_actions: keyActions3.slice(0, MAX_KEY_ACTIONS_PER_RUN + 2),
+    files_touched: filesTouched,
+    visibility: import_l59.Visibility.TEAM
+  });
+}
+function entitiesFromConfigsAndRuns(configs, runs) {
+  const byName = /* @__PURE__ */ new Map();
+  for (const config of configs) {
+    byName.set(
+      config.automationId,
+      (0, import_l59.makeEntity)({
+        name: config.automationId,
+        type: "automation",
+        summary: bounded3(
+          `Claude Code automation '${config.name}' (${config.status}). Schedule: ${config.rrule || "unspecified"}.`,
+          260
+        ),
+        last_touched: void 0,
+        tags: ["claude-code-automation", "automation", config.status.toLowerCase()],
+        visibility: import_l59.Visibility.TEAM
+      })
+    );
+  }
+  for (const run of runs) {
+    for (const project of run.projects) {
+      if (!byName.has(project)) {
+        byName.set(
+          project,
+          (0, import_l59.makeEntity)({
+            name: project,
+            type: "project",
+            summary: "Project mentioned by Claude Code automation run memory.",
+            last_touched: run.date,
+            tags: ["claude-code-automation", "automation-evidence"],
+            visibility: import_l59.Visibility.TEAM
+          })
+        );
+      }
+    }
+    for (const signal of run.signals) {
+      if (!byName.has(signal)) {
+        byName.set(
+          signal,
+          (0, import_l59.makeEntity)({
+            name: signal,
+            type: "automation-signal",
+            summary: "Signal class inferred from Claude Code automation run memory.",
+            last_touched: run.date,
+            tags: ["claude-code-automation", "automation-signal"],
+            visibility: import_l59.Visibility.TEAM
+          })
+        );
+      }
+    }
+  }
+  return [...byName.values()];
+}
+var ClaudeCodeAutomationsParticipant = class {
+  agentId = AGENT_ID9;
+  agentType = AGENT_TYPE9;
+  nativePath;
+  automationsDir;
+  policy;
+  /**
+   * Conventional Claude Code automations dir (`~/.claude/automations`). Provided
+   * for protocol uniformity — the setup wizard wires the parent `claude-code`
+   * participant and skips `-automations` sub-surfaces.
+   */
+  static defaultNativePath(home) {
+    return defaultClaudeCodeAutomationsDir(home);
+  }
+  constructor(automationsDir, claudeHome) {
+    this.automationsDir = automationsDir ?? defaultClaudeCodeAutomationsDir(claudeHome);
+    this.nativePath = this.automationsDir;
+    this.policy = DEFAULT_POLICY8;
+  }
+  discover() {
+    if (!isDir7(this.automationsDir)) {
+      throw new ParticipantDiscoveryError(
+        `Claude Code automations directory not found at ${this.automationsDir}.`
+      );
+    }
+    const configs = iterConfigs(this.automationsDir);
+    return {
+      path: this.automationsDir,
+      version: "unknown",
+      metadata: {
+        automations: configs.length,
+        with_memory: configs.filter((c) => c.memoryPath !== null).length
+      }
+    };
+  }
+  exportSessions(since, limit = 100) {
+    const sessions = this.runs(void 0, since).map(sessionFromRun);
+    sessions.sort((a, b) => a.date < b.date ? 1 : a.date > b.date ? -1 : 0);
+    return sessions.slice(0, limit);
+  }
+  exportL5(since) {
+    if (!isDir7(this.automationsDir)) {
+      throw new ParticipantDiscoveryError(
+        `Claude Code automations directory not found at ${this.automationsDir}.`
+      );
+    }
+    const configs = iterConfigs(this.automationsDir);
+    const runs = this.runs(configs, since);
+    const sessions = runs.map(sessionFromRun);
+    sessions.sort((a, b) => a.date < b.date ? 1 : a.date > b.date ? -1 : 0);
+    const entities = entitiesFromConfigsAndRuns(configs, runs);
+    const visibleEntities = (0, import_l59.filterForFederation)(entities, this.policy);
+    return (0, import_l59.makeManifest)({
+      spec_version: SPEC_VERSION,
+      agent: (0, import_l59.makeAgentInfo)({
+        id: AGENT_ID9,
+        type: AGENT_TYPE9,
+        instance: (0, import_node_os9.hostname)(),
+        spec_version_compat: SPEC_VERSION,
+        role_narrative: ROLE_NARRATIVE9
+      }),
+      last_updated: (/* @__PURE__ */ new Date()).toISOString(),
+      capabilities: ["claude-code-automation-memory", "run-summary-publication"],
+      recent_sessions: sessions,
+      known_entities: visibleEntities,
+      visibility_policy: this.policy
+    });
+  }
+  healthCheck() {
+    if (!isDir7(this.automationsDir)) {
+      return {
+        status: "blocked",
+        reason: `Claude Code automations directory not found at ${this.automationsDir}.`,
+        details: { automations_dir: this.automationsDir },
+        proposedFix: "Create the automations directory and an automation.toml: mkdir -p ~/.claude/automations/<id> && $HOME/.claude/hooks/automation-memory-append.sh <id> '...'"
+      };
+    }
+    const configs = iterConfigs(this.automationsDir);
+    const runs = this.runs(configs);
+    const hasConfigs = configs.length > 0;
+    const status = hasConfigs ? "ok" : "degraded";
+    const details = {
+      automations_dir: this.automationsDir,
+      automation_count: configs.length,
+      memory_files: configs.filter((c) => c.memoryPath !== null).length,
+      runs_extracted: runs.length,
+      active_automations: configs.filter((c) => c.status === "ACTIVE").length
+    };
+    if (hasConfigs) {
+      return { status, details };
+    }
+    return {
+      status,
+      reason: "No automation.toml files found.",
+      details,
+      proposedFix: "Add Claude Code automation.toml files."
+    };
+  }
+  runs(configs, since) {
+    const runCutoff = since ? since.toISOString().slice(0, 10) : null;
+    const runs = [];
+    for (const config of configs ?? iterConfigs(this.automationsDir)) {
+      for (const run of extractMemoryRuns(config)) {
+        if (runCutoff && run.date < runCutoff) continue;
+        runs.push(run);
+      }
+    }
+    runs.sort((a, b) => {
+      if (a.date !== b.date) return a.date < b.date ? 1 : -1;
+      const ai = a.automation.automationId;
+      const bi = b.automation.automationId;
+      if (ai !== bi) return ai < bi ? 1 : -1;
+      return 0;
+    });
+    return runs;
+  }
+};
+
+// src/readers/codex-automations.ts
+var import_node_fs10 = require("fs");
+var import_node_os10 = require("os");
+var import_node_path10 = require("path");
+var import_smol_toml2 = require("smol-toml");
+var import_l510 = require("@getbourdon/l5");
+var import_redaction10 = require("@getbourdon/redaction");
+var AGENT_ID10 = "codex-automations";
+var AGENT_TYPE10 = "other";
+var ROLE_NARRATIVE10 = "Publishes read-only Codex automation run memory into Bourdon so background monitors, digests, and recurring checks are visible alongside interactive agent sessions.";
+var DEFAULT_POLICY9 = (0, import_l510.makeVisibilityPolicy)({
+  default: import_l510.Visibility.TEAM,
+  private_tags: ["personal", "financial", "credential", "health", "family", "legal"],
+  team_tags: ["codex-automation", "automation", "workspace"]
+});
+var AUTOMATIONS_DIR_NAME2 = "automations";
+var AUTOMATION_TOML2 = "automation.toml";
+var MEMORY_MD2 = "memory.md";
+var MAX_MEMORY_CHARS2 = 16e4;
+var MAX_KEY_ACTIONS_PER_RUN2 = 6;
+var MAX_KEY_ACTION_CHARS3 = 280;
+var RUN_HEADER_RE2 = /^(\d{4}-\d{2}-\d{2})(?:\b|$)(.*)$/;
+var PROJECT_HINTS2 = [
+  "ShipStable",
+  "ILTT",
+  "Prun",
+  "PRUN",
+  "OMNIvour",
+  "Castmore",
+  "Bourdon",
+  "RADLAB",
+  "CHIP",
+  "Claude Brain",
+  "Cursor",
+  "Copilot"
+];
+var SIGNAL_PATTERNS2 = [
+  ["human-dashboard-action", /\b(human|ryan|dashboard|manual)\b/i],
+  ["release-gate", /\b(release|store|app review|play console|testflight)\b/i],
+  ["billing-drift", /\b(billing|stripe|revenuecat|iap|subscription)\b/i],
+  ["memory-coverage-gap", /\b(memory|l5|manifest|federated|bourdon)\b/i],
+  ["launch-decision", /\b(launch|go-live|pricing|prod|production)\b/i]
+];
+var logger4 = {
+  warn(msg) {
+    console.warn(`[bourdon.participants] ${msg}`);
+  }
+};
+function homeDir6() {
+  try {
+    return (0, import_node_os10.homedir)();
+  } catch {
+    return process.env.HOME || process.env.USERPROFILE || ".";
+  }
+}
+function isDir8(p) {
+  try {
+    return (0, import_node_fs10.statSync)(p).isDirectory();
+  } catch {
+    return false;
+  }
+}
+function isFile8(p) {
+  try {
+    return (0, import_node_fs10.statSync)(p).isFile();
+  } catch {
+    return false;
+  }
+}
+function defaultCodexAutomationsDir(codexHome) {
+  if (codexHome !== void 0 && codexHome !== null) {
+    return (0, import_node_path10.join)(codexHome, AUTOMATIONS_DIR_NAME2);
+  }
+  const env = process.env.CODEX_HOME;
+  if (env) return (0, import_node_path10.join)(env, AUTOMATIONS_DIR_NAME2);
+  return (0, import_node_path10.join)(homeDir6(), ".codex", AUTOMATIONS_DIR_NAME2);
+}
+function safeNativeMemoryText4(value) {
+  return (0, import_redaction10.redactText)(value, 180);
+}
+function pyStrOr(a, b) {
+  return String(a ? a : b);
+}
+function readAutomationToml2(path) {
+  let text;
+  try {
+    text = (0, import_node_fs10.readFileSync)(path, "utf8");
+  } catch (exc) {
+    logger4.warn(`CodexAutomationsParticipant: cannot parse ${path}: ${String(exc)}`);
+    return {};
+  }
+  try {
+    const parsed = (0, import_smol_toml2.parse)(text);
+    return typeof parsed === "object" && parsed !== null && !Array.isArray(parsed) ? parsed : {};
+  } catch (exc) {
+    logger4.warn(`CodexAutomationsParticipant: cannot parse ${path}: ${String(exc)}`);
+    return {};
+  }
+}
+function buildConfig2(tomlPath) {
+  const raw = readAutomationToml2(tomlPath);
+  const parentName = (0, import_node_path10.basename)((0, import_node_path10.dirname)(tomlPath));
+  const automationId = pyStrOr(raw["id"], parentName).trim();
+  if (!automationId) return null;
+  const name = pyStrOr(raw["name"], automationId).trim();
+  const status = pyStrOr(raw["status"], "UNKNOWN").trim().toUpperCase();
+  const rrule = pyStrOr(raw["rrule"], "").trim();
+  const kind = pyStrOr(raw["kind"], "").trim();
+  const cwdsRaw = raw["cwds"];
+  const cwds = Array.isArray(cwdsRaw) ? cwdsRaw.filter((cwd) => typeof cwd === "string" && cwd.trim() !== "") : [];
+  const memoryPath = (0, import_node_path10.join)((0, import_node_path10.dirname)(tomlPath), MEMORY_MD2);
+  return {
+    automationId,
+    name,
+    status,
+    rrule,
+    kind,
+    cwds,
+    path: tomlPath,
+    memoryPath: isFile8(memoryPath) ? memoryPath : null
+  };
+}
+function iterConfigs2(automationsDir) {
+  if (!isDir8(automationsDir)) return [];
+  let entries;
+  try {
+    entries = (0, import_node_fs10.readdirSync)(automationsDir);
+  } catch {
+    return [];
+  }
+  const tomlPaths = [];
+  for (const entry of entries) {
+    const tomlPath = (0, import_node_path10.join)(automationsDir, entry, AUTOMATION_TOML2);
+    if (isFile8(tomlPath)) tomlPaths.push(tomlPath);
+  }
+  tomlPaths.sort((a, b) => a < b ? -1 : a > b ? 1 : 0);
+  const configs = [];
+  for (const tomlPath of tomlPaths) {
+    const config = buildConfig2(tomlPath);
+    if (config !== null) configs.push(config);
+  }
+  return configs;
+}
+function readMemoryText2(path) {
+  if (path === null) return "";
+  let text;
+  try {
+    text = (0, import_node_fs10.readFileSync)(path, "utf8");
+  } catch (exc) {
+    logger4.warn(`CodexAutomationsParticipant: cannot read ${path}: ${String(exc)}`);
+    return "";
+  }
+  return text.length > MAX_MEMORY_CHARS2 ? text.slice(-MAX_MEMORY_CHARS2) : text;
+}
+function splitLines2(text) {
+  return text.split(/\r\n|[\n\r\v\f\x1c\x1d\x1e\x85\u2028\u2029]/);
+}
+function rstrip2(s) {
+  return s.replace(/\s+$/, "");
+}
+function collapseWhitespace(value) {
+  return value.split(/\s+/).filter((p) => p.length > 0).join(" ");
+}
+function bounded4(value, limit) {
+  const normalized = collapseWhitespace(value);
+  if (normalized.length <= limit) return normalized;
+  return rstrip2(normalized.slice(0, limit - 1)) + "...";
+}
+function actionsFromLines2(lines) {
+  const actions = [];
+  for (const line of lines) {
+    let cleaned = line.trim();
+    if (!cleaned) continue;
+    cleaned = (cleaned.startsWith("- ") ? cleaned.slice(2) : cleaned).trim();
+    const lowered = cleaned.toLowerCase();
+    if (!cleaned || lowered.startsWith("runtime")) continue;
+    if (lowered === "first run" || lowered === "follow-up") continue;
+    if (lowered.startsWith("run:")) cleaned = cleaned.slice(4).trim();
+    const safe = bounded4(safeNativeMemoryText4(cleaned), MAX_KEY_ACTION_CHARS3);
+    if (safe && !actions.includes(safe)) actions.push(safe);
+    if (actions.length >= MAX_KEY_ACTIONS_PER_RUN2) break;
+  }
+  return actions;
+}
+function titleFromActions2(config, actions) {
+  if (actions.length === 0) return config.name;
+  const first = actions[0];
+  const prefix = `${config.name}: `;
+  if (first.startsWith(prefix)) return bounded4(first, 120);
+  return bounded4(prefix + first, 120);
+}
+function inferProjects2(text) {
+  const projects = [];
+  const lowered = text.toLowerCase();
+  const seen = /* @__PURE__ */ new Set();
+  for (const project of PROJECT_HINTS2) {
+    const key = project.toLowerCase();
+    if (lowered.includes(key) && !seen.has(key)) {
+      projects.push(project);
+      seen.add(key);
+    }
+  }
+  return projects;
+}
+function inferSignals2(text) {
+  const signals = [];
+  for (const [name, pattern] of SIGNAL_PATTERNS2) {
+    if (pattern.test(text)) signals.push(name);
+  }
+  return signals;
+}
+function extractMemoryRuns2(config) {
+  const text = readMemoryText2(config.memoryPath);
+  if (!text) return [];
+  const chunks = [];
+  let currentDate = "";
+  let currentLines = [];
+  for (const rawLine of splitLines2(text)) {
+    const line = rstrip2(rawLine);
+    const match = RUN_HEADER_RE2.exec(line.trim());
+    if (match) {
+      if (currentDate) chunks.push([currentDate, currentLines]);
+      currentDate = match[1];
+      const suffix = stripChars3(match[2].trim(), " -:\u2014");
+      currentLines = suffix ? [suffix] : [];
+      continue;
+    }
+    if (currentDate) currentLines.push(line);
+  }
+  if (currentDate) chunks.push([currentDate, currentLines]);
+  const runs = [];
+  for (const [runDate, lines] of chunks) {
+    const actions = actionsFromLines2(lines);
+    if (actions.length === 0) continue;
+    const body = actions.join(" ");
+    const title = titleFromActions2(config, actions);
+    runs.push({
+      automation: config,
+      date: runDate,
+      title,
+      keyActions: actions,
+      projects: inferProjects2(body),
+      signals: inferSignals2(body)
+    });
+  }
+  return runs;
+}
+function stripChars3(s, chars) {
+  let start = 0;
+  let end = s.length;
+  while (start < end && chars.includes(s[start])) start++;
+  while (end > start && chars.includes(s[end - 1])) end--;
+  return s.slice(start, end);
+}
+function sessionFromRun2(run) {
+  const config = run.automation;
+  const keyActions3 = [
+    `automation_id: ${config.automationId}`,
+    `run: ${run.title}`,
+    ...run.keyActions
+  ];
+  const filesTouched = [config.path];
+  if (config.memoryPath !== null) filesTouched.push(config.memoryPath);
+  return (0, import_l510.makeSession)({
+    date: run.date,
+    cwd: config.cwds.length > 0 ? config.cwds[0] : (0, import_node_path10.dirname)(config.path),
+    project_focus: [...run.projects],
+    key_actions: keyActions3.slice(0, MAX_KEY_ACTIONS_PER_RUN2 + 2),
+    files_touched: filesTouched,
+    visibility: import_l510.Visibility.TEAM
+  });
+}
+function entitiesFromConfigsAndRuns2(configs, runs) {
+  const byName = /* @__PURE__ */ new Map();
+  for (const config of configs) {
+    byName.set(
+      config.automationId,
+      (0, import_l510.makeEntity)({
+        name: config.automationId,
+        type: "automation",
+        summary: bounded4(
+          `Codex automation '${config.name}' (${config.status}). Schedule: ${config.rrule || "unspecified"}.`,
+          260
+        ),
+        last_touched: void 0,
+        tags: ["codex-automation", "automation", config.status.toLowerCase()],
+        visibility: import_l510.Visibility.TEAM
+      })
+    );
+  }
+  for (const run of runs) {
+    for (const project of run.projects) {
+      if (!byName.has(project)) {
+        byName.set(
+          project,
+          (0, import_l510.makeEntity)({
+            name: project,
+            type: "project",
+            summary: "Project mentioned by Codex automation run memory.",
+            last_touched: run.date,
+            tags: ["codex-automation", "automation-evidence"],
+            visibility: import_l510.Visibility.TEAM
+          })
+        );
+      }
+    }
+    for (const signal of run.signals) {
+      if (!byName.has(signal)) {
+        byName.set(
+          signal,
+          (0, import_l510.makeEntity)({
+            name: signal,
+            type: "automation-signal",
+            summary: "Signal class inferred from Codex automation run memory.",
+            last_touched: run.date,
+            tags: ["codex-automation", "automation-signal"],
+            visibility: import_l510.Visibility.TEAM
+          })
+        );
+      }
+    }
+  }
+  return [...byName.values()];
+}
+var CodexAutomationsParticipant = class {
+  agentId = AGENT_ID10;
+  agentType = AGENT_TYPE10;
+  automationsDir;
+  policy;
+  /**
+   * Conventional Codex automations dir (`~/.codex/automations`). Provided for
+   * protocol uniformity — the setup wizard wires the parent `codex` participant
+   * and skips `-automations` sub-surfaces rather than detecting this one.
+   */
+  static defaultNativePath(home) {
+    return defaultCodexAutomationsDir(home);
+  }
+  constructor(automationsDir, codexHome) {
+    this.automationsDir = automationsDir ?? defaultCodexAutomationsDir(codexHome);
+    this.policy = DEFAULT_POLICY9;
+  }
+  get nativePath() {
+    return this.automationsDir;
+  }
+  discover() {
+    if (!isDir8(this.automationsDir)) {
+      throw new ParticipantDiscoveryError(
+        `Codex automations directory not found at ${this.automationsDir}.`
+      );
+    }
+    const configs = iterConfigs2(this.automationsDir);
+    return {
+      path: this.automationsDir,
+      version: "unknown",
+      metadata: {
+        automations: configs.length,
+        with_memory: configs.filter((c) => c.memoryPath !== null).length
+      }
+    };
+  }
+  exportSessions(since, limit = 100) {
+    const sessions = this.runs(void 0, since).map(sessionFromRun2);
+    sessions.sort((a, b) => a.date < b.date ? 1 : a.date > b.date ? -1 : 0);
+    return sessions.slice(0, limit);
+  }
+  exportL5(since) {
+    const configs = iterConfigs2(this.automationsDir);
+    const runs = this.runs(configs, since);
+    const sessions = runs.map(sessionFromRun2);
+    sessions.sort((a, b) => a.date < b.date ? 1 : a.date > b.date ? -1 : 0);
+    const entities = entitiesFromConfigsAndRuns2(configs, runs);
+    const visibleEntities = (0, import_l510.filterForFederation)(entities, this.policy);
+    return (0, import_l510.makeManifest)({
+      spec_version: SPEC_VERSION,
+      agent: (0, import_l510.makeAgentInfo)({
+        id: AGENT_ID10,
+        type: AGENT_TYPE10,
+        instance: (0, import_node_os10.hostname)(),
+        spec_version_compat: SPEC_VERSION,
+        role_narrative: ROLE_NARRATIVE10
+      }),
+      last_updated: (/* @__PURE__ */ new Date()).toISOString(),
+      capabilities: ["codex-automation-memory", "run-summary-publication"],
+      recent_sessions: sessions,
+      known_entities: visibleEntities,
+      visibility_policy: this.policy
+    });
+  }
+  healthCheck() {
+    if (!isDir8(this.automationsDir)) {
+      return {
+        status: "blocked",
+        reason: `Codex automations directory not found at ${this.automationsDir}.`,
+        details: { automations_dir: this.automationsDir },
+        proposedFix: "Create Codex automations or pass --automations-dir."
+      };
+    }
+    const configs = iterConfigs2(this.automationsDir);
+    const runs = this.runs(configs);
+    const hasConfigs = configs.length > 0;
+    return {
+      status: hasConfigs ? "ok" : "degraded",
+      reason: hasConfigs ? void 0 : "No automation.toml files found.",
+      details: {
+        automations_dir: this.automationsDir,
+        automation_count: configs.length,
+        memory_files: configs.filter((c) => c.memoryPath !== null).length,
+        runs_extracted: runs.length,
+        active_automations: configs.filter((c) => c.status === "ACTIVE").length
+      },
+      proposedFix: hasConfigs ? void 0 : "Add Codex automation.toml files."
+    };
+  }
+  // -- Internal ---------------------------------------------------------------
+  runs(configs, since) {
+    const runCutoff = since ? since.toISOString().slice(0, 10) : null;
+    const runs = [];
+    for (const config of configs ?? iterConfigs2(this.automationsDir)) {
+      for (const run of extractMemoryRuns2(config)) {
+        if (runCutoff && run.date < runCutoff) continue;
+        runs.push(run);
+      }
+    }
+    runs.sort((a, b) => {
+      if (a.date !== b.date) return a.date < b.date ? 1 : -1;
+      const ai = a.automation.automationId;
+      const bi = b.automation.automationId;
+      if (ai !== bi) return ai < bi ? 1 : -1;
+      return 0;
+    });
+    return runs;
+  }
+};
+
+// src/readers/copilot-automations.ts
+var import_node_fs11 = require("fs");
+var import_node_os11 = require("os");
+var import_node_path11 = require("path");
+var import_smol_toml3 = require("smol-toml");
+var import_l511 = require("@getbourdon/l5");
+var import_redaction11 = require("@getbourdon/redaction");
+var AGENT_ID11 = "copilot-automations";
+var AGENT_TYPE11 = "other";
+var DISPLAY_NAME7 = "GitHub Copilot \xB7 Automations";
+var ROLE_NARRATIVE11 = "Publishes read-only Copilot automation run memory into Bourdon so GitHub Actions-triggered Copilot tasks, scheduled PR reviews, issue triage, and other event-driven Copilot work are visible alongside interactive agent sessions.";
+var DEFAULT_POLICY10 = (0, import_l511.makeVisibilityPolicy)({
+  default: import_l511.Visibility.TEAM,
+  private_tags: ["personal", "financial", "credential", "health", "family", "legal"],
+  team_tags: ["copilot-automation", "automation", "github-actions", "workspace"]
+});
+var CONVENTION_DIR_NAME3 = ".copilot-bourdon";
+var AUTOMATIONS_DIR = "automations";
+var AUTOMATION_TOML3 = "automation.toml";
+var MEMORY_MD3 = "memory.md";
+var MAX_MEMORY_CHARS3 = 16e4;
+var MAX_KEY_ACTIONS_PER_RUN3 = 6;
+var MAX_KEY_ACTION_CHARS4 = 280;
+var RUN_HEADER_RE3 = /^(\d{4}-\d{2}-\d{2})(?:\b|$)(.*)$/;
+var logger5 = {
+  warn(msg) {
+    console.warn(`[bourdon.participants] ${msg}`);
+  }
+};
+function homeDir7() {
+  try {
+    return (0, import_node_os11.homedir)();
+  } catch {
+    return process.env.HOME || process.env.USERPROFILE || ".";
+  }
+}
+function isDir9(p) {
+  try {
+    return (0, import_node_fs11.statSync)(p).isDirectory();
+  } catch {
+    return false;
+  }
+}
+function isFile9(p) {
+  try {
+    return (0, import_node_fs11.statSync)(p).isFile();
+  } catch {
+    return false;
+  }
+}
+function isRecord5(v) {
+  return typeof v === "object" && v !== null && !Array.isArray(v);
+}
+function pyTruthy(v) {
+  if (v === null || v === void 0 || v === false) return false;
+  if (typeof v === "string") return v.length > 0;
+  if (typeof v === "number") return v !== 0;
+  if (Array.isArray(v)) return v.length > 0;
+  return true;
+}
+function pyStr2(v) {
+  if (typeof v === "string") return v;
+  if (typeof v === "boolean") return v ? "True" : "False";
+  if (v === null || v === void 0) return "None";
+  return String(v);
+}
+function defaultCopilotAutomationsDir(copilotBourdonDir) {
+  const env = process.env.COPILOT_AUTOMATIONS_HOME;
+  if (env) return env;
+  const base = copilotBourdonDir || (0, import_node_path11.join)(homeDir7(), CONVENTION_DIR_NAME3);
+  return (0, import_node_path11.join)(base, AUTOMATIONS_DIR);
+}
+function readAutomationToml3(path) {
+  let text;
+  try {
+    text = (0, import_node_fs11.readFileSync)(path, "utf8");
+  } catch (exc) {
+    logger5.warn(`CopilotAutomationsParticipant: cannot parse ${path}: ${String(exc)}`);
+    return {};
+  }
+  try {
+    const parsed = (0, import_smol_toml3.parse)(text);
+    return isRecord5(parsed) ? parsed : {};
+  } catch (exc) {
+    logger5.warn(`CopilotAutomationsParticipant: cannot parse ${path}: ${String(exc)}`);
+    return {};
+  }
+}
+function buildConfig3(tomlPath) {
+  const raw = readAutomationToml3(tomlPath);
+  const parentDir = (0, import_node_path11.dirname)(tomlPath);
+  const parentName = parentDir.split(/[\\/]/).filter(Boolean).pop() ?? "";
+  const automationId = pyStr2(pyTruthy(raw["id"]) ? raw["id"] : parentName).trim();
+  if (!automationId) return null;
+  const name = pyStr2(pyTruthy(raw["name"]) ? raw["name"] : automationId).trim();
+  const status = pyStr2(pyTruthy(raw["status"]) ? raw["status"] : "UNKNOWN").trim().toUpperCase();
+  const trigger = pyStr2(pyTruthy(raw["trigger"]) ? raw["trigger"] : "").trim();
+  const kind = pyStr2(pyTruthy(raw["kind"]) ? raw["kind"] : "").trim();
+  const reposRaw = pyTruthy(raw["repos"]) ? raw["repos"] : [];
+  const reposIter = Array.isArray(reposRaw) ? reposRaw : typeof reposRaw === "string" ? Array.from(reposRaw) : [];
+  const repos = reposIter.filter(
+    (r) => typeof r === "string" && r.trim() !== ""
+  );
+  const memoryPath = (0, import_node_path11.join)(parentDir, MEMORY_MD3);
+  return {
+    automationId,
+    name,
+    status,
+    trigger,
+    kind,
+    repos,
+    path: tomlPath,
+    memoryPath: isFile9(memoryPath) ? memoryPath : null
+  };
+}
+function iterConfigs3(automationsDir) {
+  const configs = [];
+  if (!isDir9(automationsDir)) return configs;
+  let entries;
+  try {
+    entries = (0, import_node_fs11.readdirSync)(automationsDir);
+  } catch {
+    return configs;
+  }
+  const tomlPaths = [];
+  for (const entry of entries) {
+    const candidate = (0, import_node_path11.join)(automationsDir, entry, AUTOMATION_TOML3);
+    if (isFile9(candidate)) tomlPaths.push(candidate);
+  }
+  tomlPaths.sort((a, b) => a < b ? -1 : a > b ? 1 : 0);
+  for (const tomlPath of tomlPaths) {
+    const config = buildConfig3(tomlPath);
+    if (config !== null) configs.push(config);
+  }
+  return configs;
+}
+function splitLines3(text) {
+  if (text.length === 0) return [];
+  return text.split(/\r\n|\r|\n|\v|\f|\x1c|\x1d|\x1e|\x85|\u2028|\u2029/);
+}
+function rstrip3(s) {
+  return s.replace(/\s+$/u, "");
+}
+function stripChars4(s, chars) {
+  let start = 0;
+  let end = s.length;
+  while (start < end && chars.includes(s[start])) start++;
+  while (end > start && chars.includes(s[end - 1])) end--;
+  return s.slice(start, end);
+}
+function extractMemoryRuns3(config) {
+  if (config.memoryPath === null) return [];
+  let text;
+  try {
+    text = (0, import_node_fs11.readFileSync)(config.memoryPath, "utf8");
+  } catch (exc) {
+    logger5.warn(
+      `CopilotAutomationsParticipant: cannot read ${config.memoryPath}: ${String(exc)}`
+    );
+    return [];
+  }
+  text = text.slice(-MAX_MEMORY_CHARS3);
+  const chunks = [];
+  let currentDate = "";
+  let currentLines = [];
+  for (const rawLine of splitLines3(text)) {
+    const line = rstrip3(rawLine);
+    const match = RUN_HEADER_RE3.exec(line.trim());
+    if (match) {
+      if (currentDate) chunks.push([currentDate, currentLines]);
+      currentDate = match[1];
+      const suffix = stripChars4((match[2] ?? "").trim(), " -:\u2014");
+      currentLines = suffix ? [suffix] : [];
+      continue;
+    }
+    if (currentDate) currentLines.push(line);
+  }
+  if (currentDate) chunks.push([currentDate, currentLines]);
+  const runs = [];
+  for (const [runDate, lines] of chunks) {
+    const actions = actionsFromLines3(lines);
+    if (actions.length === 0) continue;
+    const title = titleFromActions3(config, actions);
+    runs.push({
+      automation: config,
+      date: runDate,
+      title,
+      keyActions: actions,
+      repos: config.repos
+    });
+  }
+  return runs;
+}
+function actionsFromLines3(lines) {
+  const actions = [];
+  for (const line of lines) {
+    let cleaned = line.trim();
+    if (!cleaned) continue;
+    cleaned = (cleaned.startsWith("- ") ? cleaned.slice(2) : cleaned).trim();
+    if (!cleaned || cleaned.toLowerCase().startsWith("runtime")) continue;
+    const safe = bounded5(safeNativeMemoryText5(cleaned), MAX_KEY_ACTION_CHARS4);
+    if (safe && !actions.includes(safe)) actions.push(safe);
+    if (actions.length >= MAX_KEY_ACTIONS_PER_RUN3) break;
+  }
+  return actions;
+}
+function titleFromActions3(config, actions) {
+  if (actions.length === 0) return config.name;
+  const first = actions[0];
+  const prefix = `${config.name}: `;
+  if (first.startsWith(prefix)) return bounded5(first, 120);
+  return bounded5(prefix + first, 120);
+}
+function bounded5(value, limit) {
+  const normalized = value.split(/\s+/u).filter((x) => x.length > 0).join(" ");
+  if (normalized.length <= limit) return normalized;
+  return rstrip3(normalized.slice(0, limit - 1)) + "\u2026";
+}
+function safeNativeMemoryText5(value) {
+  return (0, import_redaction11.redactText)(value, 180);
+}
+function sessionFromRun3(run) {
+  const config = run.automation;
+  const keyActions3 = [
+    `automation: ${config.automationId}`,
+    config.trigger ? `trigger: ${config.trigger}` : `kind: ${config.kind}`,
+    `run: ${run.title}`,
+    ...run.keyActions
+  ];
+  return (0, import_l511.makeSession)({
+    date: run.date,
+    cwd: (0, import_node_path11.dirname)(config.path),
+    project_focus: [...run.repos],
+    key_actions: keyActions3.slice(0, MAX_KEY_ACTIONS_PER_RUN3 + 3),
+    files_touched: [config.path],
+    visibility: import_l511.Visibility.TEAM
+  });
+}
+function entitiesFromConfigsAndRuns3(configs, runs) {
+  const entities = /* @__PURE__ */ new Map();
+  for (const config of configs) {
+    entities.set(
+      config.automationId,
+      (0, import_l511.makeEntity)({
+        name: config.automationId,
+        type: "automation",
+        summary: bounded5(
+          `Copilot automation '${config.name}' (${config.status}). Trigger: ${config.trigger || "unspecified"}. Kind: ${config.kind || "unspecified"}.`,
+          260
+        ),
+        last_touched: void 0,
+        tags: ["copilot-automation", "automation", config.status.toLowerCase()],
+        visibility: import_l511.Visibility.TEAM
+      })
+    );
+  }
+  for (const run of runs) {
+    for (const repo of run.repos) {
+      if (!entities.has(repo)) {
+        entities.set(
+          repo,
+          (0, import_l511.makeEntity)({
+            name: repo,
+            type: "project",
+            summary: "Repository targeted by Copilot automation.",
+            last_touched: run.date,
+            tags: ["copilot-automation", "project"],
+            visibility: import_l511.Visibility.TEAM
+          })
+        );
+      }
+    }
+  }
+  return [...entities.values()];
+}
+var CopilotAutomationsParticipant = class {
+  agentId = AGENT_ID11;
+  agentType = AGENT_TYPE11;
+  displayName = DISPLAY_NAME7;
+  automationsDir;
+  policy;
+  /** Conventional automations dir (`~/.copilot-bourdon/automations`). Does NOT
+   * consult `COPILOT_AUTOMATIONS_HOME` (matches Python `default_native_path`). */
+  static defaultNativePath(home) {
+    const base = (0, import_node_path11.join)(home ?? homeDir7(), CONVENTION_DIR_NAME3);
+    return (0, import_node_path11.join)(base, AUTOMATIONS_DIR);
+  }
+  constructor(automationsDir) {
+    this.automationsDir = automationsDir ?? defaultCopilotAutomationsDir();
+    this.policy = DEFAULT_POLICY10;
+  }
+  get nativePath() {
+    return this.automationsDir;
+  }
+  // -- Protocol surface -------------------------------------------------------
+  discover() {
+    if (!isDir9(this.automationsDir)) {
+      throw new ParticipantDiscoveryError(
+        `Copilot automations directory not found at ${this.automationsDir}. Run \`bourdon copilot-automations init <name>\` to create one.`
+      );
+    }
+    const configs = iterConfigs3(this.automationsDir);
+    return {
+      path: this.automationsDir,
+      version: "convention-v1",
+      metadata: {
+        automations: configs.length,
+        with_memory: configs.filter((c) => c.memoryPath !== null).length
+      }
+    };
+  }
+  exportSessions(since, limit = 100) {
+    const sessions = this.runs(void 0, since).map(sessionFromRun3);
+    sessions.sort((a, b) => a.date < b.date ? 1 : a.date > b.date ? -1 : 0);
+    return sessions.slice(0, limit);
+  }
+  exportL5(since) {
+    const configs = iterConfigs3(this.automationsDir);
+    const runs = this.runs(configs, since);
+    const sessions = runs.map(sessionFromRun3);
+    sessions.sort((a, b) => a.date < b.date ? 1 : a.date > b.date ? -1 : 0);
+    const entities = entitiesFromConfigsAndRuns3(configs, runs);
+    const visibleEntities = (0, import_l511.filterForFederation)(entities, this.policy);
+    return (0, import_l511.makeManifest)({
+      spec_version: SPEC_VERSION,
+      agent: (0, import_l511.makeAgentInfo)({
+        id: AGENT_ID11,
+        type: AGENT_TYPE11,
+        instance: (0, import_node_os11.hostname)() || "unknown",
+        spec_version_compat: `>=${SPEC_VERSION}`,
+        role_narrative: ROLE_NARRATIVE11
+      }),
+      last_updated: (/* @__PURE__ */ new Date()).toISOString(),
+      capabilities: ["copilot-automation-memory", "run-summary-publication"],
+      recent_sessions: sessions,
+      known_entities: visibleEntities,
+      visibility_policy: this.policy
+    });
+  }
+  healthCheck() {
+    if (!isDir9(this.automationsDir)) {
+      return {
+        status: "blocked",
+        reason: `Copilot automations directory not found at ${this.automationsDir}.`,
+        details: { automations_dir: this.automationsDir },
+        proposedFix: "Run `bourdon copilot-automations init <name>` to create an automation."
+      };
+    }
+    const configs = iterConfigs3(this.automationsDir);
+    const runs = this.runs(configs);
+    const hasConfigs = configs.length > 0;
+    return {
+      status: hasConfigs ? "ok" : "degraded",
+      reason: hasConfigs ? void 0 : "No automation.toml files found.",
+      details: {
+        automations_dir: this.automationsDir,
+        automation_count: configs.length,
+        memory_files: configs.filter((c) => c.memoryPath !== null).length,
+        runs_extracted: runs.length,
+        active_automations: configs.filter((c) => c.status === "ACTIVE").length
+      },
+      proposedFix: hasConfigs ? void 0 : "Run `bourdon copilot-automations init <name>` to create an automation, or add automation.toml files manually."
+    };
+  }
+  // -- Internal ---------------------------------------------------------------
+  runs(configs, since) {
+    const runCutoff = since ? since.toISOString().slice(0, 10) : null;
+    const out = [];
+    for (const config of configs ?? iterConfigs3(this.automationsDir)) {
+      for (const run of extractMemoryRuns3(config)) {
+        if (runCutoff && run.date < runCutoff) continue;
+        out.push(run);
+      }
+    }
+    out.sort((a, b) => {
+      if (a.date !== b.date) return a.date < b.date ? 1 : -1;
+      const ai = a.automation.automationId;
+      const bi = b.automation.automationId;
+      if (ai !== bi) return ai < bi ? 1 : -1;
+      return 0;
+    });
+    return out;
+  }
+};
+
+// src/readers/cursor-automations.ts
+var import_node_fs12 = require("fs");
+var import_node_os12 = require("os");
+var import_node_path12 = require("path");
+var import_smol_toml4 = require("smol-toml");
+var import_l512 = require("@getbourdon/l5");
+var import_redaction12 = require("@getbourdon/redaction");
+var AGENT_ID12 = "cursor-automations";
+var AGENT_TYPE12 = "other";
+var ROLE_NARRATIVE12 = "Publishes read-only Cursor Cloud Agent automation run memory into Bourdon so background PR reviews, code generation tasks, and scheduled agent runs become visible alongside interactive Cursor IDE sessions.";
+var DEFAULT_POLICY11 = (0, import_l512.makeVisibilityPolicy)({
+  default: import_l512.Visibility.TEAM,
+  private_tags: ["personal", "financial", "credential", "health", "family", "legal"],
+  team_tags: ["cursor-automation", "automation", "workspace"]
+});
+var AUTOMATIONS_DIR_NAME3 = "automations";
+var AUTOMATION_TOML4 = "automation.toml";
+var MEMORY_MD4 = "memory.md";
+var MAX_MEMORY_CHARS4 = 16e4;
+var MAX_KEY_ACTIONS_PER_RUN4 = 6;
+var MAX_KEY_ACTION_CHARS5 = 280;
+var RUN_HEADER_RE4 = /^(\d{4}-\d{2}-\d{2})(?:\b|$)(.*)$/;
+var HEADER_SUFFIX_STRIP2 = " -:\u2014";
+var PROJECT_HINTS3 = [
+  "ShipStable",
+  "ILTT",
+  "Prun",
+  "PRUN",
+  "OMNIvour",
+  "Castmore",
+  "Bourdon",
+  "RADLAB",
+  "CHIP",
+  "Claude Brain",
+  "Cursor",
+  "Copilot",
+  "Codex",
+  "Cascade"
+];
+var SIGNAL_PATTERNS3 = [
+  ["human-dashboard-action", /\b(human|ryan|dashboard|manual)\b/i],
+  ["release-gate", /\b(release|store|app review|play console|testflight)\b/i],
+  ["billing-drift", /\b(billing|stripe|revenuecat|iap|subscription)\b/i],
+  ["memory-coverage-gap", /\b(memory|l5|manifest|federated|bourdon)\b/i],
+  ["launch-decision", /\b(launch|go-live|pricing|prod|production)\b/i],
+  ["ci-signal", /\b(github action|workflow run|ci|cd|deploy|pipeline)\b/i]
+];
+var logger6 = {
+  warn(msg) {
+    console.warn(`[bourdon.participants] ${msg}`);
+  }
+};
+function homeDir8() {
+  try {
+    return (0, import_node_os12.homedir)();
+  } catch {
+    return process.env.HOME || process.env.USERPROFILE || ".";
+  }
+}
+function isDir10(p) {
+  try {
+    return (0, import_node_fs12.statSync)(p).isDirectory();
+  } catch {
+    return false;
+  }
+}
+function isFile10(p) {
+  try {
+    return (0, import_node_fs12.statSync)(p).isFile();
+  } catch {
+    return false;
+  }
+}
+function pyFalsy(v) {
+  return v === void 0 || v === null || v === "" || v === 0 || v === false;
+}
+function strOr2(v, fallback) {
+  return String(pyFalsy(v) ? fallback : v);
+}
+function stripChars5(s, chars) {
+  let start = 0;
+  let end = s.length;
+  while (start < end && chars.includes(s[start])) start++;
+  while (end > start && chars.includes(s[end - 1])) end--;
+  return s.slice(start, end);
+}
+function rstrip4(s) {
+  return s.replace(/\s+$/, "");
+}
+function bounded6(value, limit) {
+  const trimmed = value.trim();
+  const normalized = trimmed === "" ? "" : trimmed.split(/\s+/).join(" ");
+  if (normalized.length <= limit) return normalized;
+  return rstrip4(normalized.slice(0, limit - 1)) + "...";
+}
+function safeNativeMemoryText6(value) {
+  return (0, import_redaction12.redactText)(value, 180);
+}
+function defaultCursorAutomationsDir(cursorHome) {
+  if (cursorHome !== void 0 && cursorHome !== null) {
+    return (0, import_node_path12.join)(cursorHome, AUTOMATIONS_DIR_NAME3);
+  }
+  const env = process.env.CURSOR_DIR || process.env.CURSOR_HOME;
+  if (env) return (0, import_node_path12.join)(env, AUTOMATIONS_DIR_NAME3);
+  return (0, import_node_path12.join)(homeDir8(), ".cursor", AUTOMATIONS_DIR_NAME3);
+}
+function readAutomationToml4(path) {
+  let text;
+  try {
+    text = (0, import_node_fs12.readFileSync)(path, "utf8");
+  } catch (exc) {
+    logger6.warn(`CursorAutomationsParticipant: cannot parse ${path}: ${String(exc)}`);
+    return {};
+  }
+  try {
+    const parsed = (0, import_smol_toml4.parse)(text);
+    return typeof parsed === "object" && parsed !== null && !Array.isArray(parsed) ? parsed : {};
+  } catch (exc) {
+    logger6.warn(`CursorAutomationsParticipant: cannot parse ${path}: ${String(exc)}`);
+    return {};
+  }
+}
+function buildConfig4(tomlPath) {
+  const raw = readAutomationToml4(tomlPath);
+  const parentName = basenameOf3((0, import_node_path12.dirname)(tomlPath));
+  const automationId = strOr2(raw["id"], parentName).trim();
+  if (!automationId) return null;
+  const name = strOr2(raw["name"], automationId).trim();
+  const status = strOr2(raw["status"], "UNKNOWN").trim().toUpperCase();
+  const rrule = strOr2(raw["rrule"], "").trim();
+  const kind = strOr2(raw["kind"], "").trim();
+  const cwdsRaw = raw["cwds"];
+  const cwds = [];
+  if (Array.isArray(cwdsRaw)) {
+    for (const cwd of cwdsRaw) {
+      if (typeof cwd === "string" && cwd.trim()) cwds.push(cwd);
+    }
+  } else if (typeof cwdsRaw === "string") {
+    for (const ch of cwdsRaw) {
+      if (ch.trim()) cwds.push(ch);
+    }
+  }
+  const memoryPath = (0, import_node_path12.join)((0, import_node_path12.dirname)(tomlPath), MEMORY_MD4);
+  return {
+    automationId,
+    name,
+    status,
+    rrule,
+    kind,
+    cwds,
+    path: tomlPath,
+    memoryPath: isFile10(memoryPath) ? memoryPath : null
+  };
+}
+function basenameOf3(p) {
+  const parts = p.split(/[\\/]+/).filter((x) => x !== "");
+  return parts.length ? parts[parts.length - 1] : "";
+}
+function iterConfigs4(automationsDir) {
+  const configs = [];
+  if (!isDir10(automationsDir)) return configs;
+  let names;
+  try {
+    names = (0, import_node_fs12.readdirSync)(automationsDir);
+  } catch {
+    return configs;
+  }
+  const tomlPaths = [];
+  for (const name of names) {
+    const tomlPath = (0, import_node_path12.join)(automationsDir, name, AUTOMATION_TOML4);
+    if (isFile10(tomlPath)) tomlPaths.push(tomlPath);
+  }
+  tomlPaths.sort((a, b) => a < b ? -1 : a > b ? 1 : 0);
+  for (const tomlPath of tomlPaths) {
+    const config = buildConfig4(tomlPath);
+    if (config !== null) configs.push(config);
+  }
+  return configs;
+}
+function readMemoryText3(path) {
+  if (path === null) return "";
+  let text;
+  try {
+    text = (0, import_node_fs12.readFileSync)(path, "utf8");
+  } catch (exc) {
+    logger6.warn(`CursorAutomationsParticipant: cannot read ${path}: ${String(exc)}`);
+    return "";
+  }
+  return text.slice(-MAX_MEMORY_CHARS4);
+}
+function extractMemoryRuns4(config) {
+  const text = readMemoryText3(config.memoryPath);
+  if (!text) return [];
+  const chunks = [];
+  let currentDate = "";
+  let currentLines = [];
+  for (const rawLine of text.split(/\r?\n/)) {
+    const line = rstrip4(rawLine);
+    const match = RUN_HEADER_RE4.exec(line.trim());
+    if (match) {
+      if (currentDate) chunks.push([currentDate, currentLines]);
+      currentDate = match[1];
+      const suffix = stripChars5(match[2].trim(), HEADER_SUFFIX_STRIP2);
+      currentLines = suffix ? [suffix] : [];
+      continue;
+    }
+    if (currentDate) currentLines.push(line);
+  }
+  if (currentDate) chunks.push([currentDate, currentLines]);
+  const runs = [];
+  for (const [runDate, lines] of chunks) {
+    const actions = actionsFromLines4(lines);
+    if (actions.length === 0) continue;
+    const body = actions.join(" ");
+    const title = titleFromActions4(config, actions);
+    runs.push({
+      automation: config,
+      date: runDate,
+      title,
+      keyActions: actions,
+      projects: inferProjects3(body),
+      signals: inferSignals3(body)
+    });
+  }
+  return runs;
+}
+function actionsFromLines4(lines) {
+  const actions = [];
+  for (const line of lines) {
+    let cleaned = line.trim();
+    if (!cleaned) continue;
+    cleaned = (cleaned.startsWith("- ") ? cleaned.slice(2) : cleaned).trim();
+    const lowered = cleaned.toLowerCase();
+    if (!cleaned || lowered.startsWith("runtime")) continue;
+    if (lowered === "first run" || lowered === "follow-up") continue;
+    if (lowered.startsWith("run:")) cleaned = cleaned.slice(4).trim();
+    const safe = bounded6(safeNativeMemoryText6(cleaned), MAX_KEY_ACTION_CHARS5);
+    if (safe && !actions.includes(safe)) actions.push(safe);
+    if (actions.length >= MAX_KEY_ACTIONS_PER_RUN4) break;
+  }
+  return actions;
+}
+function titleFromActions4(config, actions) {
+  if (actions.length === 0) return config.name;
+  const first = actions[0];
+  const prefix = `${config.name}: `;
+  if (first.startsWith(prefix)) return bounded6(first, 120);
+  return bounded6(prefix + first, 120);
+}
+function inferProjects3(text) {
+  const projects = [];
+  const lowered = text.toLowerCase();
+  const seen = /* @__PURE__ */ new Set();
+  for (const project of PROJECT_HINTS3) {
+    const key = project.toLowerCase();
+    if (lowered.includes(key) && !seen.has(key)) {
+      projects.push(project);
+      seen.add(key);
+    }
+  }
+  return projects;
+}
+function inferSignals3(text) {
+  const signals = [];
+  for (const [name, pattern] of SIGNAL_PATTERNS3) {
+    if (pattern.test(text)) signals.push(name);
+  }
+  return signals;
+}
+function sessionFromRun4(run) {
+  const config = run.automation;
+  const keyActions3 = [
+    `automation_id: ${config.automationId}`,
+    `run: ${run.title}`,
+    ...run.keyActions
+  ];
+  const filesTouched = [config.path];
+  if (config.memoryPath !== null) filesTouched.push(config.memoryPath);
+  return (0, import_l512.makeSession)({
+    date: run.date,
+    cwd: config.cwds.length ? config.cwds[0] : (0, import_node_path12.dirname)(config.path),
+    project_focus: [...run.projects],
+    key_actions: keyActions3.slice(0, MAX_KEY_ACTIONS_PER_RUN4 + 2),
+    files_touched: filesTouched,
+    visibility: import_l512.Visibility.TEAM
+  });
+}
+function entitiesFromConfigsAndRuns4(configs, runs) {
+  const entitiesByName = /* @__PURE__ */ new Map();
+  for (const config of configs) {
+    entitiesByName.set(
+      config.automationId,
+      (0, import_l512.makeEntity)({
+        name: config.automationId,
+        type: "automation",
+        summary: bounded6(
+          `Cursor automation '${config.name}' (${config.status}). Schedule: ${config.rrule || "unspecified"}.`,
+          260
+        ),
+        last_touched: null,
+        tags: ["cursor-automation", "automation", config.status.toLowerCase()],
+        visibility: import_l512.Visibility.TEAM
+      })
+    );
+  }
+  for (const run of runs) {
+    for (const project of run.projects) {
+      if (!entitiesByName.has(project)) {
+        entitiesByName.set(
+          project,
+          (0, import_l512.makeEntity)({
+            name: project,
+            type: "project",
+            summary: "Project mentioned by Cursor automation run memory.",
+            last_touched: run.date,
+            tags: ["cursor-automation", "automation-evidence"],
+            visibility: import_l512.Visibility.TEAM
+          })
+        );
+      }
+    }
+    for (const signal of run.signals) {
+      if (!entitiesByName.has(signal)) {
+        entitiesByName.set(
+          signal,
+          (0, import_l512.makeEntity)({
+            name: signal,
+            type: "automation-signal",
+            summary: "Signal class inferred from Cursor automation run memory.",
+            last_touched: run.date,
+            tags: ["cursor-automation", "automation-signal"],
+            visibility: import_l512.Visibility.TEAM
+          })
+        );
+      }
+    }
+  }
+  return [...entitiesByName.values()];
+}
+function nowIsoSeconds3() {
+  return (/* @__PURE__ */ new Date()).toISOString().replace(/\.\d+Z$/, "+00:00");
+}
+var CursorAutomationsParticipant = class {
+  agentId = AGENT_ID12;
+  agentType = AGENT_TYPE12;
+  automationsDir;
+  policy;
+  constructor(automationsDir, cursorHome) {
+    this.automationsDir = automationsDir || defaultCursorAutomationsDir(cursorHome ?? void 0);
+    this.policy = DEFAULT_POLICY11;
+  }
+  get nativePath() {
+    return this.automationsDir;
+  }
+  discover() {
+    if (!isDir10(this.automationsDir)) {
+      throw new ParticipantDiscoveryError(
+        `Cursor automations directory not found at ${this.automationsDir}.`
+      );
+    }
+    const configs = iterConfigs4(this.automationsDir);
+    return {
+      path: this.automationsDir,
+      version: "unknown",
+      metadata: {
+        automations: configs.length,
+        with_memory: configs.filter((c) => c.memoryPath !== null).length
+      }
+    };
+  }
+  exportSessions(since, limit = 100) {
+    const sessions = this.runs(void 0, since).map(sessionFromRun4);
+    sessions.sort((a, b) => a.date < b.date ? 1 : a.date > b.date ? -1 : 0);
+    return sessions.slice(0, limit);
+  }
+  exportL5(since) {
+    const configs = iterConfigs4(this.automationsDir);
+    const runs = this.runs(configs, since);
+    const sessions = runs.map(sessionFromRun4);
+    sessions.sort((a, b) => a.date < b.date ? 1 : a.date > b.date ? -1 : 0);
+    const entities = entitiesFromConfigsAndRuns4(configs, runs);
+    const visibleEntities = (0, import_l512.filterForFederation)(entities, this.policy);
+    return (0, import_l512.makeManifest)({
+      spec_version: SPEC_VERSION,
+      agent: (0, import_l512.makeAgentInfo)({
+        id: AGENT_ID12,
+        type: AGENT_TYPE12,
+        instance: (0, import_node_os12.hostname)(),
+        spec_version_compat: SPEC_VERSION,
+        role_narrative: ROLE_NARRATIVE12
+      }),
+      last_updated: nowIsoSeconds3(),
+      capabilities: ["cursor-automation-memory", "run-summary-publication"],
+      recent_sessions: sessions,
+      known_entities: visibleEntities,
+      visibility_policy: this.policy
+    });
+  }
+  healthCheck() {
+    if (!isDir10(this.automationsDir)) {
+      return {
+        status: "blocked",
+        reason: `Cursor automations directory not found at ${this.automationsDir}.`,
+        details: { automations_dir: this.automationsDir },
+        proposedFix: "Create Cursor automations or pass --automations-dir."
+      };
+    }
+    const configs = iterConfigs4(this.automationsDir);
+    const runs = this.runs(configs);
+    const hasConfigs = configs.length > 0;
+    const details = {
+      automations_dir: this.automationsDir,
+      automation_count: configs.length,
+      memory_files: configs.filter((c) => c.memoryPath !== null).length,
+      runs_extracted: runs.length,
+      active_automations: configs.filter((c) => c.status === "ACTIVE").length
+    };
+    if (hasConfigs) {
+      return { status: "ok", details };
+    }
+    return {
+      status: "degraded",
+      reason: "No automation.toml files found.",
+      details,
+      proposedFix: "Add Cursor automation.toml files."
+    };
+  }
+  runs(configs, since) {
+    const runCutoff = since ? since.toISOString().slice(0, 10) : null;
+    const runs = [];
+    for (const config of configs ?? iterConfigs4(this.automationsDir)) {
+      for (const run of extractMemoryRuns4(config)) {
+        if (runCutoff && run.date < runCutoff) continue;
+        runs.push(run);
+      }
+    }
+    runs.sort((a, b) => {
+      if (a.date !== b.date) return a.date > b.date ? -1 : 1;
+      const ai = a.automation.automationId;
+      const bi = b.automation.automationId;
+      return ai > bi ? -1 : ai < bi ? 1 : 0;
+    });
+    return runs;
+  }
+};
+
+// src/readers/claude-desktop-code.ts
+var import_node_fs13 = require("fs");
+var import_node_os13 = require("os");
+var import_node_path13 = require("path");
+var import_l513 = require("@getbourdon/l5");
+var import_redaction13 = require("@getbourdon/redaction");
+var AGENT_ID13 = "claude-desktop-code";
+var AGENT_TYPE13 = "code-assistant";
+var DISPLAY_NAME8 = "Claude Desktop \xB7 Code";
+var SURFACE_ENTITY_NAME = "Claude Desktop Code";
+var ROLE_NARRATIVE13 = "Claude desktop app, GUI Claude Code. Bourdon reads the metadata-only per-conversation local state to surface recognition metadata -- title, project, model, effort, capability counts -- never conversation content -- so desktop Claude Code work is visible to other agents.";
+var DESKTOP_DIR_ENV = "BOURDON_CLAUDE_DESKTOP_DIR";
+var CODE_STORE = "claude-code-sessions";
+var STATE_PREFIX = "local_";
+var STATE_FILE_RE = /^local_.*\.json$/;
+var MAX_KEY_ACTION_CHARS6 = 280;
+var MAX_PROJECTS = 6;
+var MAX_KEY_ACTIONS2 = 6;
+var PROJECT_HINTS4 = [
+  "ShipStable",
+  "ILTT",
+  "Prun",
+  "PRUN",
+  "OMNIvour",
+  "Castmore",
+  "Bourdon",
+  "RADLAB",
+  "CHIP",
+  "Claude Brain",
+  "Cursor",
+  "Copilot",
+  "Codex",
+  "Cascade"
+];
+var DEFAULT_POLICY12 = (0, import_l513.makeVisibilityPolicy)({
+  default: import_l513.Visibility.TEAM,
+  private_tags: ["personal", "financial", "credential", "health", "family", "legal"],
+  team_tags: ["claude-desktop", "claude-desktop-code", "agent-surface", "workspace"]
+});
+function isDir11(p) {
+  try {
+    return (0, import_node_fs13.statSync)(p).isDirectory();
+  } catch {
+    return false;
+  }
+}
+function homeBase(home) {
+  if (home !== void 0) return home;
+  try {
+    return (0, import_node_os13.homedir)();
+  } catch {
+    return process.env.HOME || process.env.USERPROFILE || ".";
+  }
+}
+function defaultClaudeDesktopDir(home) {
+  const env = process.env[DESKTOP_DIR_ENV];
+  if (env) return env;
+  const base = homeBase(home);
+  if (process.platform === "darwin") {
+    return (0, import_node_path13.join)(base, "Library", "Application Support", "Claude");
+  }
+  if (process.platform === "win32") {
+    if (home === void 0) {
+      const appdata = process.env.APPDATA;
+      if (appdata) return (0, import_node_path13.join)(appdata, "Claude");
+    }
+    return (0, import_node_path13.join)(base, "AppData", "Roaming", "Claude");
+  }
+  if (process.platform === "linux") {
+    return (0, import_node_path13.join)(base, ".config", "Claude");
+  }
+  return null;
+}
+function iterStateFiles(storeDir) {
+  if (!isDir11(storeDir)) return [];
+  const out = [];
+  let accts;
+  try {
+    accts = (0, import_node_fs13.readdirSync)(storeDir);
+  } catch {
+    return out;
+  }
+  for (const acct of accts) {
+    const acctDir = (0, import_node_path13.join)(storeDir, acct);
+    if (!isDir11(acctDir)) continue;
+    let orgs;
+    try {
+      orgs = (0, import_node_fs13.readdirSync)(acctDir);
+    } catch {
+      continue;
+    }
+    for (const org of orgs) {
+      const orgDir = (0, import_node_path13.join)(acctDir, org);
+      if (!isDir11(orgDir)) continue;
+      let names;
+      try {
+        names = (0, import_node_fs13.readdirSync)(orgDir);
+      } catch {
+        continue;
+      }
+      for (const name of names) {
+        if (name.startsWith(STATE_PREFIX) && STATE_FILE_RE.test(name)) {
+          out.push((0, import_node_path13.join)(orgDir, name));
+        }
+      }
+    }
+  }
+  out.sort((a, b) => a < b ? -1 : a > b ? 1 : 0);
+  return out;
+}
+function loadStateJson(path) {
+  let raw;
+  try {
+    raw = (0, import_node_fs13.readFileSync)(path, "utf8");
+  } catch {
+    return null;
+  }
+  let data;
+  try {
+    data = JSON.parse(raw);
+  } catch {
+    return null;
+  }
+  if (typeof data !== "object" || data === null || Array.isArray(data)) return null;
+  return data;
+}
+function epochToDate(value) {
+  if (typeof value === "boolean") return "";
+  let num = null;
+  if (typeof value === "number") {
+    num = value;
+  } else if (typeof value === "string" && value.trim()) {
+    const parsed = Number(value.trim());
+    num = Number.isNaN(parsed) ? null : parsed;
+  }
+  if (num === null || !Number.isFinite(num)) return "";
+  const seconds = num > 1e12 ? num / 1e3 : num;
+  try {
+    const d = new Date(seconds * 1e3);
+    const iso = d.toISOString();
+    return iso.slice(0, 10);
+  } catch {
+    return "";
+  }
+}
+function sessionDate(state) {
+  for (const key of ["createdAt", "lastActivityAt"]) {
+    const parsed = epochToDate(state[key]);
+    if (parsed) return parsed;
+  }
+  return "";
+}
+function bounded7(value, limit = MAX_KEY_ACTION_CHARS6) {
+  return (0, import_redaction13.redactText)(value, limit);
+}
+function safeLabel(value, limit = MAX_KEY_ACTION_CHARS6) {
+  if (value === null || value === void 0) return "";
+  const text = String(value).trim();
+  if (!text) return "";
+  return bounded7(text, limit);
+}
+function countEnabledMcpTools(enabled) {
+  if (typeof enabled !== "object" || enabled === null || Array.isArray(enabled)) return 0;
+  let count = 0;
+  for (const v of Object.values(enabled)) {
+    if (v === true) count += 1;
+  }
+  return count;
+}
+function baseName(pathValue) {
+  if (typeof pathValue !== "string" || !pathValue.trim()) return "";
+  const name = (0, import_node_path13.basename)(pathValue.trim()).trim();
+  return name && name !== "." && name !== "/" && name !== "\\" ? name : "";
+}
+function inferProjects4(state) {
+  const projects = [];
+  const seen = /* @__PURE__ */ new Set();
+  const add = (name) => {
+    const cleaned = name.trim();
+    if (cleaned && !seen.has(cleaned.toLowerCase())) {
+      projects.push(cleaned);
+      seen.add(cleaned.toLowerCase());
+    }
+  };
+  const pathStrings = [];
+  const cwd = state["cwd"];
+  if (typeof cwd === "string" && cwd.trim()) pathStrings.push(cwd);
+  const folders = state["userSelectedFolders"];
+  if (Array.isArray(folders)) {
+    for (const f of folders) {
+      if (typeof f === "string" && f.trim()) pathStrings.push(f);
+    }
+  }
+  for (const rawPath of pathStrings) {
+    const base = baseName(rawPath);
+    if (base) add(base);
+  }
+  const haystack = pathStrings.join(" ").toLowerCase();
+  for (const hint of PROJECT_HINTS4) {
+    if (haystack.includes(hint.toLowerCase())) add(hint);
+  }
+  return projects.slice(0, MAX_PROJECTS);
+}
+function conversationFromState(statePath, state) {
+  const sessionId = state["sessionId"];
+  const stem2 = (0, import_node_path13.parse)(statePath).name;
+  return {
+    convId: String(sessionId || stem2),
+    date: sessionDate(state),
+    cwd: safeLabel(state["cwd"], 300),
+    title: safeLabel(state["title"], 160) || "(untitled conversation)",
+    model: safeLabel(state["model"], 80),
+    effort: safeLabel(state["effort"], 40),
+    permissionMode: safeLabel(state["permissionMode"], 40),
+    isArchived: Boolean(state["isArchived"]),
+    mcpToolCount: countEnabledMcpTools(state["enabledMcpTools"]),
+    projects: inferProjects4(state)
+  };
+}
+function keyActions(conv) {
+  const actions = [bounded7(conv.title, 160)];
+  if (conv.model) actions.push(bounded7(`model: ${conv.model}`, 120));
+  if (conv.effort) actions.push(bounded7(`effort: ${conv.effort}`, 60));
+  if (conv.permissionMode) actions.push(bounded7(`permission: ${conv.permissionMode}`, 80));
+  if (conv.mcpToolCount) actions.push(`mcp-tools: ${conv.mcpToolCount}`);
+  return actions.slice(0, MAX_KEY_ACTIONS2);
+}
+function sessionFromConversation(conv) {
+  return (0, import_l513.makeSession)({
+    date: conv.date,
+    cwd: conv.cwd || void 0,
+    project_focus: [...conv.projects],
+    key_actions: keyActions(conv),
+    files_touched: [],
+    // never list user files -- privacy
+    visibility: import_l513.Visibility.TEAM
+  });
+}
+function capabilities(convs) {
+  let maxMcp = 0;
+  for (const conv of convs) if (conv.mcpToolCount > maxMcp) maxMcp = conv.mcpToolCount;
+  return [AGENT_ID13, `mcp-tools:${maxMcp}`];
+}
+function entitiesFromConversations(convs) {
+  let lastSeen;
+  for (const conv of convs) {
+    if (lastSeen === void 0 || conv.date > lastSeen) lastSeen = conv.date;
+  }
+  const entities = /* @__PURE__ */ new Map();
+  entities.set(
+    SURFACE_ENTITY_NAME,
+    (0, import_l513.makeEntity)({
+      name: SURFACE_ENTITY_NAME,
+      type: "agent-surface",
+      summary: bounded7(
+        "Claude desktop app GUI Claude Code surface (metadata-only federation).",
+        260
+      ),
+      last_touched: lastSeen,
+      tags: ["claude-desktop", "claude-desktop-code", "agent-surface"],
+      visibility: import_l513.Visibility.TEAM
+    })
+  );
+  for (const conv of convs) {
+    for (const project of conv.projects) {
+      if (!entities.has(project)) {
+        entities.set(
+          project,
+          (0, import_l513.makeEntity)({
+            name: project,
+            type: "project",
+            summary: "Project inferred from a Claude Desktop Code conversation cwd.",
+            last_touched: conv.date || void 0,
+            tags: ["claude-desktop", "claude-desktop-code", "project"],
+            visibility: import_l513.Visibility.TEAM
+          })
+        );
+      }
+    }
+  }
+  return [...entities.values()];
+}
+var ClaudeDesktopCodeParticipant = class _ClaudeDesktopCodeParticipant {
+  agentId = AGENT_ID13;
+  agentType = AGENT_TYPE13;
+  displayName = DISPLAY_NAME8;
+  storeDir;
+  policy;
+  /**
+   * The Claude Code sub-store dir the setup wizard probes for presence. Resolves
+   * to `<desktop>/claude-code-sessions`. Falls back to a non-existent sentinel
+   * under `home` on an unrecognized platform so the wizard reports "not found".
+   */
+  static defaultNativePath(home) {
+    const desktop = defaultClaudeDesktopDir(home);
+    if (desktop === null) return (0, import_node_path13.join)(homeBase(home), "Claude", CODE_STORE);
+    return (0, import_node_path13.join)(desktop, CODE_STORE);
+  }
+  constructor(storeDir, home) {
+    this.storeDir = storeDir ?? _ClaudeDesktopCodeParticipant.defaultNativePath(home);
+    this.policy = DEFAULT_POLICY12;
+  }
+  get nativePath() {
+    return this.storeDir;
+  }
+  discover() {
+    if (!isDir11(this.storeDir)) {
+      throw new ParticipantDiscoveryError(
+        `Claude Desktop Code store not found at ${this.storeDir}.`
+      );
+    }
+    const stateFiles = iterStateFiles(this.storeDir);
+    return {
+      path: this.storeDir,
+      version: "unknown",
+      metadata: { conversations: stateFiles.length }
+    };
+  }
+  exportSessions(since, limit = 100) {
+    const convs = this.conversations(since);
+    const sessions = convs.map(sessionFromConversation);
+    sessions.sort((a, b) => a.date < b.date ? 1 : a.date > b.date ? -1 : 0);
+    return sessions.slice(0, limit);
+  }
+  exportL5(since) {
+    if (!isDir11(this.storeDir)) {
+      throw new ParticipantDiscoveryError(
+        `Claude Desktop Code store not found at ${this.storeDir}.`
+      );
+    }
+    const convs = this.conversations(since);
+    const sessions = convs.map(sessionFromConversation);
+    sessions.sort((a, b) => a.date < b.date ? 1 : a.date > b.date ? -1 : 0);
+    const entities = entitiesFromConversations(convs);
+    const visibleEntities = (0, import_l513.filterForFederation)(entities, this.policy);
+    return (0, import_l513.makeManifest)({
+      spec_version: SPEC_VERSION,
+      agent: (0, import_l513.makeAgentInfo)({
+        id: AGENT_ID13,
+        type: AGENT_TYPE13,
+        instance: (0, import_node_os13.hostname)(),
+        spec_version_compat: SPEC_VERSION,
+        role_narrative: ROLE_NARRATIVE13
+      }),
+      last_updated: (/* @__PURE__ */ new Date()).toISOString(),
+      capabilities: capabilities(convs),
+      recent_sessions: sessions,
+      known_entities: visibleEntities,
+      visibility_policy: this.policy
+    });
+  }
+  healthCheck() {
+    if (!isDir11(this.storeDir)) {
+      return {
+        status: "blocked",
+        reason: `Claude Desktop Code store not found at ${this.storeDir}.`,
+        details: { store_dir: this.storeDir },
+        proposedFix: "Install the Claude desktop app and open a Claude Code conversation once. Set BOURDON_CLAUDE_DESKTOP_DIR if the app stores state in a non-standard location."
+      };
+    }
+    let stateFiles;
+    let convs;
+    let malformed;
+    try {
+      stateFiles = iterStateFiles(this.storeDir);
+      const collected = this.collectConversations();
+      convs = collected.convs;
+      malformed = collected.malformed;
+    } catch (exc) {
+      return {
+        status: "degraded",
+        reason: "Code store present but extraction failed.",
+        details: { error: String(exc) },
+        proposedFix: "Close the Claude desktop app (its state files may be locked) and re-run `bourdon claude-desktop-code export`."
+      };
+    }
+    if (stateFiles.length === 0) {
+      return {
+        status: "degraded",
+        reason: "No Claude Code conversations found under the store directory.",
+        details: { store_dir: this.storeDir },
+        proposedFix: "Open a Claude Code conversation in the Claude desktop app, then re-run `bourdon claude-desktop-code export`."
+      };
+    }
+    return {
+      status: "ok",
+      details: {
+        store_dir: this.storeDir,
+        conversation_count: stateFiles.length,
+        conversations_extracted: convs.length,
+        malformed_records: malformed
+      }
+    };
+  }
+  // -- Internal ---------------------------------------------------------------
+  collectConversations() {
+    const convs = [];
+    let malformed = 0;
+    for (const statePath of iterStateFiles(this.storeDir)) {
+      const state = loadStateJson(statePath);
+      if (state === null) {
+        malformed += 1;
+        continue;
+      }
+      convs.push(conversationFromState(statePath, state));
+    }
+    return { convs, malformed };
+  }
+  conversations(since) {
+    let { convs } = this.collectConversations();
+    if (since !== void 0) {
+      const cutoff = since.toISOString().slice(0, 10);
+      convs = convs.filter((conv) => !conv.date || conv.date >= cutoff);
+    }
+    convs.sort((a, b) => {
+      if (a.date !== b.date) return a.date < b.date ? 1 : -1;
+      if (a.convId !== b.convId) return a.convId < b.convId ? 1 : -1;
+      return 0;
+    });
+    return convs;
+  }
+};
+
+// src/readers/claude-desktop-cowork.ts
+var import_node_fs14 = require("fs");
+var import_node_os14 = require("os");
+var import_node_path14 = require("path");
+var import_l514 = require("@getbourdon/l5");
+var import_redaction14 = require("@getbourdon/redaction");
+var AGENT_ID14 = "claude-desktop-cowork";
+var AGENT_TYPE14 = "code-assistant";
+var DISPLAY_NAME9 = "Claude Desktop \xB7 Co-Work";
+var SURFACE_ENTITY_NAME2 = "Claude Desktop Co-Work";
+var ROLE_NARRATIVE14 = "Claude desktop app, Co-Work / local-agent mode. Bourdon reads the per-run local state and audit transcript to surface recognition metadata -- title, project, model, turn/cost scalars, capability counts -- never conversation content -- so Co-Work runs are visible to other agents.";
+var DEFAULT_POLICY13 = (0, import_l514.makeVisibilityPolicy)({
+  default: import_l514.Visibility.TEAM,
+  private_tags: ["personal", "financial", "credential", "health", "family", "legal"],
+  team_tags: ["claude-desktop", "claude-desktop-cowork", "agent-surface", "workspace"]
+});
+var DESKTOP_DIR_ENV2 = "BOURDON_CLAUDE_DESKTOP_DIR";
+var COWORK_STORE = "local-agent-mode-sessions";
+var STATE_PREFIX2 = "local_";
+var MAX_PROJECTS2 = 6;
+var MAX_KEY_ACTIONS3 = 8;
+var MAX_AUDIT_LINES = 5e4;
+var PROJECT_HINTS5 = [
+  "ShipStable",
+  "ILTT",
+  "Prun",
+  "PRUN",
+  "OMNIvour",
+  "Castmore",
+  "Bourdon",
+  "RADLAB",
+  "CHIP",
+  "Claude Brain",
+  "Cursor",
+  "Copilot",
+  "Codex",
+  "Cascade"
+];
+var logger7 = {
+  warn(msg) {
+    console.warn(`[bourdon.participants] ${msg}`);
+  }
+};
+function isDir12(p) {
+  try {
+    return (0, import_node_fs14.statSync)(p).isDirectory();
+  } catch {
+    return false;
+  }
+}
+function isFile11(p) {
+  try {
+    return (0, import_node_fs14.statSync)(p).isFile();
+  } catch {
+    return false;
+  }
+}
+function homeDir9() {
+  return process.env.HOME || process.env.USERPROFILE || ".";
+}
+function isRecord6(v) {
+  return typeof v === "object" && v !== null && !Array.isArray(v);
+}
+function isoSeconds() {
+  return (/* @__PURE__ */ new Date()).toISOString().replace(/\.\d{3}Z$/, "+00:00");
+}
+function defaultClaudeDesktopDir2(home) {
+  const env = process.env[DESKTOP_DIR_ENV2];
+  if (env) return env;
+  const base = home || homeDir9();
+  const plat = process.platform;
+  if (plat === "darwin") {
+    return (0, import_node_path14.join)(base, "Library", "Application Support", "Claude");
+  }
+  if (plat.startsWith("win")) {
+    if (home === void 0) {
+      const appdata = process.env.APPDATA;
+      if (appdata) return (0, import_node_path14.join)(appdata, "Claude");
+    }
+    return (0, import_node_path14.join)(base, "AppData", "Roaming", "Claude");
+  }
+  if (plat.startsWith("linux")) {
+    return (0, import_node_path14.join)(base, ".config", "Claude");
+  }
+  return null;
+}
+function iterStateFiles2(storeDir) {
+  if (!isDir12(storeDir)) return [];
+  const out = [];
+  let accounts;
+  try {
+    accounts = (0, import_node_fs14.readdirSync)(storeDir);
+  } catch {
+    return [];
+  }
+  for (const acct of accounts) {
+    const acctDir = (0, import_node_path14.join)(storeDir, acct);
+    if (!isDir12(acctDir)) continue;
+    let orgs;
+    try {
+      orgs = (0, import_node_fs14.readdirSync)(acctDir);
+    } catch {
+      continue;
+    }
+    for (const org of orgs) {
+      const orgDir = (0, import_node_path14.join)(acctDir, org);
+      if (!isDir12(orgDir)) continue;
+      let entries;
+      try {
+        entries = (0, import_node_fs14.readdirSync)(orgDir);
+      } catch {
+        continue;
+      }
+      for (const name of entries) {
+        if (name.startsWith(STATE_PREFIX2) && name.endsWith(".json")) {
+          out.push((0, import_node_path14.join)(orgDir, name));
+        }
+      }
+    }
+  }
+  out.sort();
+  return out;
+}
+function loadStateJson2(path) {
+  let raw;
+  try {
+    raw = (0, import_node_fs14.readFileSync)(path, "utf8");
+  } catch (exc) {
+    logger7.warn(`claude-desktop: cannot read ${path}: ${String(exc)}`);
+    return null;
+  }
+  let data;
+  try {
+    data = JSON.parse(raw);
+  } catch (exc) {
+    logger7.warn(`claude-desktop: cannot parse ${path}: ${String(exc)}`);
+    return null;
+  }
+  return isRecord6(data) ? data : null;
+}
+function epochToDate2(value) {
+  if (typeof value === "boolean") return "";
+  let num = null;
+  if (typeof value === "number") {
+    num = value;
+  } else if (typeof value === "string" && value.trim()) {
+    const n = Number(value.trim());
+    num = Number.isNaN(n) ? null : n;
+  }
+  if (num === null || Number.isNaN(num)) return "";
+  const seconds = num > 1e12 ? num / 1e3 : num;
+  try {
+    const d = new Date(seconds * 1e3);
+    if (Number.isNaN(d.getTime())) return "";
+    return d.toISOString().slice(0, 10);
+  } catch {
+    return "";
+  }
+}
+function sessionDate2(state) {
+  for (const key of ["createdAt", "lastActivityAt"]) {
+    const parsed = epochToDate2(state[key]);
+    if (parsed) return parsed;
+  }
+  return "";
+}
+function bounded8(value, limit = 280) {
+  return (0, import_redaction14.redactText)(value, limit);
+}
+function safeLabel2(value, limit = 280) {
+  if (value === null || value === void 0) return "";
+  const text = String(value).trim();
+  if (!text) return "";
+  return bounded8(text, limit);
+}
+function countEnabledMcpTools2(enabled) {
+  if (!isRecord6(enabled)) return 0;
+  let n = 0;
+  for (const v of Object.values(enabled)) {
+    if (v === true) n += 1;
+  }
+  return n;
+}
+function basenameOf4(pathValue) {
+  if (typeof pathValue !== "string" || !pathValue.trim()) return "";
+  const name = (0, import_node_path14.basename)(pathValue.trim()).trim();
+  return name && name !== "." && name !== "/" && name !== "\\" ? name : "";
+}
+function inferProjects5(state) {
+  const projects = [];
+  const seen = /* @__PURE__ */ new Set();
+  const add = (name) => {
+    const cleaned = name.trim();
+    if (cleaned && !seen.has(cleaned.toLowerCase())) {
+      projects.push(cleaned);
+      seen.add(cleaned.toLowerCase());
+    }
+  };
+  const pathStrings = [];
+  const cwd = state["cwd"];
+  if (typeof cwd === "string" && cwd.trim()) pathStrings.push(cwd);
+  const folders = state["userSelectedFolders"];
+  if (Array.isArray(folders)) {
+    for (const f of folders) {
+      if (typeof f === "string" && f.trim()) pathStrings.push(f);
+    }
+  }
+  for (const raw of pathStrings) {
+    const base = basenameOf4(raw);
+    if (base) add(base);
+  }
+  const haystack = pathStrings.join(" ").toLowerCase();
+  for (const hint of PROJECT_HINTS5) {
+    if (haystack.includes(hint.toLowerCase())) add(hint);
+  }
+  return projects.slice(0, MAX_PROJECTS2);
+}
+function runDirFor(statePath) {
+  return (0, import_node_path14.join)((0, import_node_path14.dirname)(statePath), (0, import_node_path14.parse)(statePath).name);
+}
+function absorbAuditRecord(record, out) {
+  const recType = record["type"];
+  const subtype = record["subtype"];
+  if (recType === "system" && subtype === "init") {
+    const pairs = [
+      ["tools", "init_tools"],
+      ["mcp_servers", "init_mcp_servers"],
+      ["skills", "init_skills"],
+      ["plugins", "init_plugins"],
+      ["slash_commands", "init_slash_commands"]
+    ];
+    for (const [srcKey, dstKey] of pairs) {
+      const value = record[srcKey];
+      if (Array.isArray(value)) out[dstKey] = value.length;
+    }
+    const version = record["claude_code_version"];
+    if (version !== null && version !== void 0) {
+      out["claude_code_version"] = safeLabel2(version, 40);
+    }
+    return;
+  }
+  if (recType === "result") {
+    for (const key of ["total_cost_usd", "num_turns", "is_error", "duration_ms"]) {
+      if (key in record) out[key] = record[key];
+    }
+    const stopReason = record["stop_reason"];
+    if (stopReason !== null && stopReason !== void 0) {
+      out["stop_reason"] = safeLabel2(stopReason, 40);
+    }
+  }
+}
+function readAuditScalars(runDir) {
+  const auditPath = (0, import_node_path14.join)(runDir, "audit.jsonl");
+  if (!isFile11(auditPath)) return {};
+  const out = {};
+  let raw;
+  try {
+    raw = (0, import_node_fs14.readFileSync)(auditPath, "utf8");
+  } catch (exc) {
+    logger7.warn(`claude-desktop: cannot read ${auditPath}: ${String(exc)}`);
+    return out;
+  }
+  let lineNo = 0;
+  for (const rawLine of raw.split(/\r?\n/)) {
+    if (lineNo >= MAX_AUDIT_LINES) break;
+    lineNo += 1;
+    const line = rawLine.trim();
+    if (!line || line[0] !== "{") continue;
+    let record;
+    try {
+      record = JSON.parse(line);
+    } catch {
+      continue;
+    }
+    if (!isRecord6(record)) continue;
+    absorbAuditRecord(record, out);
+  }
+  return out;
+}
+function runFromState(statePath, state) {
+  const audit = readAuditScalars(runDirFor(statePath));
+  const title = safeLabel2(state["title"], 160) || "(untitled run)";
+  const model = safeLabel2(state["model"], 80);
+  const permissionMode = safeLabel2(state["permissionMode"], 40);
+  const numTurnsRaw = audit["num_turns"];
+  const costRaw = audit["total_cost_usd"];
+  const isErrorRaw = audit["is_error"];
+  const initCounts = {};
+  for (const [k, v] of Object.entries(audit)) {
+    if (k.startsWith("init_") && typeof v === "number" && Number.isInteger(v)) {
+      initCounts[k] = v;
+    }
+  }
+  const stem2 = (0, import_node_path14.parse)(statePath).name;
+  const sid = state["sessionId"];
+  return {
+    runId: String(sid || stem2),
+    date: sessionDate2(state),
+    cwd: safeLabel2(state["cwd"], 300),
+    title,
+    model,
+    permissionMode,
+    isArchived: Boolean(state["isArchived"]),
+    mcpToolCount: countEnabledMcpTools2(state["enabledMcpTools"]),
+    projects: inferProjects5(state),
+    numTurns: typeof numTurnsRaw === "number" && Number.isInteger(numTurnsRaw) ? numTurnsRaw : null,
+    totalCostUsd: typeof costRaw === "number" ? costRaw : null,
+    isError: typeof isErrorRaw === "boolean" ? isErrorRaw : null,
+    initCounts
+  };
+}
+function keyActions2(run) {
+  const actions = [bounded8(run.title, 160)];
+  if (run.model) actions.push(bounded8(`model: ${run.model}`, 120));
+  if (run.permissionMode) actions.push(bounded8(`permission: ${run.permissionMode}`, 80));
+  if (run.numTurns !== null) actions.push(`${run.numTurns} turns`);
+  if (run.totalCostUsd !== null) actions.push(`$${run.totalCostUsd.toFixed(2)}`);
+  if (run.isError) actions.push("error");
+  if (run.mcpToolCount) actions.push(`mcp-tools: ${run.mcpToolCount}`);
+  return actions.slice(0, MAX_KEY_ACTIONS3);
+}
+function sessionFromRun5(run) {
+  return (0, import_l514.makeSession)({
+    date: run.date,
+    cwd: run.cwd || void 0,
+    // run.cwd or None -- privacy: never empty string
+    project_focus: [...run.projects],
+    key_actions: keyActions2(run),
+    files_touched: [],
+    // never list user files -- privacy
+    visibility: import_l514.Visibility.TEAM
+  });
+}
+function capabilities2(runs) {
+  const caps = [AGENT_ID14];
+  const maxMcp = runs.length ? Math.max(...runs.map((r) => r.mcpToolCount)) : 0;
+  caps.push(`mcp-tools:${maxMcp}`);
+  const bestTools = runs.length ? Math.max(...runs.map((r) => r.initCounts["init_tools"] ?? 0)) : 0;
+  if (bestTools) caps.push(`tools:${bestTools}`);
+  const bestSkills = runs.length ? Math.max(...runs.map((r) => r.initCounts["init_skills"] ?? 0)) : 0;
+  if (bestSkills) caps.push(`skills:${bestSkills}`);
+  return caps;
+}
+function entitiesFromRuns(runs) {
+  const lastSeen = runs.length ? runs.map((r) => r.date).reduce((a, b) => a > b ? a : b) : null;
+  const entities = /* @__PURE__ */ new Map();
+  entities.set(
+    SURFACE_ENTITY_NAME2,
+    (0, import_l514.makeEntity)({
+      name: SURFACE_ENTITY_NAME2,
+      type: "agent-surface",
+      summary: bounded8(
+        "Claude desktop app Co-Work / local-agent mode surface (metadata-only federation).",
+        260
+      ),
+      last_touched: lastSeen,
+      tags: ["claude-desktop", "claude-desktop-cowork", "agent-surface"],
+      visibility: import_l514.Visibility.TEAM
+    })
+  );
+  for (const run of runs) {
+    for (const project of run.projects) {
+      if (!entities.has(project)) {
+        entities.set(
+          project,
+          (0, import_l514.makeEntity)({
+            name: project,
+            type: "project",
+            summary: "Project inferred from a Claude Desktop Co-Work run cwd.",
+            last_touched: run.date || void 0,
+            // run.date or None
+            tags: ["claude-desktop", "claude-desktop-cowork", "project"],
+            visibility: import_l514.Visibility.TEAM
+          })
+        );
+      }
+    }
+  }
+  return [...entities.values()];
+}
+var ClaudeDesktopCoworkParticipant = class _ClaudeDesktopCoworkParticipant {
+  agentId = AGENT_ID14;
+  agentType = AGENT_TYPE14;
+  displayName = DISPLAY_NAME9;
+  storeDir;
+  policy;
+  /**
+   * The Co-Work sub-store dir the setup wizard probes for presence. Resolves to
+   * `<desktop>/local-agent-mode-sessions`. When the desktop dir cannot be
+   * resolved on this platform, falls back to a non-existent sentinel under
+   * `home` so the wizard reports "not found" rather than crashing.
+   */
+  static defaultNativePath(home) {
+    const desktop = defaultClaudeDesktopDir2(home);
+    if (desktop === null) return (0, import_node_path14.join)(home || homeDir9(), "Claude", COWORK_STORE);
+    return (0, import_node_path14.join)(desktop, COWORK_STORE);
+  }
+  constructor(storeDir, home) {
+    this.storeDir = storeDir || _ClaudeDesktopCoworkParticipant.defaultNativePath(home);
+    this.policy = DEFAULT_POLICY13;
+  }
+  get nativePath() {
+    return this.storeDir;
+  }
+  // -- Protocol surface --------------------------------------------------------
+  discover() {
+    if (!isDir12(this.storeDir)) {
+      throw new ParticipantDiscoveryError(
+        `Claude Desktop Co-Work store not found at ${this.storeDir}.`
+      );
+    }
+    const stateFiles = iterStateFiles2(this.storeDir);
+    return {
+      path: this.storeDir,
+      version: "unknown",
+      metadata: { runs: stateFiles.length }
+    };
+  }
+  exportSessions(since, limit = 100) {
+    const runs = this.runs(since);
+    const sessions = runs.map(sessionFromRun5);
+    sessions.sort((a, b) => a.date < b.date ? 1 : a.date > b.date ? -1 : 0);
+    return sessions.slice(0, limit);
+  }
+  exportL5(since) {
+    if (!isDir12(this.storeDir)) {
+      throw new ParticipantDiscoveryError(
+        `Claude Desktop Co-Work store not found at ${this.storeDir}.`
+      );
+    }
+    const runs = this.runs(since);
+    const sessions = runs.map(sessionFromRun5);
+    sessions.sort((a, b) => a.date < b.date ? 1 : a.date > b.date ? -1 : 0);
+    const entities = entitiesFromRuns(runs);
+    const visibleEntities = (0, import_l514.filterForFederation)(entities, this.policy);
+    return (0, import_l514.makeManifest)({
+      spec_version: SPEC_VERSION,
+      agent: (0, import_l514.makeAgentInfo)({
+        id: AGENT_ID14,
+        type: AGENT_TYPE14,
+        instance: (0, import_node_os14.hostname)(),
+        spec_version_compat: SPEC_VERSION,
+        role_narrative: ROLE_NARRATIVE14
+      }),
+      last_updated: isoSeconds(),
+      capabilities: capabilities2(runs),
+      recent_sessions: sessions,
+      known_entities: visibleEntities,
+      visibility_policy: this.policy
+    });
+  }
+  healthCheck() {
+    if (!isDir12(this.storeDir)) {
+      return {
+        status: "blocked",
+        reason: `Claude Desktop Co-Work store not found at ${this.storeDir}.`,
+        details: { store_dir: this.storeDir },
+        proposedFix: "Install the Claude desktop app and run a Co-Work / local-agent session once. Set BOURDON_CLAUDE_DESKTOP_DIR if the app stores state in a non-standard location."
+      };
+    }
+    let stateFiles;
+    let runs;
+    let malformed;
+    try {
+      stateFiles = iterStateFiles2(this.storeDir);
+      [runs, malformed] = this.collectRuns();
+    } catch (exc) {
+      logger7.warn(`ClaudeDesktopCoworkParticipant health_check failed: ${String(exc)}`);
+      return {
+        status: "degraded",
+        reason: "Co-Work store present but extraction failed.",
+        details: { error: String(exc) },
+        proposedFix: "Close the Claude desktop app (its state files may be locked) and re-run `bourdon claude-desktop-cowork export`."
+      };
+    }
+    if (stateFiles.length === 0) {
+      return {
+        status: "degraded",
+        reason: "No Co-Work runs found under the store directory.",
+        details: { store_dir: this.storeDir },
+        proposedFix: "Run a Co-Work / local-agent session in the Claude desktop app, then re-run `bourdon claude-desktop-cowork export`."
+      };
+    }
+    return {
+      status: "ok",
+      details: {
+        store_dir: this.storeDir,
+        run_count: stateFiles.length,
+        runs_extracted: runs.length,
+        malformed_records: malformed,
+        runs_with_scalars: runs.filter((r) => r.numTurns !== null).length
+      }
+    };
+  }
+  // -- Internal ----------------------------------------------------------------
+  collectRuns() {
+    const runs = [];
+    let malformed = 0;
+    for (const statePath of iterStateFiles2(this.storeDir)) {
+      const state = loadStateJson2(statePath);
+      if (state === null) {
+        malformed += 1;
+        continue;
+      }
+      runs.push(runFromState(statePath, state));
+    }
+    return [runs, malformed];
+  }
+  runs(since) {
+    const [runs] = this.collectRuns();
+    let filtered = runs;
+    if (since !== void 0) {
+      const cutoff = new Date(since.getTime()).toISOString().slice(0, 10);
+      filtered = runs.filter((run) => !run.date || run.date >= cutoff);
+    }
+    filtered.sort((a, b) => {
+      if (a.date !== b.date) return a.date < b.date ? 1 : -1;
+      if (a.runId !== b.runId) return a.runId < b.runId ? 1 : -1;
+      return 0;
+    });
+    return filtered;
+  }
+};
+
+// src/readers/copilot-vscode.ts
+var import_node_fs15 = require("fs");
+var import_node_os15 = require("os");
+var import_node_path15 = require("path");
+var import_l515 = require("@getbourdon/l5");
+var import_redaction15 = require("@getbourdon/redaction");
+var AGENT_ID15 = "copilot-vscode";
+var AGENT_TYPE15 = "code-assistant";
+var DISPLAY_NAME10 = "GitHub Copilot \xB7 VS Code";
+var ROLE_NARRATIVE15 = "VS Code integrated Copilot Chat \u2014 the GUI surface for inline completion, chat, plan mode, ask mode, and explore mode. Persists per-workspace transcripts and repo-scoped memory locally. The most widely-used Copilot surface by session count.";
+var DEFAULT_POLICY14 = (0, import_l515.makeVisibilityPolicy)({
+  default: import_l515.Visibility.TEAM,
+  private_tags: ["personal", "financial", "credential", "health", "family", "legal"],
+  team_tags: ["copilot-vscode", "copilot", "vscode", "workspace"]
+});
+var COPILOT_CHAT_EXT = "GitHub.copilot-chat";
+var TRANSCRIPTS_DIR = "transcripts";
+var MEMORY_TOOL_DIR = "memory-tool";
+var MAX_KEY_ACTIONS4 = 6;
+var MAX_KEY_ACTION_CHARS7 = 280;
+var MAX_SUMMARY_CHARS3 = 260;
+var MAX_TRANSCRIPT_EVENTS = 500;
+function homeDir10() {
+  try {
+    return (0, import_node_os15.homedir)();
+  } catch {
+    return process.env.HOME || process.env.USERPROFILE || ".";
+  }
+}
+function isDir13(p) {
+  try {
+    return (0, import_node_fs15.statSync)(p).isDirectory();
+  } catch {
+    return false;
+  }
+}
+function safeNativeMemoryText7(value, limit = 180) {
+  return (0, import_redaction15.redactText)(value, limit);
+}
+function bounded9(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 splitLines4(text) {
+  return text.split(/\r\n|\r|\n/);
+}
+function defaultVscodeWorkspaceStorageDir() {
+  const env = process.env.COPILOT_VSCODE_STORAGE;
+  if (env) return env;
+  const system = (0, import_node_os15.platform)();
+  if (system === "win32") {
+    const appdata = process.env.APPDATA;
+    if (appdata) return (0, import_node_path15.join)(appdata, "Code", "User", "workspaceStorage");
+    return null;
+  }
+  if (system === "darwin") {
+    return (0, import_node_path15.join)(
+      homeDir10(),
+      "Library",
+      "Application Support",
+      "Code",
+      "User",
+      "workspaceStorage"
+    );
+  }
+  const wslPath = "/mnt/c/Users";
+  if (isDir13(wslPath)) {
+    try {
+      for (const candidate of (0, import_node_fs15.readdirSync)(wslPath)) {
+        try {
+          const ws = (0, import_node_path15.join)(
+            wslPath,
+            candidate,
+            "AppData",
+            "Roaming",
+            "Code",
+            "User",
+            "workspaceStorage"
+          );
+          if (isDir13(ws)) return ws;
+        } catch {
+          continue;
+        }
+      }
+    } catch {
+    }
+  }
+  const config = process.env.XDG_CONFIG_HOME || (0, import_node_path15.join)(homeDir10(), ".config");
+  return (0, import_node_path15.join)(config, "Code", "User", "workspaceStorage");
+}
+function findCopilotChatDirs(workspaceStorage) {
+  if (!isDir13(workspaceStorage)) return [];
+  const dirs = [];
+  try {
+    for (const wsHash of (0, import_node_fs15.readdirSync)(workspaceStorage)) {
+      const chatDir = (0, import_node_path15.join)(workspaceStorage, wsHash, COPILOT_CHAT_EXT);
+      if (isDir13(chatDir)) dirs.push(chatDir);
+    }
+  } catch (exc) {
+    logger8.warn(`CopilotVscodeParticipant: cannot scan workspace storage: ${String(exc)}`);
+  }
+  return dirs;
+}
+var logger8 = {
+  warn(msg) {
+    console.warn(`[bourdon.participants] ${msg}`);
+  }
+};
+function parseTranscript(path) {
+  let text;
+  try {
+    text = (0, import_node_fs15.readFileSync)(path, "utf8");
+  } catch {
+    return null;
+  }
+  const lines = text.trim() ? splitLines4(text.trim()) : [];
+  if (lines.length === 0) return null;
+  const info = {
+    transcript_path: path,
+    session_id: stem(path),
+    start_time: null,
+    producer: null,
+    copilot_version: null,
+    vscode_version: null,
+    user_messages: [],
+    turn_count: 0
+  };
+  let turnCount = 0;
+  const userMsgs = [];
+  for (const line of lines.slice(0, MAX_TRANSCRIPT_EVENTS)) {
+    let event;
+    try {
+      event = JSON.parse(line);
+    } catch {
+      continue;
+    }
+    if (typeof event !== "object" || event === null) continue;
+    const ev = event;
+    const eventType = ev["type"];
+    const dataRaw = ev["data"];
+    const data = typeof dataRaw === "object" && dataRaw !== null ? dataRaw : {};
+    if (eventType === "session.start") {
+      info.start_time = data["startTime"] == null ? null : String(data["startTime"]);
+      info.producer = data["producer"] ?? null;
+      info.copilot_version = data["copilotVersion"] ?? null;
+      info.vscode_version = data["vscodeVersion"] ?? null;
+    } else if (eventType === "user.message") {
+      const content = data["content"] ? String(data["content"]) : "";
+      if (content) {
+        userMsgs.push(content.slice(0, 200));
+      }
+    } else if (eventType === "assistant.turn_end") {
+      turnCount += 1;
+    }
+  }
+  info.user_messages = userMsgs.slice(0, 20);
+  info.turn_count = turnCount;
+  return info;
+}
+function stem(p) {
+  const base = p.replace(/[\\/]+$/, "").split(/[\\/]/).pop() ?? "";
+  return base.replace(/\.[^.]+$/, "");
+}
+function walkMarkdown(dir) {
+  const out = [];
+  let entries;
+  try {
+    entries = (0, import_node_fs15.readdirSync)(dir).sort();
+  } catch {
+    return out;
+  }
+  for (const name of entries) {
+    const full = (0, import_node_path15.join)(dir, name);
+    if (isDir13(full)) {
+      out.push(...walkMarkdown(full));
+    } else if (name.endsWith(".md")) {
+      out.push(full);
+    }
+  }
+  return out;
+}
+function parseMemoryFiles(chatDir) {
+  const memoryDir = (0, import_node_path15.join)(chatDir, MEMORY_TOOL_DIR, "memories");
+  if (!isDir13(memoryDir)) return [];
+  const memories = [];
+  for (const mdFile of walkMarkdown(memoryDir)) {
+    let text;
+    try {
+      text = (0, import_node_fs15.readFileSync)(mdFile, "utf8");
+    } catch {
+      continue;
+    }
+    if (!text.trim()) continue;
+    const rel = (0, import_node_path15.relative)(memoryDir, mdFile);
+    const name = rel.replace(/\.[^./\\]*$/, "").replace(/\\/g, "/");
+    const bulletCount = text.split("\n- ").length - 1 + (text.startsWith("- ") ? 1 : 0);
+    memories.push({ name, content: text, path: mdFile, bullet_count: bulletCount });
+  }
+  return memories;
+}
+function sessionFromTranscript(info) {
+  const start = info.start_time ?? "";
+  const dateStr = start ? start.slice(0, 10) : "";
+  const keyActions3 = [];
+  const msgs = info.user_messages ?? [];
+  if (msgs.length > 0) {
+    keyActions3.push(bounded9(safeNativeMemoryText7(String(msgs[0])), MAX_KEY_ACTION_CHARS7));
+  }
+  if (info.turn_count) keyActions3.push(`turns: ${info.turn_count}`);
+  if (info.copilot_version) keyActions3.push(`copilot: ${String(info.copilot_version)}`);
+  if (info.producer) keyActions3.push(`mode: ${String(info.producer)}`);
+  return (0, import_l515.makeSession)({
+    date: dateStr,
+    cwd: void 0,
+    project_focus: [],
+    key_actions: keyActions3.slice(0, MAX_KEY_ACTIONS4),
+    files_touched: [],
+    visibility: import_l515.Visibility.TEAM
+  });
+}
+function entitiesFromMemories(memories) {
+  const entities = [];
+  for (const mem of memories) {
+    const bullets = [];
+    for (const line of splitLines4(mem.content)) {
+      const stripped = line.trim();
+      if (stripped.startsWith("- ")) {
+        bullets.push(stripped.slice(2).trim());
+        if (bullets.length === 3) break;
+      }
+    }
+    let summary = bullets.length > 0 ? bullets.join("; ") : void 0;
+    if (summary) summary = bounded9(safeNativeMemoryText7(summary), MAX_SUMMARY_CHARS3);
+    entities.push(
+      (0, import_l515.makeEntity)({
+        name: mem.name,
+        type: "vscode-memory",
+        summary,
+        last_touched: void 0,
+        tags: ["copilot-vscode", "memory-tool", "repo-memory"],
+        visibility: import_l515.Visibility.TEAM
+      })
+    );
+  }
+  return entities;
+}
+function entitiesFromTranscripts(transcripts) {
+  const topicCounts = /* @__PURE__ */ new Map();
+  for (const info of transcripts) {
+    const msgs = info.user_messages ?? [];
+    if (msgs.length > 0) {
+      const first = String(msgs[0]).slice(0, 100);
+      const slashMatch = /^\/(\S+)/.exec(first);
+      if (slashMatch) {
+        const topic = `copilot-command:${slashMatch[1]}`;
+        topicCounts.set(topic, (topicCounts.get(topic) ?? 0) + 1);
+      }
+    }
+  }
+  const ordered = [...topicCounts.entries()].sort((a, b) => b[1] - a[1]).slice(0, 10);
+  const entities = [];
+  for (const [topic, count] of ordered) {
+    entities.push(
+      (0, import_l515.makeEntity)({
+        name: topic,
+        type: "vscode-capability",
+        summary: `VS Code Copilot command used ${count} time(s).`,
+        tags: ["copilot-vscode", "capability"],
+        visibility: import_l515.Visibility.TEAM
+      })
+    );
+  }
+  return entities;
+}
+var CopilotVscodeParticipant = class {
+  agentId = AGENT_ID15;
+  agentType = AGENT_TYPE15;
+  displayName = DISPLAY_NAME10;
+  workspaceStorage;
+  /** The workspaceStorage dir the setup wizard probes for presence. */
+  static defaultNativePath(home) {
+    if (home !== void 0) {
+      return (0, import_node_path15.join)(home, ".config", "Code", "User", "workspaceStorage");
+    }
+    let ws;
+    try {
+      ws = defaultVscodeWorkspaceStorageDir();
+    } catch {
+      ws = null;
+    }
+    if (ws !== null) return ws;
+    return (0, import_node_path15.join)(homeDir10(), ".config", "Code", "User", "workspaceStorage");
+  }
+  constructor(workspaceStorage) {
+    this.workspaceStorage = workspaceStorage ?? null;
+  }
+  get nativePath() {
+    return this.workspaceStorage ?? defaultVscodeWorkspaceStorageDir() ?? "";
+  }
+  resolveWs() {
+    return this.workspaceStorage ?? defaultVscodeWorkspaceStorageDir();
+  }
+  // -- Protocol surface -------------------------------------------------------
+  discover() {
+    const ws = this.resolveWs();
+    if (ws === null || !isDir13(ws)) {
+      throw new ParticipantDiscoveryError(
+        `VS Code workspaceStorage not found at ${ws ?? "None"}. Install VS Code with the GitHub Copilot Chat extension.`
+      );
+    }
+    const chatDirs = findCopilotChatDirs(ws);
+    if (chatDirs.length === 0) {
+      throw new ParticipantDiscoveryError(
+        `No GitHub.copilot-chat data found under ${ws}. Open VS Code and use Copilot Chat at least once.`
+      );
+    }
+    return {
+      path: ws,
+      version: "transcript-v1",
+      metadata: {
+        workspace_count: chatDirs.length,
+        workspace_storage_path: ws
+      }
+    };
+  }
+  exportSessions(since, limit = 100) {
+    const sinceIso = since ? since.toISOString().slice(0, 10) : null;
+    const transcripts = this.allTranscripts();
+    const sessions = [];
+    for (const info of transcripts) {
+      const session = sessionFromTranscript(info);
+      if (sinceIso && session.date && session.date < sinceIso) continue;
+      sessions.push(session);
+      if (sessions.length >= limit) break;
+    }
+    return sessions;
+  }
+  exportL5(since) {
+    const transcripts = this.allTranscripts();
+    const memories = this.allMemories();
+    const sinceIso = since ? since.toISOString().slice(0, 10) : null;
+    const sessions = [];
+    for (const info of transcripts) {
+      const session = sessionFromTranscript(info);
+      if (sinceIso && session.date && session.date < sinceIso) continue;
+      sessions.push(session);
+    }
+    const entities = [
+      ...entitiesFromMemories(memories),
+      ...entitiesFromTranscripts(transcripts)
+    ];
+    const visibleEntities = (0, import_l515.filterForFederation)(entities, DEFAULT_POLICY14);
+    return (0, import_l515.makeManifest)({
+      spec_version: SPEC_VERSION,
+      agent: (0, import_l515.makeAgentInfo)({
+        id: AGENT_ID15,
+        type: AGENT_TYPE15,
+        instance: (0, import_node_os15.hostname)() || "unknown",
+        spec_version_compat: `>=${SPEC_VERSION}`,
+        role_narrative: ROLE_NARRATIVE15
+      }),
+      last_updated: (/* @__PURE__ */ new Date()).toISOString(),
+      capabilities: [
+        "inline-completion",
+        "chat",
+        "plan-mode",
+        "ask-mode",
+        "explore-mode",
+        "memory-tool",
+        "workspace-scoped"
+      ],
+      recent_sessions: sessions,
+      known_entities: visibleEntities,
+      visibility_policy: DEFAULT_POLICY14
+    });
+  }
+  healthCheck() {
+    try {
+      const ws = this.resolveWs();
+      if (ws === null || !isDir13(ws)) {
+        return {
+          status: "blocked",
+          reason: `VS Code workspaceStorage not found at ${ws ?? "None"}.`,
+          details: { expected_path: ws ?? "None" },
+          proposedFix: "Install VS Code and the GitHub Copilot Chat extension. Set COPILOT_VSCODE_STORAGE if VS Code stores data elsewhere."
+        };
+      }
+      const chatDirs = findCopilotChatDirs(ws);
+      if (chatDirs.length === 0) {
+        return {
+          status: "degraded",
+          reason: "No Copilot Chat data found in any workspace.",
+          details: { workspace_storage: ws },
+          proposedFix: "Open VS Code and start a Copilot Chat conversation, then re-run `bourdon copilot-vscode export`."
+        };
+      }
+      const transcripts = this.allTranscripts();
+      const memories = this.allMemories();
+      return {
+        status: "ok",
+        details: {
+          workspace_storage: ws,
+          workspace_count: chatDirs.length,
+          transcript_count: transcripts.length,
+          memory_file_count: memories.length,
+          total_turns: transcripts.reduce((acc, t) => acc + (t.turn_count || 0), 0)
+        }
+      };
+    } catch (err) {
+      return {
+        status: "degraded",
+        reason: `unexpected error: ${String(err)}`,
+        details: {}
+      };
+    }
+  }
+  // -- Internal ---------------------------------------------------------------
+  /** Collect and parse all transcripts across all workspaces. */
+  allTranscripts() {
+    const ws = this.resolveWs();
+    if (ws === null) return [];
+    const chatDirs = findCopilotChatDirs(ws);
+    const transcripts = [];
+    for (const chatDir of chatDirs) {
+      const transcriptDir = (0, import_node_path15.join)(chatDir, TRANSCRIPTS_DIR);
+      if (!isDir13(transcriptDir)) continue;
+      let files;
+      try {
+        files = (0, import_node_fs15.readdirSync)(transcriptDir).sort();
+      } catch {
+        continue;
+      }
+      for (const fname of files) {
+        if (!fname.endsWith(".jsonl")) continue;
+        const info = parseTranscript((0, import_node_path15.join)(transcriptDir, fname));
+        if (info !== null) transcripts.push(info);
+      }
+    }
+    transcripts.sort((a, b) => {
+      const av = a.start_time ?? "";
+      const bv = b.start_time ?? "";
+      return av < bv ? 1 : av > bv ? -1 : 0;
+    });
+    return transcripts;
+  }
+  /** Collect all memory-tool files across all workspaces. */
+  allMemories() {
+    const ws = this.resolveWs();
+    if (ws === null) return [];
+    const chatDirs = findCopilotChatDirs(ws);
+    const memories = [];
+    for (const chatDir of chatDirs) {
+      memories.push(...parseMemoryFiles(chatDir));
+    }
+    return memories;
+  }
+};
+
 // src/registry.ts
 var FIRST_PARTY = [
   CascadeParticipant,
   ClaudeCodeParticipant,
+  ClaudeCodeAutomationsParticipant,
+  ClaudeDesktopCodeParticipant,
+  ClaudeDesktopCoworkParticipant,
+  CodexAutomationsParticipant,
   CopilotParticipant,
+  CopilotAutomationsParticipant,
   CopilotCliParticipant,
+  CopilotVscodeParticipant,
   CursorParticipant,
+  CursorAutomationsParticipant,
   GitHubCopilotParticipant,
   HermesParticipant,
   OpenClawParticipant
 ];
-var logger3 = {
+var logger9 = {
   warn(msg) {
     console.warn(`[bourdon.participants] ${msg}`);
   }
@@ -3222,7 +6380,7 @@ function discoverParticipants(ctors = FIRST_PARTY) {
     try {
       instance = new Ctor();
     } catch (err) {
-      logger3.warn(
+      logger9.warn(
         `Skipping participant ${Ctor.name || "<anonymous>"}: construction failed: ${String(err)}`
       );
       continue;
@@ -3240,15 +6398,22 @@ function resolvePluginParticipants() {
 }
 
 // src/index.ts
-var import_l59 = require("@getbourdon/l5");
+var import_l516 = require("@getbourdon/l5");
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   CONTRACT_VERSION,
   CacheEntry,
   CascadeParticipant,
+  ClaudeCodeAutomationsParticipant,
   ClaudeCodeParticipant,
+  ClaudeDesktopCodeParticipant,
+  ClaudeDesktopCoworkParticipant,
+  CodexAutomationsParticipant,
+  CopilotAutomationsParticipant,
   CopilotCliParticipant,
   CopilotParticipant,
+  CopilotVscodeParticipant,
+  CursorAutomationsParticipant,
   CursorParticipant,
   DEFAULT_CACHE_TTL_SECONDS,
   FIRST_PARTY,