@withoperon/cli 0.2.0

package/dist/cli.js

@@ -0,0 +1,4100 @@
+#!/usr/bin/env node
+
+// src/cli.ts
+import { Command as Command15, Option as Option5 } from "commander";
+
+// src/commands/config.ts
+import { Command } from "commander";
+import { spawn } from "child_process";
+
+// src/lib/exit-codes.ts
+var EXIT = {
+  ok: 0,
+  err: 1,
+  noWork: 2,
+  // no sources detected, no candidates produced, etc.
+  config: 3,
+  // bad config / setup
+  network: 4,
+  // v1
+  auth: 5,
+  // v1
+  evalFail: 6
+  // v1
+};
+
+// src/lib/globals.ts
+import process2 from "process";
+var resolved;
+function setGlobals(g) {
+  resolved = g;
+}
+function getGlobals() {
+  if (!resolved) {
+    return {
+      json: false,
+      noColor: !process2.stdout.isTTY,
+      quiet: false,
+      verbose: false,
+      configPath: void 0,
+      cwd: process2.cwd()
+    };
+  }
+  return resolved;
+}
+
+// src/lib/logger.ts
+import chalk from "chalk";
+var isColor = () => !getGlobals().noColor;
+var dim = (s) => isColor() ? chalk.dim(s) : s;
+var bold = (s) => isColor() ? chalk.bold(s) : s;
+var yellow = (s) => isColor() ? chalk.yellow(s) : s;
+var red = (s) => isColor() ? chalk.red(s) : s;
+var green = (s) => isColor() ? chalk.green(s) : s;
+var log = {
+  info(msg) {
+    if (getGlobals().quiet) return;
+    console.log(msg);
+  },
+  debug(msg) {
+    if (!getGlobals().verbose) return;
+    console.log(dim(`[debug] ${msg}`));
+  },
+  step(msg) {
+    if (getGlobals().quiet) return;
+    console.log(`${bold(green("\u2192"))} ${msg}`);
+  },
+  warn(msg) {
+    console.warn(`${bold(yellow("!"))} ${msg}`);
+  },
+  err(msg) {
+    console.error(`${bold(red("\u2716"))} ${msg}`);
+  },
+  json(value) {
+    process.stdout.write(`${JSON.stringify(value)}
+`);
+  }
+};
+
+// src/store/config.ts
+import { readFile, writeFile } from "fs/promises";
+import { z } from "zod";
+
+// src/store/paths.ts
+import { mkdir } from "fs/promises";
+import { homedir } from "os";
+import { join } from "path";
+var ROOT = join(homedir(), ".operon");
+var CANDIDATES_DIR = join(ROOT, "candidates");
+var OPERONS_DIR = join(ROOT, "operons");
+var SKILLS_DIR = join(ROOT, "skills");
+var TRASH_DIR = join(ROOT, ".trash");
+var CONFIG_PATH = join(ROOT, "config.json");
+async function ensureDir(path) {
+  await mkdir(path, { recursive: true });
+}
+async function ensureLayout() {
+  await ensureDir(ROOT);
+  await ensureDir(CANDIDATES_DIR);
+  await ensureDir(OPERONS_DIR);
+  await ensureDir(TRASH_DIR);
+}
+function candidateDir(slug) {
+  return join(CANDIDATES_DIR, slug);
+}
+function operonDir(slug) {
+  return join(OPERONS_DIR, slug);
+}
+function skillFile(workspaceSlug, slug) {
+  return join(SKILLS_DIR, workspaceSlug, slug, "SKILL.md");
+}
+function trashDir(undoId) {
+  return join(TRASH_DIR, undoId);
+}
+
+// src/store/config.ts
+var configSchema = z.object({
+  version: z.literal(1).default(1),
+  telemetry: z.object({
+    anonStats: z.boolean().default(false),
+    patternHashes: z.boolean().default(false),
+    anonUserId: z.string().uuid().optional()
+  }).default({}),
+  redact: z.object({
+    patterns: z.array(z.object({ kind: z.string().min(1), regex: z.string().min(1) })).default([]),
+    redactEmails: z.boolean().default(true)
+  }).default({}),
+  paths: z.object({
+    // Reserved for `operon scan --cwd` overrides; v0 leaves empty.
+    cwdAllowlist: z.array(z.string()).default([])
+  }).default({}),
+  // Platform endpoint + signed-in identity. apiBase points at the
+  // deployed apps/web (or http://localhost:3001 during dogfooding).
+  // accessToken may be a Supabase access_token or an op_pat_* token.
+  // workspaceSlug is the default --workspace value for publish/install.
+  platform: z.object({
+    apiBase: z.string().url().default("https://app.withoperon.com"),
+    accessToken: z.string().optional(),
+    refreshToken: z.string().optional(),
+    expiresAt: z.number().int().optional(),
+    userEmail: z.string().optional(),
+    workspaceSlug: z.string().optional()
+  }).default({})
+});
+var DEFAULT_CONFIG = configSchema.parse({});
+async function readConfig() {
+  await ensureLayout();
+  try {
+    const raw = await readFile(CONFIG_PATH, "utf8");
+    const parsed = JSON.parse(raw);
+    return configSchema.parse(parsed);
+  } catch {
+    return DEFAULT_CONFIG;
+  }
+}
+async function writeConfig(config) {
+  await ensureLayout();
+  const validated = configSchema.parse(config);
+  await writeFile(
+    CONFIG_PATH,
+    `${JSON.stringify(validated, null, 2)}
+`,
+    "utf8"
+  );
+}
+function getConfigValue(config, path) {
+  const parts = path.split(".");
+  let cursor = config;
+  for (const p of parts) {
+    if (typeof cursor !== "object" || cursor === null) return void 0;
+    cursor = cursor[p];
+  }
+  return cursor;
+}
+function setConfigValue(config, path, value) {
+  const parts = path.split(".");
+  const next = JSON.parse(JSON.stringify(config));
+  let cursor = next;
+  for (let i = 0; i < parts.length - 1; i += 1) {
+    const key = parts[i];
+    const child = cursor[key];
+    if (typeof child !== "object" || child === null) {
+      cursor[key] = {};
+    }
+    cursor = cursor[key];
+  }
+  cursor[parts[parts.length - 1]] = value;
+  return configSchema.parse(next);
+}
+
+// src/commands/config.ts
+function configCommand() {
+  const cmd = new Command("config").description(
+    "Read / write ~/.operon/config.json."
+  );
+  cmd.command("get <key>").description("Read a config value by dot path.").action(async (key) => {
+    const config = await readConfig();
+    const value = getConfigValue(config, key);
+    if (getGlobals().json) {
+      log.json({ key, value });
+    } else {
+      log.info(value === void 0 ? "(unset)" : JSON.stringify(value));
+    }
+    process.exit(EXIT.ok);
+  });
+  cmd.command("set <key> <value>").description(
+    "Write a config value by dot path. Booleans true/false; JSON literal otherwise."
+  ).action(async (key, raw) => {
+    const value = parseConfigValue(raw);
+    const config = await readConfig();
+    const next = setConfigValue(config, key, value);
+    await writeConfig(next);
+    log.step(`config set ${key} = ${JSON.stringify(value)}`);
+    process.exit(EXIT.ok);
+  });
+  cmd.command("edit").description("Open ~/.operon/config.json in $EDITOR.").action(() => {
+    const editor = process.env["EDITOR"] ?? process.env["VISUAL"] ?? "vi";
+    const child = spawn(editor, [CONFIG_PATH], { stdio: "inherit" });
+    child.on("exit", (code) => process.exit(code ?? 0));
+  });
+  return cmd;
+}
+function parseConfigValue(raw) {
+  if (raw === "true") return true;
+  if (raw === "false") return false;
+  try {
+    return JSON.parse(raw);
+  } catch {
+    return raw;
+  }
+}
+
+// src/commands/doctor.ts
+import { stat as stat4 } from "fs/promises";
+import { Command as Command2 } from "commander";
+import { z as z2 } from "zod";
+
+// src/ingestion/claude-code.ts
+import { readdir, stat } from "fs/promises";
+import { homedir as homedir2 } from "os";
+import { basename, join as join2 } from "path";
+
+// src/ingestion/jsonl.ts
+import { createReadStream } from "fs";
+import { createInterface } from "readline";
+async function* readJsonl(path, opts = {}) {
+  const stream = createReadStream(path, { encoding: "utf8" });
+  const rl = createInterface({
+    input: stream,
+    crlfDelay: Infinity
+  });
+  let lineNumber = 0;
+  for await (const raw of rl) {
+    lineNumber += 1;
+    if (raw.length === 0 && opts.skipEmpty !== false) continue;
+    try {
+      yield JSON.parse(raw);
+    } catch (e) {
+      opts.onError?.(lineNumber, raw, e);
+    }
+  }
+}
+
+// src/ingestion/normalize.ts
+import { extname } from "path";
+function fileExtension(p) {
+  const ext = extname(p);
+  return ext.length > 0 && ext.length < 8 ? ext.toLowerCase() : "<none>";
+}
+function fileTouchesFromPaths(paths) {
+  const counts = /* @__PURE__ */ new Map();
+  for (const p of paths) {
+    const ext = fileExtension(p);
+    counts.set(ext, (counts.get(ext) ?? 0) + 1);
+  }
+  return [...counts.entries()].map(([extension, count]) => ({
+    extension,
+    count
+  }));
+}
+function aggregateToolCalls(calls) {
+  const sums = /* @__PURE__ */ new Map();
+  for (const c of calls) {
+    const key = c.name;
+    const existing = sums.get(key) ?? { name: key, arity: 0, uses: 0 };
+    existing.arity = Math.max(existing.arity, c.arity ?? 0);
+    existing.uses += 1;
+    sums.set(key, existing);
+  }
+  return [...sums.values()].map(({ name, arity, uses }) => ({
+    name,
+    arity,
+    count: uses
+  }));
+}
+function safeDate(value) {
+  if (typeof value !== "string" && typeof value !== "number") return void 0;
+  const d = new Date(value);
+  return Number.isFinite(d.getTime()) ? d : void 0;
+}
+function durationSec(start, end) {
+  return Math.max(0, Math.round((end.getTime() - start.getTime()) / 1e3));
+}
+function isAfter(d, cutoff) {
+  if (cutoff === void 0) return true;
+  if (d === void 0) return true;
+  return d.getTime() >= cutoff.getTime();
+}
+
+// src/ingestion/claude-code.ts
+var ROOT2 = join2(homedir2(), ".claude", "projects");
+var FILE_TOUCH_TOOLS = /* @__PURE__ */ new Set([
+  "Edit",
+  "Write",
+  "MultiEdit",
+  "NotebookEdit"
+]);
+var claudeCodeAdapter = {
+  name: "claude-code",
+  async detect() {
+    try {
+      const s = await stat(ROOT2);
+      if (!s.isDirectory()) {
+        return { present: false, reason: `${ROOT2} is not a directory` };
+      }
+      return { present: true };
+    } catch {
+      return { present: false, reason: `${ROOT2} not found` };
+    }
+  },
+  async *enumerate(opts) {
+    let projects;
+    try {
+      projects = await readdir(ROOT2);
+    } catch {
+      return;
+    }
+    let yielded = 0;
+    for (const project of projects) {
+      const projectDir = join2(ROOT2, project);
+      let entries;
+      try {
+        entries = await readdir(projectDir);
+      } catch {
+        continue;
+      }
+      for (const entry of entries) {
+        if (!entry.endsWith(".jsonl")) continue;
+        const path = join2(projectDir, entry);
+        let mtime;
+        try {
+          const s = await stat(path);
+          mtime = s.mtime;
+        } catch {
+          continue;
+        }
+        if (!isAfter(mtime, opts.since)) continue;
+        if (opts.cwdFilter !== void 0 && opts.cwdFilter.length > 0) {
+        }
+        yield {
+          source: "claude-code",
+          path,
+          rawId: basename(entry, ".jsonl"),
+          records: readJsonl(path, {
+            onError: (ln, _raw, e) => {
+              process.stderr.write(
+                `! claude-code: ${path}:${ln} ${e.message}
+`
+              );
+            }
+          })
+        };
+        yielded += 1;
+        if (opts.limit !== void 0 && yielded >= opts.limit) return;
+      }
+    }
+  },
+  async normalize(raw) {
+    const messages = [];
+    const toolCalls = [];
+    const filePaths = [];
+    const modelHints = /* @__PURE__ */ new Set();
+    let cwd;
+    let firstTs;
+    let lastTs;
+    for await (const record of raw.records) {
+      const line = record;
+      const ts = safeDate(line.timestamp);
+      if (ts !== void 0) {
+        if (firstTs === void 0 || ts < firstTs) firstTs = ts;
+        if (lastTs === void 0 || ts > lastTs) lastTs = ts;
+      }
+      if (line.cwd !== void 0 && cwd === void 0) cwd = line.cwd;
+      if (line.type === "user" || line.type === "assistant") {
+        const role = line.message?.role ?? line.type;
+        if (line.message?.model !== void 0) {
+          modelHints.add(line.message.model);
+        }
+        const content = line.message?.content;
+        if (typeof content === "string") {
+          messages.push({ role, content });
+        } else if (Array.isArray(content)) {
+          const textParts = [];
+          for (const block of content) {
+            if (block.type === "text" && typeof block.text === "string") {
+              textParts.push(block.text);
+            } else if (block.type === "thinking" && typeof block.text === "string") {
+              textParts.push(block.text);
+            } else if (block.type === "tool_use" && typeof block.name === "string") {
+              const arity = typeof block.input === "object" && block.input !== null ? Object.keys(block.input).length : 0;
+              toolCalls.push({ name: block.name, arity });
+              if (FILE_TOUCH_TOOLS.has(block.name)) {
+                const filePath = extractFilePath(
+                  block.input
+                );
+                if (filePath !== void 0) filePaths.push(filePath);
+              }
+            }
+          }
+          if (textParts.length > 0) {
+            messages.push({ role, content: textParts.join("\n") });
+          }
+        }
+      }
+    }
+    const startedAt = firstTs ?? /* @__PURE__ */ new Date(0);
+    const endedAt = lastTs ?? startedAt;
+    const session = {
+      id: `claude-code:${raw.rawId}`,
+      source: "claude-code",
+      startedAt,
+      endedAt,
+      durationSec: durationSec(startedAt, endedAt),
+      modelHints: [...modelHints],
+      messages,
+      toolCalls: aggregateToolCalls(toolCalls),
+      fileTouches: fileTouchesFromPaths(filePaths),
+      outcome: "unknown"
+    };
+    if (cwd !== void 0) session.cwd = cwd;
+    return session;
+  }
+};
+function extractFilePath(input2) {
+  if (input2 === void 0) return void 0;
+  for (const key of ["file_path", "path", "notebook_path"]) {
+    const v = input2[key];
+    if (typeof v === "string" && v.length > 0) return v;
+  }
+  return void 0;
+}
+
+// src/ingestion/codex.ts
+import { readdir as readdir2, stat as stat2 } from "fs/promises";
+import { homedir as homedir3 } from "os";
+import { basename as basename2, join as join3 } from "path";
+var ROOT3 = join3(homedir3(), ".codex", "sessions");
+var codexAdapter = {
+  name: "codex",
+  async detect() {
+    try {
+      const s = await stat2(ROOT3);
+      if (!s.isDirectory()) {
+        return { present: false, reason: `${ROOT3} is not a directory` };
+      }
+      return { present: true };
+    } catch {
+      return { present: false, reason: `${ROOT3} not found` };
+    }
+  },
+  async *enumerate(opts) {
+    let yielded = 0;
+    for await (const path of walkJsonl(ROOT3)) {
+      let mtime;
+      try {
+        const s = await stat2(path);
+        mtime = s.mtime;
+      } catch {
+        continue;
+      }
+      if (!isAfter(mtime, opts.since)) continue;
+      const rawId = parseRawIdFromFilename(basename2(path));
+      yield {
+        source: "codex",
+        path,
+        rawId,
+        records: readJsonl(path, {
+          onError: (ln, _raw, e) => {
+            process.stderr.write(`! codex: ${path}:${ln} ${e.message}
+`);
+          }
+        })
+      };
+      yielded += 1;
+      if (opts.limit !== void 0 && yielded >= opts.limit) return;
+    }
+  },
+  async normalize(raw) {
+    const messages = [];
+    const toolCalls = [];
+    const filePaths = [];
+    const modelHints = /* @__PURE__ */ new Set();
+    let cwd;
+    let firstTs;
+    let lastTs;
+    for await (const record of raw.records) {
+      const line = record;
+      const ts = safeDate(line.timestamp) ?? safeDate(line.payload?.timestamp);
+      if (ts !== void 0) {
+        if (firstTs === void 0 || ts < firstTs) firstTs = ts;
+        if (lastTs === void 0 || ts > lastTs) lastTs = ts;
+      }
+      if (line.type === "session_meta") {
+        if (line.payload?.cwd !== void 0 && cwd === void 0) {
+          cwd = line.payload.cwd;
+        }
+        continue;
+      }
+      if (line.type !== "response_item") continue;
+      const p = line.payload;
+      if (p === void 0) continue;
+      if (p.model !== void 0) modelHints.add(p.model);
+      if (p.type === "message") {
+        const role = p.role ?? "assistant";
+        const content = p.content;
+        if (typeof content === "string") {
+          messages.push({ role, content });
+        } else if (Array.isArray(content)) {
+          const textParts = [];
+          for (const block of content) {
+            if (typeof block.text === "string") textParts.push(block.text);
+          }
+          if (textParts.length > 0) {
+            messages.push({ role, content: textParts.join("\n") });
+          }
+        }
+      } else if (p.type === "function_call") {
+        if (typeof p.name !== "string") continue;
+        const args = parseArguments(p.arguments);
+        const arity = args !== void 0 ? Object.keys(args).length : 0;
+        toolCalls.push({ name: p.name, arity });
+        const filePath = extractFilePath2(args);
+        if (filePath !== void 0) filePaths.push(filePath);
+      } else if (p.type === "custom_tool_call") {
+        if (typeof p.name !== "string") continue;
+        toolCalls.push({ name: p.name, arity: 1 });
+        const filePath = extractFilePathFromPatch(p.input);
+        if (filePath !== void 0) filePaths.push(filePath);
+      }
+    }
+    const startedAt = firstTs ?? /* @__PURE__ */ new Date(0);
+    const endedAt = lastTs ?? startedAt;
+    const session = {
+      id: `codex:${raw.rawId}`,
+      source: "codex",
+      startedAt,
+      endedAt,
+      durationSec: durationSec(startedAt, endedAt),
+      modelHints: [...modelHints],
+      messages,
+      toolCalls: aggregateToolCalls(toolCalls),
+      fileTouches: fileTouchesFromPaths(filePaths),
+      outcome: "unknown"
+    };
+    if (cwd !== void 0) session.cwd = cwd;
+    return session;
+  }
+};
+async function* walkJsonl(dir) {
+  let entries;
+  try {
+    entries = await readdir2(dir, { withFileTypes: true });
+  } catch {
+    return;
+  }
+  for (const entry of entries) {
+    const p = join3(dir, entry.name);
+    if (entry.isDirectory()) {
+      yield* walkJsonl(p);
+    } else if (entry.isFile() && entry.name.endsWith(".jsonl")) {
+      yield p;
+    }
+  }
+}
+function parseRawIdFromFilename(name) {
+  const stem = name.replace(/\.jsonl$/, "");
+  const m = /-([0-9a-f-]{36})$/.exec(stem);
+  return m?.[1] ?? stem;
+}
+function parseArguments(s) {
+  if (typeof s !== "string" || s.length === 0) return void 0;
+  try {
+    const parsed = JSON.parse(s);
+    if (typeof parsed === "object" && parsed !== null) {
+      return parsed;
+    }
+  } catch {
+  }
+  return void 0;
+}
+function extractFilePath2(input2) {
+  if (input2 === void 0) return void 0;
+  for (const key of ["path", "file_path", "filename"]) {
+    const v = input2[key];
+    if (typeof v === "string" && v.length > 0) return v;
+  }
+  return void 0;
+}
+function extractFilePathFromPatch(input2) {
+  if (typeof input2 !== "string") return void 0;
+  const m = /\*\*\* (?:Update|Add|Delete) File: (.+)$/m.exec(input2);
+  return m?.[1] ?? void 0;
+}
+
+// src/ingestion/cursor.ts
+import { readdir as readdir3, readFile as readFile2, stat as stat3 } from "fs/promises";
+import { createRequire } from "module";
+import { homedir as homedir4 } from "os";
+import { basename as basename3, join as join4 } from "path";
+import { fileURLToPath } from "url";
+var ROOTS = cursorWorkspaceStorageRoots();
+var CHATDATA_KEY = "workbench.panel.aichat.view.aichat.chatdata";
+var require2 = createRequire(import.meta.url);
+var cursorAdapter = {
+  name: "cursor",
+  async detect() {
+    if (loadSqlite() === void 0) {
+      return { present: false, reason: "node:sqlite unavailable" };
+    }
+    for (const root of ROOTS) {
+      try {
+        const s = await stat3(root);
+        if (s.isDirectory()) return { present: true };
+      } catch {
+      }
+    }
+    return { present: false, reason: `${ROOTS.join(", ")} not found` };
+  },
+  async *enumerate(opts) {
+    const sqlite = loadSqlite();
+    if (sqlite === void 0) return;
+    let yielded = 0;
+    for (const root of ROOTS) {
+      let entries;
+      try {
+        entries = await readdir3(root, { withFileTypes: true });
+      } catch {
+        continue;
+      }
+      for (const entry of entries) {
+        if (!entry.isDirectory()) continue;
+        const storageDir = join4(root, entry.name);
+        const dbPath = join4(storageDir, "state.vscdb");
+        let dbMtime;
+        try {
+          dbMtime = (await stat3(dbPath)).mtime;
+        } catch {
+          continue;
+        }
+        if (!isAfter(dbMtime, opts.since)) continue;
+        const chatData = readChatData(sqlite, dbPath);
+        if (chatData === void 0) continue;
+        const cwd = await readWorkspaceFolder(storageDir);
+        const tabs = Array.isArray(chatData.tabs) ? chatData.tabs : [];
+        for (const tab of tabs) {
+          const startedAt = tabStartedAt(tab, dbMtime);
+          if (!isAfter(startedAt, opts.since)) continue;
+          const tabId = typeof tab.tabId === "string" && tab.tabId.length > 0 ? tab.tabId : String(yielded);
+          yield {
+            source: "cursor",
+            path: dbPath,
+            rawId: `${basename3(storageDir)}:${tabId}`,
+            records: fromArray([{ tab, cwd, dbMtimeMs: dbMtime.getTime() }])
+          };
+          yielded += 1;
+          if (opts.limit !== void 0 && yielded >= opts.limit) return;
+        }
+      }
+    }
+  },
+  async normalize(raw) {
+    const messages = [];
+    const toolCalls = [];
+    const filePaths = [];
+    const modelHints = /* @__PURE__ */ new Set();
+    let cwd;
+    let firstTs;
+    let lastTs;
+    let fallbackTs = /* @__PURE__ */ new Date(0);
+    for await (const record of raw.records) {
+      const cursorRecord = record;
+      if (cursorRecord.cwd !== void 0 && cwd === void 0) {
+        cwd = cursorRecord.cwd;
+      }
+      fallbackTs = new Date(cursorRecord.dbMtimeMs);
+      for (const bubble of cursorRecord.tab.bubbles ?? []) {
+        const ts = timestampFromBubble(bubble);
+        if (ts !== void 0) {
+          if (firstTs === void 0 || ts < firstTs) firstTs = ts;
+          if (lastTs === void 0 || ts > lastTs) lastTs = ts;
+        }
+        const content = bubbleText(bubble);
+        const role = roleFromBubble(bubble);
+        if (role !== void 0 && content !== void 0) {
+          messages.push({ role, content });
+        }
+        if (typeof bubble.modelType === "string") {
+          modelHints.add(bubble.modelType);
+        }
+        if (bubble.type === "ai" || bubble.messageType === 3) {
+          toolCalls.push({ name: "CursorChat", arity: 1 });
+        }
+        for (const path of selectionPaths(bubble)) {
+          filePaths.push(path);
+        }
+      }
+    }
+    const startedAt = firstTs ?? fallbackTs;
+    const endedAt = lastTs ?? startedAt;
+    const session = {
+      id: `cursor:${raw.rawId}`,
+      source: "cursor",
+      startedAt,
+      endedAt,
+      durationSec: durationSec(startedAt, endedAt),
+      modelHints: [...modelHints],
+      messages,
+      toolCalls: aggregateToolCalls(toolCalls),
+      fileTouches: fileTouchesFromPaths(filePaths),
+      outcome: "unknown"
+    };
+    if (cwd !== void 0) session.cwd = cwd;
+    return session;
+  }
+};
+function loadSqlite() {
+  try {
+    return require2("node:sqlite");
+  } catch {
+    return void 0;
+  }
+}
+function cursorWorkspaceStorageRoots() {
+  if (process.platform === "darwin") {
+    return [
+      join4(
+        homedir4(),
+        "Library",
+        "Application Support",
+        "Cursor",
+        "User",
+        "workspaceStorage"
+      )
+    ];
+  }
+  if (process.platform === "win32" && process.env.APPDATA !== void 0) {
+    return [join4(process.env.APPDATA, "Cursor", "User", "workspaceStorage")];
+  }
+  return [join4(homedir4(), ".config", "Cursor", "User", "workspaceStorage")];
+}
+function readChatData(sqlite, dbPath) {
+  let db;
+  try {
+    db = new sqlite.DatabaseSync(dbPath, { readOnly: true });
+    const row = db.prepare("select value from ItemTable where key = ?").get(CHATDATA_KEY);
+    if (typeof row?.value !== "string") return void 0;
+    const parsed = JSON.parse(row.value);
+    if (typeof parsed !== "object" || parsed === null) return void 0;
+    return parsed;
+  } catch {
+    return void 0;
+  } finally {
+    db?.close();
+  }
+}
+async function readWorkspaceFolder(storageDir) {
+  try {
+    const raw = await readFile2(join4(storageDir, "workspace.json"), "utf8");
+    const parsed = JSON.parse(raw);
+    const folder = typeof parsed.folder === "string" ? parsed.folder : typeof parsed.workspace === "string" ? parsed.workspace : void 0;
+    if (folder === void 0) return void 0;
+    if (folder.startsWith("file:")) return fileURLToPath(folder);
+    return folder;
+  } catch {
+    return void 0;
+  }
+}
+function tabStartedAt(tab, fallback) {
+  const timestamps = (tab.bubbles ?? []).map(timestampFromBubble).filter((d) => d !== void 0).sort((a, b) => a.getTime() - b.getTime());
+  return timestamps[0] ?? fallback;
+}
+function timestampFromBubble(bubble) {
+  if (typeof bubble.contextCacheTimestamp !== "number" || !Number.isFinite(bubble.contextCacheTimestamp)) {
+    return void 0;
+  }
+  return new Date(bubble.contextCacheTimestamp);
+}
+function roleFromBubble(bubble) {
+  if (bubble.type === "user" || bubble.messageType === 2) return "user";
+  if (bubble.type === "ai" || bubble.messageType === 3) return "assistant";
+  return void 0;
+}
+function bubbleText(bubble) {
+  for (const value of [bubble.rawText, bubble.initText, bubble.text]) {
+    if (typeof value === "string" && value.trim().length > 0) {
+      return value;
+    }
+  }
+  return void 0;
+}
+function selectionPaths(bubble) {
+  const paths = [];
+  for (const selection of [
+    ...bubble.selections ?? [],
+    ...bubble.fileSelections ?? []
+  ]) {
+    const uri = selection.uri;
+    if (uri === void 0) continue;
+    if (typeof uri.fsPath === "string" && uri.fsPath.length > 0) {
+      paths.push(uri.fsPath);
+    } else if (uri.scheme === "file" && typeof uri.path === "string") {
+      paths.push(uri.path);
+    }
+  }
+  return paths;
+}
+async function* fromArray(items) {
+  for (const item of items) yield item;
+}
+
+// src/ingestion/redact.ts
+var BUILTIN = [
+  { kind: "stripe", re: /sk_(live|test)_[A-Za-z0-9]{24,}/g },
+  { kind: "github", re: /\b(ghp|gho|ghu|ghs|ghr)_[A-Za-z0-9]{36,}\b/g },
+  { kind: "aws", re: /\bAKIA[0-9A-Z]{16}\b/g },
+  {
+    kind: "jwt",
+    re: /\beyJ[A-Za-z0-9_-]{10,}\.[A-Za-z0-9_-]+\.[A-Za-z0-9_-]+\b/g
+  },
+  { kind: "openai", re: /\bsk-[A-Za-z0-9]{32,}\b/g },
+  { kind: "anthropic", re: /\bsk-ant-[A-Za-z0-9-]{32,}\b/g },
+  {
+    kind: "email",
+    re: /\b[A-Za-z0-9._%+-]+@[A-Za-z0-9.-]+\.[A-Za-z]{2,}\b/g
+  }
+];
+var ENTROPY_RE = /\b[A-Za-z0-9_+\/=-]{40,}\b/g;
+function redactString(s, cfg = {}) {
+  if (s.length === 0) return s;
+  let out = s;
+  for (const { kind, re } of BUILTIN) {
+    if (kind === "email" && cfg.redactEmails === false) continue;
+    out = out.replace(re, `[REDACTED:${kind}]`);
+  }
+  for (const { kind, re } of cfg.userPatterns ?? []) {
+    out = out.replace(re, `[REDACTED:${kind}]`);
+  }
+  out = out.replace(
+    ENTROPY_RE,
+    (m) => isEntropyHit(m) ? `[REDACTED:high-entropy]` : m
+  );
+  return out;
+}
+function isEntropyHit(m) {
+  let hasDigit = false;
+  let hasUpper = false;
+  let hasLower = false;
+  let hasSymbol = false;
+  for (const c of m) {
+    if (c >= "0" && c <= "9") hasDigit = true;
+    else if (c >= "A" && c <= "Z") hasUpper = true;
+    else if (c >= "a" && c <= "z") hasLower = true;
+    else hasSymbol = true;
+  }
+  const classes = Number(hasDigit) + Number(hasUpper) + Number(hasLower) + Number(hasSymbol);
+  return classes >= 3;
+}
+function redactSession(session, cfg = {}) {
+  return {
+    ...session,
+    messages: session.messages.map((m) => ({
+      ...m,
+      content: redactString(m.content, cfg)
+    }))
+  };
+}
+
+// src/ingestion/index.ts
+var ADAPTERS = {
+  "claude-code": claudeCodeAdapter,
+  codex: codexAdapter,
+  cursor: cursorAdapter,
+  // ChatGPT is exploratory and not wired here.
+  chatgpt: void 0
+};
+
+// src/render/doctor-report.ts
+import chalk2 from "chalk";
+function renderDoctorReport(r) {
+  const colored = !getGlobals().noColor;
+  const ok = (s) => colored ? chalk2.green(s) : s;
+  const bad = (s) => colored ? chalk2.red(s) : s;
+  const dim2 = (s) => colored ? chalk2.dim(s) : s;
+  const lines = [];
+  lines.push("Sources detected:");
+  for (const s of r.sources) {
+    const mark = s.present ? ok("\u2713") : bad("\u2717");
+    const reason = s.reason !== void 0 ? dim2(`  ${s.reason}`) : "";
+    lines.push(`  ${mark} ${s.name}${reason}`);
+  }
+  lines.push("");
+  lines.push("Local layout:");
+  for (const l of r.layout) {
+    const mark = l.ok ? ok("\u2713") : bad("\u2717");
+    const detail = l.detail !== void 0 ? dim2(`  ${l.detail}`) : "";
+    lines.push(`  ${mark} ${l.path}${detail}`);
+  }
+  lines.push("");
+  lines.push("Telemetry:");
+  lines.push(
+    `  anon-stats:        ${r.telemetry.anonStats ? ok("opt-in") : dim2("disabled")}`
+  );
+  lines.push(
+    `  pattern-hashes:    ${r.telemetry.patternHashes ? ok("opt-in") : dim2("disabled")}`
+  );
+  lines.push("");
+  lines.push(`Operon CLI v${r.cliVersion}`);
+  return lines.join("\n");
+}
+
+// src/version.ts
+import { readFileSync } from "fs";
+var CLI_VERSION = readCliVersion();
+function readCliVersion() {
+  try {
+    const packageJson = JSON.parse(
+      readFileSync(new URL("../package.json", import.meta.url), "utf8")
+    );
+    return typeof packageJson.version === "string" ? packageJson.version : "0.0.0";
+  } catch {
+    return "0.0.0";
+  }
+}
+
+// src/commands/doctor.ts
+var optsSchema = z2.object({
+  fix: z2.boolean().default(false)
+});
+function doctorCommand() {
+  return new Command2("doctor").description("Sanity-check the install and local data layout.").option("--fix", "Attempt to repair config / permissions issues", false).action(async (rawOpts) => {
+    const opts = optsSchema.parse(rawOpts);
+    if (opts.fix) await ensureLayout();
+    const sources = [];
+    for (const [name, adapter] of Object.entries(ADAPTERS)) {
+      if (adapter === void 0) {
+        sources.push({
+          name,
+          present: false,
+          reason: "not enabled in v0"
+        });
+        continue;
+      }
+      const detect = await adapter.detect();
+      const result = {
+        name,
+        present: detect.present
+      };
+      if (detect.reason !== void 0) result.reason = detect.reason;
+      sources.push(result);
+    }
+    const layout = [];
+    for (const path of [ROOT, CANDIDATES_DIR, OPERONS_DIR]) {
+      try {
+        const s = await stat4(path);
+        layout.push({
+          path,
+          ok: s.isDirectory(),
+          detail: s.isDirectory() ? "ok" : "not a directory"
+        });
+      } catch {
+        layout.push({
+          path,
+          ok: false,
+          detail: "missing \u2014 run `operon doctor --fix`"
+        });
+      }
+    }
+    const config = await readConfig();
+    const report = {
+      sources,
+      layout,
+      telemetry: {
+        anonStats: config.telemetry.anonStats,
+        patternHashes: config.telemetry.patternHashes
+      },
+      cliVersion: CLI_VERSION
+    };
+    if (getGlobals().json) {
+      log.json(report);
+      process.exit(EXIT.ok);
+    }
+    log.info(renderDoctorReport(report));
+    const allOk = sources.some((s) => s.present) && layout.every((l) => l.ok);
+    process.exit(allOk ? EXIT.ok : EXIT.config);
+  });
+}
+
+// src/commands/install.ts
+import { createHash } from "crypto";
+import { mkdir as mkdir2, readFile as readFile3, writeFile as writeFile2 } from "fs/promises";
+import { homedir as homedir5 } from "os";
+import { dirname, join as join5 } from "path";
+import { Command as Command3 } from "commander";
+import { z as z4 } from "zod";
+
+// src/lib/runs.ts
+import { z as z3 } from "zod";
+var slugRe = /^[a-z0-9-]+$/;
+var semverRe = /^\d+\.\d+\.\d+(-[a-z0-9.]+)?$/;
+var sha256HexRe = /^[a-f0-9]{64}$/i;
+var maxInt = 2147483647;
+var recordRunPayloadSchema = z3.object({
+  workspaceSlug: z3.string().min(1).max(64).regex(slugRe),
+  operonSlug: z3.string().min(1).max(64).regex(slugRe),
+  semver: z3.string().min(1).max(64).regex(semverRe),
+  invocationSource: z3.enum(["cli", "mcp", "webhook", "dashboard"]),
+  status: z3.enum(["running", "succeeded", "failed", "timeout"]),
+  startedAt: z3.string().datetime({ offset: true }).optional(),
+  finishedAt: z3.string().datetime({ offset: true }).optional(),
+  durationMs: z3.number().int().min(0).max(maxInt).optional(),
+  inputHash: z3.string().regex(sha256HexRe).optional(),
+  tokenIn: z3.number().int().min(0).max(maxInt).optional(),
+  tokenOut: z3.number().int().min(0).max(maxInt).optional(),
+  costUsdEstimated: z3.number().finite().min(0).max(9999.999999).optional(),
+  billedRunCount: z3.number().int().min(1).max(maxInt).optional()
+});
+var recordRunResponseSchema = z3.object({
+  runId: z3.string().uuid(),
+  status: z3.enum(["running", "succeeded", "failed", "timeout"]),
+  runsUsedMtd: z3.number().int().nonnegative(),
+  runsCap: z3.number().int().nonnegative().nullable(),
+  overCap: z3.boolean()
+});
+var RecordRunError = class extends Error {
+  exitCode;
+  status;
+  body;
+  constructor(message, exitCode, status, body) {
+    super(message);
+    this.name = "RecordRunError";
+    this.exitCode = exitCode;
+    this.status = status;
+    this.body = body;
+  }
+};
+async function recordRun(input2) {
+  const {
+    apiBase: apiBaseOverride,
+    token: tokenOverride,
+    fetchImpl = fetch,
+    ...payloadInput
+  } = input2;
+  const payload = recordRunPayloadSchema.parse(payloadInput);
+  const config = await readConfig();
+  const apiBase = (apiBaseOverride ?? config.platform.apiBase ?? "https://app.withoperon.com").replace(/\/+$/, "");
+  const token = tokenOverride ?? config.platform.accessToken;
+  if (token === void 0 || token.length === 0) {
+    throw new RecordRunError("not signed in. Run: operon login", EXIT.auth);
+  }
+  let res;
+  try {
+    res = await fetchImpl(`${apiBase}/api/v1/runs`, {
+      method: "POST",
+      headers: {
+        "content-type": "application/json",
+        "x-operon-source": "cli",
+        authorization: `Bearer ${token}`
+      },
+      body: JSON.stringify(payload)
+    });
+  } catch (e) {
+    throw new RecordRunError(
+      `network error: ${e.message}`,
+      EXIT.network
+    );
+  }
+  if (!res.ok) {
+    const body = await res.text().catch(() => "<unreadable>");
+    throw new RecordRunError(
+      `server returned ${res.status}: ${body.slice(0, 400)}`,
+      res.status === 401 ? EXIT.auth : EXIT.err,
+      res.status,
+      body
+    );
+  }
+  return recordRunResponseSchema.parse(await res.json());
+}
+
+// src/commands/install.ts
+var slugSchema = z4.string().min(1).max(64).regex(/^[a-z0-9-]+$/);
+var workspaceSchema = z4.string().min(1).max(64).regex(/^[a-z0-9-]+$/);
+var installRefSchema = z4.string().min(1).max(129).regex(/^[a-z0-9-]+(?:\/[a-z0-9-]+)?$/);
+var optsSchema2 = z4.object({
+  workspace: workspaceSchema.optional(),
+  semver: z4.string().min(1).max(64).regex(/^\d+\.\d+\.\d+(-[a-z0-9.]+)?$/).optional(),
+  target: z4.enum(["all", "claude", "codex"]).default("all"),
+  force: z4.boolean().default(false),
+  json: z4.boolean().default(false),
+  apiBase: z4.string().url().optional()
+});
+var installResponseSchema = z4.object({
+  workspace: z4.object({
+    slug: z4.string(),
+    name: z4.string()
+  }),
+  operon: z4.object({
+    slug: z4.string(),
+    name: z4.string(),
+    description: z4.string().nullable(),
+    visibility: z4.string(),
+    tags: z4.array(z4.string())
+  }),
+  version: z4.object({
+    semver: z4.string(),
+    contentHash: z4.string().regex(/^[a-f0-9]{64}$/i),
+    publishStatus: z4.string(),
+    evalStatus: z4.string(),
+    createdAt: z4.string(),
+    changelog: z4.string().nullable()
+  }),
+  skillUrl: z4.string().url(),
+  runRecorded: z4.boolean().optional()
+});
+function installCommand() {
+  return new Command3("install").argument("<workspace/slug>", "Operon to install, e.g. acme/review-pr").description("Install an operon's SKILL.md into Claude Code and Codex.").option("--workspace <slug>", "Workspace slug for scriptable install form").option("--semver <x.y.z>", "Version to install; defaults to current").option("--target <target>", "all | claude | codex (default: all)", "all").option("--force", "Overwrite existing different local skill files", false).option("--json", "Machine-readable JSON output", false).option("--api-base <url>", "Override platform base URL").action(async (refArg, rawOpts) => {
+    const ref = installRefSchema.parse(refArg);
+    const opts = optsSchema2.parse(rawOpts);
+    const config = await readConfig();
+    const parsed = parseInstallRef(ref, opts.workspace);
+    const workspaceSlug = parsed.workspace ?? config.platform.workspaceSlug;
+    if (workspaceSlug === void 0 || workspaceSlug.length === 0) {
+      log.err(
+        "missing workspace. Use operon install <workspace>/<slug> or pass --workspace."
+      );
+      process.exit(EXIT.config);
+      return;
+    }
+    const apiBase = (opts.apiBase ?? config.platform.apiBase ?? "https://app.withoperon.com").replace(/\/+$/, "");
+    const token = config.platform.accessToken;
+    const startedAt = /* @__PURE__ */ new Date();
+    const metadata = await fetchMetadata({
+      apiBase,
+      workspaceSlug,
+      slug: parsed.slug,
+      semver: opts.semver,
+      token
+    });
+    if (metadata === void 0) return;
+    const skillBody = await fetchSkill(metadata.skillUrl);
+    if (skillBody === void 0) return;
+    const actualHash = sha256Hex(skillBody);
+    const expectedHash = metadata.version.contentHash.toLowerCase();
+    if (actualHash !== expectedHash) {
+      log.err(
+        `content hash mismatch: expected ${expectedHash}, got ${actualHash}`
+      );
+      process.exit(EXIT.err);
+      return;
+    }
+    const plans = await buildWritePlans({
+      workspaceSlug: metadata.workspace.slug,
+      slug: metadata.operon.slug,
+      body: skillBody,
+      target: opts.target,
+      force: opts.force
+    });
+    if (plans === void 0) return;
+    for (const plan of plans) {
+      await mkdir2(dirname(plan.path), { recursive: true });
+      if (plan.status !== "already-installed") {
+        await writeFile2(plan.path, skillBody, "utf8");
+      }
+    }
+    let runRecorded = metadata.runRecorded === true;
+    if (token !== void 0 && token.length > 0) {
+      const finishedAt = /* @__PURE__ */ new Date();
+      try {
+        await recordRun({
+          workspaceSlug: metadata.workspace.slug,
+          operonSlug: metadata.operon.slug,
+          semver: metadata.version.semver,
+          invocationSource: "cli",
+          status: "succeeded",
+          startedAt: startedAt.toISOString(),
+          finishedAt: finishedAt.toISOString(),
+          durationMs: Math.max(0, finishedAt.getTime() - startedAt.getTime()),
+          inputHash: expectedHash,
+          apiBase,
+          token
+        });
+        runRecorded = true;
+      } catch (e) {
+        if (e instanceof RecordRunError) {
+          log.err(e.message);
+          process.exit(e.exitCode);
+          return;
+        }
+        log.err(`could not record run: ${e.message}`);
+        process.exit(EXIT.err);
+        return;
+      }
+    } else if (!runRecorded) {
+      log.warn(
+        "not signed in; installed public operon without recording a run"
+      );
+    }
+    const json = {
+      workspace: metadata.workspace.slug,
+      slug: metadata.operon.slug,
+      semver: metadata.version.semver,
+      contentHash: expectedHash,
+      runRecorded,
+      targets: plans
+    };
+    if (getGlobals().json || opts.json) {
+      log.json(json);
+    } else {
+      log.step(
+        `installed ${metadata.workspace.slug}/${metadata.operon.slug}@${metadata.version.semver}`
+      );
+      for (const plan of plans) {
+        log.info(`  ${plan.target}: ${plan.status} ${plan.path}`);
+      }
+      if (runRecorded) log.info("  run recorded");
+    }
+    process.exit(EXIT.ok);
+  });
+}
+function parseInstallRef(ref, workspaceOpt) {
+  const parts = ref.split("/");
+  if (parts.length === 2) {
+    const workspace = workspaceSchema.parse(parts[0]);
+    const slug = slugSchema.parse(parts[1]);
+    if (workspaceOpt !== void 0 && workspaceOpt !== workspace) {
+      log.err(
+        `workspace mismatch: ref uses "${workspace}" but --workspace is "${workspaceOpt}"`
+      );
+      process.exit(EXIT.config);
+    }
+    return { workspace, slug };
+  }
+  return {
+    ...workspaceOpt !== void 0 ? { workspace: workspaceOpt } : {},
+    slug: slugSchema.parse(ref)
+  };
+}
+async function buildWritePlans(input2) {
+  const paths = [
+    {
+      target: "cache",
+      path: skillFile(input2.workspaceSlug, input2.slug),
+      status: "installed"
+    }
+  ];
+  if (input2.target === "all" || input2.target === "claude") {
+    paths.push({
+      target: "claude",
+      path: join5(homedir5(), ".claude", "skills", input2.slug, "SKILL.md"),
+      status: "installed"
+    });
+  }
+  if (input2.target === "all" || input2.target === "codex") {
+    paths.push({
+      target: "codex",
+      path: join5(
+        process.env.CODEX_HOME ?? join5(homedir5(), ".codex"),
+        "skills",
+        input2.slug,
+        "SKILL.md"
+      ),
+      status: "installed"
+    });
+  }
+  const conflicts = [];
+  for (const item of paths) {
+    const existing = await readExisting(item.path);
+    if (existing === void 0) continue;
+    if (existing === input2.body) {
+      item.status = "already-installed";
+      continue;
+    }
+    if (item.target === "cache" || input2.force) {
+      item.status = "overwritten";
+      continue;
+    }
+    conflicts.push(`${item.target}: ${item.path}`);
+  }
+  if (conflicts.length > 0) {
+    log.err(
+      `local skill already exists with different content. Re-run with --force to overwrite:
+${conflicts.map((p) => `  ${p}`).join("\n")}`
+    );
+    process.exit(EXIT.err);
+    return void 0;
+  }
+  return paths;
+}
+async function readExisting(path) {
+  try {
+    return await readFile3(path, "utf8");
+  } catch {
+    return void 0;
+  }
+}
+async function fetchMetadata(input2) {
+  const params = new URLSearchParams();
+  if (input2.semver !== void 0) params.set("semver", input2.semver);
+  const query = params.size > 0 ? `?${params.toString()}` : "";
+  const url = `${input2.apiBase}/api/v1/workspaces/${input2.workspaceSlug}/operons/${input2.slug}${query}`;
+  let res;
+  try {
+    const headers = { "x-operon-source": "cli" };
+    if (input2.token !== void 0 && input2.token.length > 0) {
+      headers.authorization = `Bearer ${input2.token}`;
+    }
+    res = await fetch(url, { headers });
+  } catch (e) {
+    log.err(`network error: ${e.message}`);
+    process.exit(EXIT.network);
+    return void 0;
+  }
+  if (!res.ok) {
+    const body = await res.text().catch(() => "<unreadable>");
+    log.err(`server returned ${res.status}: ${body.slice(0, 400)}`);
+    process.exit(res.status === 401 ? EXIT.auth : EXIT.err);
+    return void 0;
+  }
+  try {
+    return installResponseSchema.parse(await res.json());
+  } catch (e) {
+    log.err(`invalid server response: ${e.message}`);
+    process.exit(EXIT.err);
+    return void 0;
+  }
+}
+async function fetchSkill(skillUrl) {
+  let res;
+  try {
+    res = await fetch(skillUrl);
+  } catch (e) {
+    log.err(`skill download failed: ${e.message}`);
+    process.exit(EXIT.network);
+    return void 0;
+  }
+  if (!res.ok) {
+    log.err(`skill download returned ${res.status}`);
+    process.exit(EXIT.err);
+    return void 0;
+  }
+  return res.text();
+}
+function sha256Hex(value) {
+  return createHash("sha256").update(value).digest("hex");
+}
+
+// src/commands/list.ts
+import { Command as Command4, Option } from "commander";
+import { z as z5 } from "zod";
+
+// src/render/candidate-table.ts
+import chalk3 from "chalk";
+function renderCandidateTable(candidates) {
+  if (candidates.length === 0) return "(no candidates)";
+  const colored = !getGlobals().noColor;
+  const tint = (s, fn) => colored ? fn(s) : s;
+  const rows = [];
+  rows.push(["#", "slug", "uses", "days", "score", "tools"]);
+  for (const [i, c] of candidates.entries()) {
+    rows.push([
+      String(i + 1),
+      c.slug,
+      String(c.uses),
+      String(c.spanDays),
+      c.score.toFixed(3),
+      c.suggestedTools.slice(0, 3).join(",") || "(none)"
+    ]);
+  }
+  const widths = rows[0].map(
+    (_, col) => rows.reduce((max, r) => Math.max(max, r[col].length), 0)
+  );
+  const lines = [];
+  for (const [i, r] of rows.entries()) {
+    const cells = r.map((cell, col) => cell.padEnd(widths[col]));
+    const joined = cells.join("  ");
+    lines.push(i === 0 ? tint(joined, chalk3.bold) : joined);
+  }
+  return lines.join("\n");
+}
+
+// src/store/candidates.ts
+import { readFile as readFile4, readdir as readdir4, rename, writeFile as writeFile3, rm } from "fs/promises";
+import { join as join6 } from "path";
+async function writeCandidate(candidate, exemplars) {
+  const dir = candidateDir(candidate.slug);
+  await ensureDir(dir);
+  await ensureDir(join6(dir, "exemplars"));
+  await writeFile3(
+    join6(dir, "candidate.json"),
+    `${JSON.stringify(candidate, null, 2)}
+`,
+    "utf8"
+  );
+  await writeFile3(join6(dir, "prompt.draft.md"), candidate.draftPrompt, "utf8");
+  await writeFile3(
+    join6(dir, "tools.suggested.json"),
+    `${JSON.stringify(candidate.suggestedTools, null, 2)}
+`,
+    "utf8"
+  );
+  await writeFile3(
+    join6(dir, "eval.draft.json"),
+    `${JSON.stringify(candidate.draftEval, null, 2)}
+`,
+    "utf8"
+  );
+  for (const session of exemplars) {
+    await writeFile3(
+      join6(dir, "exemplars", `${sanitize(session.id)}.summary.md`),
+      renderExemplarSummary(session),
+      "utf8"
+    );
+  }
+}
+async function readCandidate(slug) {
+  const dir = candidateDir(slug);
+  try {
+    const raw = await readFile4(join6(dir, "candidate.json"), "utf8");
+    return JSON.parse(raw);
+  } catch {
+    return void 0;
+  }
+}
+async function listCandidates() {
+  let entries;
+  try {
+    entries = await readdir4(CANDIDATES_DIR);
+  } catch {
+    return [];
+  }
+  const out = [];
+  for (const slug of entries) {
+    const candidate = await readCandidate(slug);
+    if (candidate !== void 0) out.push(candidate);
+  }
+  return out;
+}
+async function trashCandidate(slug) {
+  const undoId = `${Date.now().toString(36)}-cand-${slug}`;
+  const target = trashDir(undoId);
+  await ensureDir(target);
+  try {
+    await rename(candidateDir(slug), join6(target, slug));
+  } catch (e) {
+    throw new Error(
+      `cannot trash candidate "${slug}": ${e.message}`
+    );
+  }
+  return undoId;
+}
+var SNIPPET_LEN = 200;
+function renderExemplarSummary(session) {
+  const userMsg = session.messages.find((m) => m.role === "user");
+  const snippet = userMsg !== void 0 ? userMsg.content.slice(0, SNIPPET_LEN).replace(/\s+/g, " ") : "(no user message)";
+  const tools = session.toolCalls.map((t) => t.name).join(", ") || "(none)";
+  const exts = session.fileTouches.map((f) => `${f.extension}:${f.count}`).join(", ") || "(none)";
+  return `# ${session.id}
+
+source: ${session.source}
+started: ${session.startedAt.toISOString()}
+duration: ${session.durationSec}s
+cwd: ${session.cwd ?? "(unknown)"}
+
+## first user prompt (200c snippet)
+
+${snippet}
+
+## tools used
+
+${tools}
+
+## file extensions touched
+
+${exts}
+`;
+}
+function sanitize(id) {
+  return id.replace(/[^a-zA-Z0-9._-]/g, "_");
+}
+
+// src/store/operons.ts
+import { readFile as readFile5, readdir as readdir5, rename as rename2, writeFile as writeFile4, rm as rm2 } from "fs/promises";
+import { join as join7 } from "path";
+async function readOperon(slug) {
+  try {
+    const raw = await readFile5(join7(operonDir(slug), "manifest.json"), "utf8");
+    return JSON.parse(raw);
+  } catch {
+    return void 0;
+  }
+}
+async function listOperons() {
+  let entries;
+  try {
+    entries = await readdir5(OPERONS_DIR);
+  } catch {
+    return [];
+  }
+  const out = [];
+  for (const slug of entries) {
+    const m = await readOperon(slug);
+    if (m !== void 0) out.push(m);
+  }
+  return out;
+}
+async function trashOperon(slug) {
+  const undoId = `${Date.now().toString(36)}-${slug}`;
+  const target = trashDir(undoId);
+  await ensureDir(target);
+  try {
+    await rename2(operonDir(slug), join7(target, slug));
+  } catch (e) {
+    throw new Error(`cannot trash operon "${slug}": ${e.message}`);
+  }
+  return undoId;
+}
+
+// src/commands/list.ts
+var SORTS = ["score", "recent", "name"];
+var optsSchema3 = z5.object({
+  candidates: z5.boolean().default(false),
+  operons: z5.boolean().default(false),
+  sort: z5.enum(SORTS).default("score")
+});
+function listCommand() {
+  return new Command4("list").alias("ls").description("List candidates and operons.").option("--candidates", "Show only candidates", false).option("--operons", "Show only operons", false).addOption(new Option("--sort <key>", "Sort key").choices([...SORTS])).action(async (rawOpts) => {
+    const opts = optsSchema3.parse(rawOpts);
+    const showBoth = !opts.candidates && !opts.operons;
+    const candidates = showBoth || opts.candidates ? await listCandidates() : [];
+    const operons = showBoth || opts.operons ? await listOperons() : [];
+    sortCandidates(candidates, opts.sort);
+    if (getGlobals().json) {
+      log.json({ candidates, operons });
+      process.exit(EXIT.ok);
+    }
+    if (showBoth || opts.candidates) {
+      log.info("Candidates:");
+      log.info(renderCandidateTable(candidates));
+      log.info("");
+    }
+    if (showBoth || opts.operons) {
+      log.info("Operons:");
+      if (operons.length === 0) {
+        log.info("  (none)");
+      } else {
+        for (const o of operons) {
+          log.info(`  ${o.slug}  v${o.semver}  promoted ${o.promotedAt}`);
+        }
+      }
+    }
+    const total = candidates.length + operons.length;
+    process.exit(total > 0 ? EXIT.ok : EXIT.noWork);
+  });
+}
+function sortCandidates(candidates, key) {
+  switch (key) {
+    case "score":
+      candidates.sort((a, b) => b.score - a.score);
+      return;
+    case "recent":
+      candidates.sort((a, b) => b.spanDays - a.spanDays);
+      return;
+    case "name":
+      candidates.sort((a, b) => a.slug.localeCompare(b.slug));
+      return;
+  }
+}
+
+// src/commands/login.ts
+import { createInterface as createInterface2 } from "readline/promises";
+import { Command as Command5 } from "commander";
+import { z as z6 } from "zod";
+var optsSchema4 = z6.object({
+  apiBase: z6.string().url().optional(),
+  workspace: z6.string().min(1).max(64).optional(),
+  token: z6.string().optional()
+});
+function loginCommand() {
+  return new Command5("login").description("Sign in to the Operon platform (paste-token flow for v0).").option(
+    "--api-base <url>",
+    "Override platform base URL (default https://app.withoperon.com)"
+  ).option("--workspace <slug>", "Set default workspace slug for publish").option(
+    "--token <token>",
+    "Skip the prompt and pass a Supabase access token or op_pat_* PAT"
+  ).action(async (rawOpts) => {
+    const opts = optsSchema4.parse(rawOpts);
+    const config = await readConfig();
+    const apiBase = opts.apiBase ?? config.platform.apiBase ?? "https://app.withoperon.com";
+    let accessToken = opts.token;
+    if (accessToken === void 0) {
+      log.step(`Open this URL in your browser to sign in:`);
+      log.info("");
+      log.info(`  ${apiBase}/login?from=cli`);
+      log.info("");
+      log.info(
+        "After signing in, copy the access token shown on the device page,"
+      );
+      log.info("then paste it here. You can also paste an op_pat_* token.");
+      log.info("");
+      const rl = createInterface2({
+        input: process.stdin,
+        output: process.stdout
+      });
+      accessToken = (await rl.question("token> ")).trim();
+      rl.close();
+    }
+    if (accessToken === void 0 || accessToken.length === 0) {
+      log.err("no token provided");
+      process.exit(EXIT.config);
+      return;
+    }
+    let email;
+    try {
+      const res = await fetch(`${apiBase}/api/v1/whoami`, {
+        headers: { authorization: `Bearer ${accessToken}` }
+      });
+      if (!res.ok) {
+        const body = await res.text().catch(() => "");
+        log.err(
+          `Token rejected by ${apiBase} (${res.status}): ${body.slice(0, 200)}`
+        );
+        process.exit(EXIT.auth);
+        return;
+      }
+      const json = await res.json();
+      email = json.email;
+    } catch (e) {
+      log.err(`Could not reach ${apiBase}: ${e.message}`);
+      process.exit(EXIT.network);
+      return;
+    }
+    const next = {
+      ...config,
+      platform: {
+        ...config.platform,
+        apiBase,
+        accessToken,
+        userEmail: email,
+        ...opts.workspace !== void 0 ? { workspaceSlug: opts.workspace } : {}
+      }
+    };
+    await writeConfig(next);
+    log.step(
+      `signed in as ${email ?? "(unknown)"} \u2192 ${apiBase}` + (opts.workspace !== void 0 ? `   default workspace: ${opts.workspace}` : "")
+    );
+    log.info("Next: operon publish <slug>");
+    process.exit(EXIT.ok);
+  });
+}
+
+// src/commands/mine.ts
+import { createInterface as createInterface3 } from "readline/promises";
+import { stdin as input, stdout as output } from "process";
+import { Command as Command6, Option as Option2 } from "commander";
+
+// ../../packages/mining/src/prompts.ts
+var NON_ACTIONABLE_PREFIXES = [
+  "<environment_context>",
+  "<local-command-caveat>",
+  "<user_info>"
+];
+var NON_ACTIONABLE_PATTERNS = [
+  /^# AGENTS\.md instructions[^\n]*(?:\n|$)/i,
+  /<INSTRUCTIONS>[\s\S]*?<\/INSTRUCTIONS>/i,
+  /<environment_context>[\s\S]*?<\/environment_context>/i,
+  /<local-command-caveat>[\s\S]*?<\/local-command-caveat>/i,
+  /<user_info>[\s\S]*?<\/user_info>/i
+];
+function firstActionableUserPrompt(session) {
+  for (const message of session.messages) {
+    if (message.role !== "user") continue;
+    const content = actionablePromptContent(message.content);
+    if (content === void 0) continue;
+    return content;
+  }
+  return void 0;
+}
+function actionablePromptContent(content) {
+  const trimmed = content.trim();
+  if (trimmed.length === 0) return void 0;
+  if (NON_ACTIONABLE_PREFIXES.some((prefix) => trimmed.startsWith(prefix))) {
+    return void 0;
+  }
+  let stripped = trimmed;
+  for (const pattern of NON_ACTIONABLE_PATTERNS) {
+    stripped = stripped.replace(pattern, " ").trim();
+  }
+  return stripped.length === 0 ? void 0 : stripped;
+}
+
+// ../../packages/mining/src/filter.ts
+var DEFAULTS = {
+  minDurationSec: 60,
+  minMessages: 3,
+  minWork: 1
+};
+function filterSessions(sessions, opts = {}) {
+  const cfg = { ...DEFAULTS, ...opts };
+  const kept = [];
+  const dropped = [];
+  for (const s of sessions) {
+    if (s.durationSec < cfg.minDurationSec) {
+      dropped.push({ id: s.id, reason: "too-short" });
+      continue;
+    }
+    if (s.messages.length < cfg.minMessages) {
+      dropped.push({ id: s.id, reason: "too-few-messages" });
+      continue;
+    }
+    if (firstActionableUserPrompt(s) === void 0) {
+      dropped.push({ id: s.id, reason: "no-actionable-prompt" });
+      continue;
+    }
+    const fileTouchTotal = s.fileTouches.reduce((a, t) => a + t.count, 0);
+    const toolCallTotal = s.toolCalls.reduce((a, t) => a + (t.count ?? 1), 0);
+    const work = fileTouchTotal + Math.floor(toolCallTotal / 2);
+    if (work < cfg.minWork) {
+      dropped.push({ id: s.id, reason: "no-work" });
+      continue;
+    }
+    kept.push(s);
+  }
+  return { kept, dropped };
+}
+
+// ../../packages/mining/src/hashes.ts
+import { createHash as createHash2 } from "crypto";
+function sha256(input2) {
+  return createHash2("sha256").update(input2).digest("hex");
+}
+function normalizePromptText(s) {
+  let out = s.toLowerCase();
+  out = out.replace(/```[\s\S]*?```/g, " ");
+  out = out.replace(/`[^`]*`/g, " ");
+  out = out.replace(/https?:\/\/\S+/g, "<url>");
+  out = out.replace(/\/[^\s'"`)]+/g, "<id>");
+  out = out.replace(/\d+/g, "#");
+  out = out.replace(/[^\p{L}\s<>#]+/gu, " ");
+  out = out.replace(/\s+/g, " ").trim();
+  return out;
+}
+function promptShapeHash(initialPrompt) {
+  return sha256(normalizePromptText(initialPrompt));
+}
+function pathFingerprintHash(extensions) {
+  const sorted = [...extensions].sort();
+  return sha256(sorted.join("|"));
+}
+function toolFingerprintHash(toolNames) {
+  const sorted = [...toolNames].sort();
+  return sha256(sorted.join("|"));
+}
+
+// ../../packages/mining/src/featurize.ts
+var BASH_TOOLS = /* @__PURE__ */ new Set(["Bash", "exec_command", "shell"]);
+var EDIT_TOOLS = /* @__PURE__ */ new Set([
+  "Edit",
+  "Write",
+  "MultiEdit",
+  "NotebookEdit",
+  "apply_patch"
+]);
+var SEARCH_TOOLS = /* @__PURE__ */ new Set(["Grep", "Glob", "Read", "WebSearch", "WebFetch"]);
+var SLASH_CMD_TAG_RE = /<command-name>\s*\/?([a-z][\w-]{0,63})\s*<\/command-name>/i;
+var SLASH_CMD_RAW_RE = /^\s*\/([a-z][\w-]{0,63})(?:\s|$)/i;
+var VERB_OBJECT_RE = /\b(?:please\s+|can\s+you\s+|let'?s\s+|i\s+want\s+(?:you\s+)?to\s+)?(\w{3,})\s+(?:the\s+|a\s+|this\s+|my\s+|our\s+)?(\w{3,})/i;
+var STOP_VERBS = /* @__PURE__ */ new Set([
+  "the",
+  "be",
+  "is",
+  "was",
+  "are",
+  "were",
+  "have",
+  "has",
+  "had",
+  "do",
+  "does",
+  "did",
+  "and",
+  "but",
+  "or",
+  "so",
+  "for",
+  "from",
+  "with",
+  "your",
+  "this",
+  "that",
+  "these",
+  "those"
+]);
+function featurize(session) {
+  const initialPrompt = firstActionableUserPrompt(session) ?? "";
+  const promptShape = promptShapeHash(initialPrompt);
+  const commandHint = extractCommand(initialPrompt);
+  const verbObject = commandHint === void 0 ? extractVerbObject(initialPrompt) : void 0;
+  const toolHistogram = {};
+  let toolCallCount = 0;
+  for (const t of session.toolCalls) {
+    const count = t.count ?? 1;
+    toolHistogram[t.name] = (toolHistogram[t.name] ?? 0) + count;
+    toolCallCount += count;
+  }
+  const primaryTool = pickPrimaryTool(toolHistogram);
+  const bashInvocationCount = sumByName(toolHistogram, BASH_TOOLS);
+  const editCount = sumByName(toolHistogram, EDIT_TOOLS);
+  const searchCount = sumByName(toolHistogram, SEARCH_TOOLS);
+  const fileExtensions = [
+    ...session.fileTouches.map((f) => f.extension)
+  ].sort();
+  const pathFingerprint = pathFingerprintHash(fileExtensions);
+  const cwdLeaf = session.cwd === void 0 ? void 0 : leafOfCwd(session.cwd);
+  const actionSignature = buildActionSignature(
+    primaryTool,
+    toolHistogram,
+    fileExtensions,
+    cwdLeaf
+  );
+  const features = {
+    primaryTool,
+    fileExtensions,
+    modelFamily: detectModelFamily(session.modelHints),
+    messageCount: session.messages.length,
+    toolCallCount,
+    bashInvocationCount,
+    editCount,
+    searchCount,
+    promptShape,
+    toolHistogram,
+    pathFingerprint,
+    commandHint,
+    verbObject,
+    actionSignature,
+    cwdLeaf,
+    durationBucket: bucketDuration(session.durationSec),
+    outcome: session.outcome,
+    sessionId: session.id,
+    startedAt: session.startedAt
+  };
+  return features;
+}
+function featurizeMany(sessions) {
+  return sessions.map(featurize);
+}
+function buildActionSignature(primaryTool, histogram, extensions, cwdLeaf) {
+  const top3 = [...Object.entries(histogram)].sort((a, b) => b[1] - a[1] || a[0].localeCompare(b[0])).slice(0, 3).map(([name]) => name).sort().join(",");
+  const primaryExt = extensions[0] ?? "<none>";
+  const leaf = cwdLeaf ?? "<no-cwd>";
+  return sha256(`${primaryTool}|${top3}|${primaryExt}|${leaf}`);
+}
+function extractCommand(prompt) {
+  const tagged = SLASH_CMD_TAG_RE.exec(prompt);
+  if (tagged?.[1] !== void 0) {
+    return tagged[1].toLowerCase();
+  }
+  const raw = SLASH_CMD_RAW_RE.exec(prompt);
+  if (raw?.[1] !== void 0) {
+    return raw[1].toLowerCase();
+  }
+  return void 0;
+}
+function extractVerbObject(prompt) {
+  const stripped = prompt.replace(/<command-message>[\s\S]*?<\/command-message>/gi, " ").replace(/<command-name>[\s\S]*?<\/command-name>/gi, " ").replace(/<command-args>[\s\S]*?<\/command-args>/gi, " ").replace(/<local-command-caveat>[\s\S]*?<\/local-command-caveat>/gi, " ").replace(/<system-reminder>[\s\S]*?<\/system-reminder>/gi, " ").trim();
+  const m = VERB_OBJECT_RE.exec(stripped);
+  if (m === null) return void 0;
+  const verb = m[1].toLowerCase();
+  const object = m[2].toLowerCase();
+  if (STOP_VERBS.has(verb) || STOP_VERBS.has(object)) return void 0;
+  if (verb === object) return void 0;
+  const slug = `${verb}-${object}`.replace(/[^a-z0-9-]/g, "");
+  if (slug.length < 6) return void 0;
+  return slug;
+}
+function leafOfCwd(cwd) {
+  const parts = cwd.split("/").filter(Boolean);
+  return parts[parts.length - 1] ?? cwd;
+}
+function pickPrimaryTool(histogram) {
+  const entries = Object.entries(histogram);
+  if (entries.length === 0) return "<none>";
+  entries.sort((a, b) => b[1] - a[1] || a[0].localeCompare(b[0]));
+  return entries[0][0];
+}
+function sumByName(histogram, names) {
+  let n = 0;
+  for (const [k, v] of Object.entries(histogram)) {
+    if (names.has(k)) n += v;
+  }
+  return n;
+}
+function detectModelFamily(hints) {
+  if (hints.length === 0) return "unknown";
+  const lower = hints.map((h) => h.toLowerCase());
+  const claude = lower.some((h) => h.includes("claude"));
+  const gpt = lower.some(
+    (h) => h.includes("gpt") || h.includes("o1") || h.includes("o3")
+  );
+  if (claude && gpt) return "mixed";
+  if (claude) return "claude";
+  if (gpt) return "gpt";
+  return "unknown";
+}
+function bucketDuration(sec) {
+  if (sec < 5 * 60) return "short";
+  if (sec < 30 * 60) return "medium";
+  if (sec < 2 * 60 * 60) return "long";
+  return "very-long";
+}
+
+// ../../packages/mining/src/cluster.ts
+var DEFAULT_WEIGHTS = {
+  actionSignature: 0.4,
+  toolJaccard: 0.3,
+  extJaccard: 0.1,
+  pathFingerprint: 0.1,
+  promptShape: 0.05,
+  outcome: 0.05
+};
+var DEFAULTS2 = {
+  // Two-session pairs were too noisy in 90-day dogfood runs: they
+  // often captured one-off debugging, setup, or conversational
+  // follow-up. Require at least three repeats before surfacing a
+  // reusable pattern.
+  minClusterSize: 3,
+  maxDistance: 0.55
+};
+function clusterSessions(features, opts = {}) {
+  const cfg = {
+    minClusterSize: opts.minClusterSize ?? DEFAULTS2.minClusterSize,
+    maxDistance: opts.maxDistance ?? DEFAULTS2.maxDistance,
+    weights: opts.weights ?? DEFAULT_WEIGHTS
+  };
+  const consumed = /* @__PURE__ */ new Set();
+  const clusters = [];
+  bucketByKey(
+    features,
+    consumed,
+    cfg.minClusterSize,
+    "cmd",
+    clusters,
+    (f) => f.commandHint === void 0 ? void 0 : `cmd:${f.commandHint}`
+  );
+  bucketByKey(
+    features,
+    consumed,
+    cfg.minClusterSize,
+    "verb",
+    clusters,
+    (f) => f.verbObject === void 0 ? void 0 : `verb:${f.verbObject}`
+  );
+  bucketByKey(
+    features,
+    consumed,
+    cfg.minClusterSize,
+    "action",
+    clusters,
+    (f) => `action:${f.actionSignature}`
+  );
+  bucketByKey(
+    features,
+    consumed,
+    cfg.minClusterSize,
+    "shape",
+    clusters,
+    (f) => `shape:${f.promptShape}`
+  );
+  const remainder = features.filter((f) => !consumed.has(f.sessionId));
+  clusters.push(...densityCluster(remainder, cfg));
+  return clusters;
+}
+function bucketByKey(features, consumed, minClusterSize, pass, clusters, keyFn) {
+  const buckets = /* @__PURE__ */ new Map();
+  for (const f of features) {
+    if (consumed.has(f.sessionId)) continue;
+    const key = keyFn(f);
+    if (key === void 0) continue;
+    const arr = buckets.get(key) ?? [];
+    arr.push(f);
+    buckets.set(key, arr);
+  }
+  for (const arr of buckets.values()) {
+    if (arr.length < minClusterSize) continue;
+    clusters.push(buildCluster(arr, pass));
+    for (const f of arr) consumed.add(f.sessionId);
+  }
+}
+function densityCluster(features, cfg) {
+  if (features.length === 0) return [];
+  const assigned = /* @__PURE__ */ new Set();
+  const clusters = [];
+  for (const seed of features) {
+    if (assigned.has(seed.sessionId)) continue;
+    const members = [seed];
+    for (const candidate of features) {
+      if (candidate.sessionId === seed.sessionId || assigned.has(candidate.sessionId)) {
+        continue;
+      }
+      if (distance(seed, candidate, cfg.weights) <= cfg.maxDistance) {
+        members.push(candidate);
+      }
+    }
+    if (members.length >= cfg.minClusterSize) {
+      clusters.push(buildCluster(members, "B"));
+      for (const member of members) assigned.add(member.sessionId);
+    }
+  }
+  return clusters;
+}
+function distance(a, b, w = DEFAULT_WEIGHTS) {
+  const actionD = a.actionSignature === b.actionSignature ? 0 : 1;
+  const toolD = jaccardDistance(
+    Object.keys(a.toolHistogram),
+    Object.keys(b.toolHistogram)
+  );
+  const extD = jaccardDistance(a.fileExtensions, b.fileExtensions);
+  const pathD = a.pathFingerprint === b.pathFingerprint ? 0 : 1;
+  const promptD = a.promptShape === b.promptShape ? 0 : 1;
+  const outcomeD = a.outcome === b.outcome ? 0 : 1;
+  return w.actionSignature * actionD + w.toolJaccard * toolD + w.extJaccard * extD + w.pathFingerprint * pathD + w.promptShape * promptD + w.outcome * outcomeD;
+}
+function jaccardDistance(a, b) {
+  if (a.length === 0 && b.length === 0) return 0;
+  const A = new Set(a);
+  const B = new Set(b);
+  let intersection = 0;
+  for (const x of A) if (B.has(x)) intersection += 1;
+  const union = A.size + B.size - intersection;
+  if (union === 0) return 0;
+  return 1 - intersection / union;
+}
+function buildCluster(members, pass) {
+  const sorted = [...members].sort(
+    (a, b) => a.startedAt.getTime() - b.startedAt.getTime()
+  );
+  const centroid = sorted[Math.floor(sorted.length / 2)];
+  const id = sha256(sorted.map((m) => m.sessionId).join("|"));
+  const days = /* @__PURE__ */ new Set();
+  for (const m of sorted) {
+    days.add(m.startedAt.toISOString().slice(0, 10));
+  }
+  return {
+    id,
+    members: sorted.map((m) => m.sessionId),
+    centroidPromptShape: centroid.promptShape,
+    centroidFeatures: centroid,
+    daysSpanned: days.size,
+    pass: passShortLabel(pass)
+  };
+}
+function passShortLabel(pass) {
+  return pass === "B" ? "B" : "A";
+}
+
+// ../../packages/mining/src/score.ts
+var DEFAULT_SCORE_WEIGHTS = {
+  uses: 0.4,
+  recurrence: 0.4,
+  toolRichness: 0.2,
+  recentlySeenPenalty: 0.1
+};
+function scoreClusters(clusters, opts = {}) {
+  const w = opts.weights ?? DEFAULT_SCORE_WEIGHTS;
+  const usesCeiling = opts.usesCeiling ?? 5;
+  const promoted = opts.alreadyPromotedShapes ?? /* @__PURE__ */ new Set();
+  return clusters.map((c) => {
+    const breakdown = scoreOne(c, w, usesCeiling, promoted);
+    const score = sum(breakdown);
+    return { cluster: c, score, breakdown };
+  }).sort((a, b) => b.score - a.score);
+}
+function scoreOne(cluster, w, usesCeiling, promoted) {
+  const uses = cluster.members.length;
+  const days = Math.max(1, cluster.daysSpanned);
+  const usesPerDay = uses / days;
+  const usesScore = w.uses * Math.min(1, usesPerDay / usesCeiling);
+  const recurrenceScore = w.recurrence * Math.min(1, Math.log2(days + 1) / Math.log2(31));
+  const toolRichnessScore = w.toolRichness * toolRichness(cluster.centroidFeatures);
+  const penalty = promoted.has(cluster.centroidPromptShape) ? w.recentlySeenPenalty : 0;
+  return {
+    uses: usesScore,
+    recurrence: recurrenceScore,
+    toolRichness: toolRichnessScore,
+    recentlySeenPenalty: -penalty
+  };
+}
+function toolRichness(f) {
+  const distinct = Object.keys(f.toolHistogram).length;
+  if (distinct <= 1) return 0;
+  if (distinct === 2) return 0.4;
+  if (distinct === 3) return 0.7;
+  return 1;
+}
+function sum(record) {
+  let total = 0;
+  for (const v of Object.values(record)) total += v;
+  return total;
+}
+
+// ../../packages/mining/src/render.ts
+var DEFAULTS3 = {
+  top: 10,
+  exemplarsPerCandidate: 3
+};
+function renderCandidates(scored, sessionsById, opts = {}) {
+  const limit = opts.top ?? DEFAULTS3.top;
+  const k = opts.exemplarsPerCandidate ?? DEFAULTS3.exemplarsPerCandidate;
+  const used = /* @__PURE__ */ new Set();
+  const out = [];
+  for (const sc of scored) {
+    if (out.length >= limit) break;
+    const candidate = renderOne(sc, sessionsById, k, used);
+    if (candidate === void 0) continue;
+    out.push(candidate);
+  }
+  return out;
+}
+function renderOne(sc, sessionsById, k, usedSlugs) {
+  const cf = sc.cluster.centroidFeatures;
+  const exemplarIds = sc.cluster.members.slice(0, k);
+  const exemplars = exemplarIds.map((id) => sessionsById.get(id)).filter((s) => s !== void 0);
+  if (exemplars.length === 0) return void 0;
+  const draftPrompt = buildDraftPrompt(exemplars[0]);
+  const suggestedTools = pickSuggestedTools(exemplars);
+  const memberSessions = sc.cluster.members.map((id) => sessionsById.get(id)).filter((s) => s !== void 0);
+  const memberStarts = memberSessions.map((s) => s.startedAt.getTime());
+  const firstSeenAt = new Date(Math.min(...memberStarts)).toISOString();
+  const lastSeenAt = new Date(Math.max(...memberStarts)).toISOString();
+  const slug = mintSlug(
+    cf.commandHint,
+    cf.verbObject,
+    draftPrompt,
+    sc.cluster.id,
+    usedSlugs
+  );
+  usedSlugs.add(slug);
+  return {
+    slug,
+    uses: sc.cluster.members.length,
+    spanDays: sc.cluster.daysSpanned,
+    toolFingerprint: toolFingerprintHash(suggestedTools),
+    pathFingerprint: pathFingerprintHash(cf.fileExtensions),
+    promptShape: cf.promptShape,
+    score: round(sc.score, 4),
+    scoreBreakdown: roundAll(sc.breakdown, 4),
+    exemplarSessionIds: exemplarIds,
+    firstSeenAt,
+    lastSeenAt,
+    draftPrompt,
+    suggestedTools,
+    draftEval: {
+      type: "session-replay",
+      fixtures: exemplarIds,
+      asserts: [{ kind: "tools-used", subset: suggestedTools.slice(0, 3) }]
+    },
+    summary: buildSummary(sc, suggestedTools, exemplars)
+  };
+}
+function buildDraftPrompt(centroidSession) {
+  let body = firstActionableUserPrompt(centroidSession);
+  if (body === void 0) return "Pattern: see exemplar sessions for shape.";
+  body = body.trim();
+  if (body.length > 1500) body = `${body.slice(0, 1497)}\u2026`;
+  return body;
+}
+function pickSuggestedTools(exemplars) {
+  const sets = exemplars.map((s) => new Set(s.toolCalls.map((t) => t.name)));
+  if (sets.length === 0) return [];
+  const intersection = new Set(sets[0]);
+  for (const s of sets.slice(1)) {
+    for (const t of intersection) if (!s.has(t)) intersection.delete(t);
+  }
+  const union = /* @__PURE__ */ new Set();
+  for (const s of sets) for (const t of s) union.add(t);
+  const inter = [...intersection];
+  const rest = [...union].filter((t) => !intersection.has(t));
+  const all = [...inter, ...rest];
+  return all.slice(0, 8);
+}
+function mintSlug(commandHint, verbObject, draftPrompt, clusterId, used) {
+  const candidate = commandHint ?? verbObject ?? extractVerbObject2(draftPrompt) ?? `pattern-${clusterId.slice(0, 8)}`;
+  if (!used.has(candidate)) return candidate;
+  return `${candidate}-${clusterId.slice(0, 4)}`;
+}
+var VERB_OBJECT_REGEX = /^(?:please\s+)?(?:can\s+you\s+)?(\w+)\s+(?:the\s+|a\s+|this\s+|my\s+)?(\w+(?:\s+\w+)?)/i;
+function extractVerbObject2(prompt) {
+  const m = VERB_OBJECT_REGEX.exec(prompt.trim());
+  if (m === null) return void 0;
+  const verb = m[1].toLowerCase();
+  const object = m[2].toLowerCase().replace(/\s+/g, "-");
+  if (verb === object) return void 0;
+  if (verb.length < 3 || object.length < 3) return void 0;
+  return `${verb}-${object}`.replace(/[^a-z0-9-]/g, "");
+}
+function buildSummary(sc, tools, exemplars) {
+  const f = sc.cluster.centroidFeatures;
+  const exts = f.fileExtensions.length > 0 ? f.fileExtensions.slice(0, 5).join(", ") : "no-file-touches";
+  const exemplarLine = exemplars.map((e) => e.id).slice(0, 3).join(", ");
+  return `This pattern appears in ${sc.cluster.members.length} sessions across ${sc.cluster.daysSpanned} days. Each session uses ${tools.slice(0, 3).join(", ") || "no tools"}, touches files matching ${exts}. Examples: ${exemplarLine}.`;
+}
+function round(n, d) {
+  const f = 10 ** d;
+  return Math.round(n * f) / f;
+}
+function roundAll(rec, d) {
+  const out = {};
+  for (const [k, v] of Object.entries(rec)) out[k] = round(v, d);
+  return out;
+}
+
+// ../../packages/mining/src/pipeline.ts
+function mineSessions(sessions, opts = {}) {
+  const filtered = filterSessions(sessions, opts.filter);
+  const features = featurizeMany(filtered.kept);
+  const clusters = clusterSessions(features, opts.cluster);
+  const scored = scoreClusters(clusters, opts.score);
+  const sessionsById = new Map(filtered.kept.map((s) => [s.id, s]));
+  const candidates = renderCandidates(scored, sessionsById, opts.render);
+  return {
+    candidates,
+    filtered,
+    clusterCount: clusters.length,
+    sessionCountInput: sessions.length,
+    sessionCountKept: filtered.kept.length
+  };
+}
+
+// src/commands/mine.ts
+import { z as z8 } from "zod";
+
+// src/lib/duration.ts
+var UNITS = {
+  s: 1e3,
+  m: 60 * 1e3,
+  h: 60 * 60 * 1e3,
+  d: 24 * 60 * 60 * 1e3
+};
+function parseDuration(input2) {
+  const m = /^(\d+)([smhd])$/.exec(input2.trim());
+  if (!m) {
+    throw new Error(
+      `Invalid duration "${input2}". Use forms like 30d, 24h, 30m, 45s.`
+    );
+  }
+  const n = Number(m[1]);
+  const unit = m[2];
+  return n * UNITS[unit];
+}
+
+// src/lib/events.ts
+import { z as z7 } from "zod";
+var eventNameSchema = z7.enum([
+  "mining_scan_started",
+  "mining_scan_completed",
+  "pattern_detected",
+  "suggestion_submitted",
+  "suggestion_viewed",
+  "suggestion_voted",
+  "suggestion_accepted",
+  "suggestion_dismissed",
+  "mining_session_completed"
+]);
+var eventValueSchema = z7.union([
+  z7.string(),
+  z7.number(),
+  z7.boolean(),
+  z7.null(),
+  z7.array(z7.union([z7.string(), z7.number(), z7.boolean()]))
+]);
+var eventPropertiesSchema = z7.record(eventValueSchema.optional());
+var PlatformEventError = class extends Error {
+  exitCode;
+  status;
+  body;
+  constructor(message, exitCode, status, body) {
+    super(message);
+    this.name = "PlatformEventError";
+    this.exitCode = exitCode;
+    this.status = status;
+    this.body = body;
+  }
+};
+async function createPlatformEventClient(options = {}) {
+  const config = await readConfig();
+  const apiBase = (options.apiBase ?? config.platform.apiBase ?? "https://app.withoperon.com").replace(/\/+$/, "");
+  const token = options.token ?? config.platform.accessToken;
+  if (token === void 0 || token.length === 0) {
+    throw new PlatformEventError("not signed in. Run: operon login", EXIT.auth);
+  }
+  const workspaceSlug = options.workspaceSlug ?? config.platform.workspaceSlug;
+  if (workspaceSlug === void 0 || workspaceSlug.length === 0) {
+    throw new PlatformEventError(
+      "missing workspace. Pass --workspace or run: operon login --workspace <slug>",
+      EXIT.config
+    );
+  }
+  return {
+    send: (event, properties = {}) => sendPlatformEvent({
+      apiBase,
+      token,
+      workspaceSlug,
+      event,
+      properties,
+      ...options.fetchImpl !== void 0 ? { fetchImpl: options.fetchImpl } : {}
+    })
+  };
+}
+async function sendPlatformEvent(input2) {
+  const event = eventNameSchema.parse(input2.event);
+  const properties = eventPropertiesSchema.parse(input2.properties ?? {});
+  const fetchImpl = input2.fetchImpl ?? fetch;
+  let res;
+  try {
+    res = await fetchImpl(
+      `${input2.apiBase.replace(/\/+$/, "")}/api/v1/events`,
+      {
+        method: "POST",
+        headers: {
+          "content-type": "application/json",
+          "x-operon-source": "cli",
+          authorization: `Bearer ${input2.token}`
+        },
+        body: JSON.stringify({
+          event,
+          properties: {
+            ...properties,
+            workspaceSlug: input2.workspaceSlug,
+            source: "cli"
+          }
+        })
+      }
+    );
+  } catch (e) {
+    throw new PlatformEventError(
+      `network error: ${e.message}`,
+      EXIT.network
+    );
+  }
+  if (!res.ok) {
+    const body = await res.text().catch(() => "<unreadable>");
+    throw new PlatformEventError(
+      `server returned ${res.status}: ${body.slice(0, 400)}`,
+      res.status === 401 ? EXIT.auth : EXIT.err,
+      res.status,
+      body
+    );
+  }
+}
+
+// src/lib/push.ts
+import { readFile as readFile6 } from "fs/promises";
+import { join as join8 } from "path";
+var PushOperonError = class extends Error {
+  exitCode;
+  status;
+  body;
+  constructor(message, exitCode, status, body) {
+    super(message);
+    this.name = "PushOperonError";
+    this.exitCode = exitCode;
+    this.status = status;
+    this.body = body;
+  }
+};
+async function pushOperon(options) {
+  const config = await readConfig();
+  const apiBase = (options.apiBase ?? config.platform.apiBase ?? "https://app.withoperon.com").replace(/\/+$/, "");
+  const token = options.token ?? config.platform.accessToken;
+  if (token === void 0 || token.length === 0) {
+    throw new PushOperonError("not signed in. Run: operon login", EXIT.auth);
+  }
+  const workspaceSlug = options.workspace ?? config.platform.workspaceSlug;
+  const candidate = options.candidate ?? await readCandidate(options.slug);
+  if (candidate === void 0) {
+    throw new PushOperonError(
+      `no candidate "${options.slug}" found locally. Run scan first.`,
+      EXIT.noWork
+    );
+  }
+  const skill = await readSkillMarkdown(candidate);
+  const testsYaml = await readTestsYaml(candidate.slug);
+  const body = {
+    ...workspaceSlug !== void 0 ? { workspaceSlug } : {},
+    slug: options.slug,
+    name: titleCase(options.slug),
+    description: truncate(candidate.summary, 1800),
+    polishedSkillMarkdown: skill.markdown,
+    ...testsYaml !== void 0 ? { testsYaml } : {},
+    suggestedTools: candidate.suggestedTools,
+    visibility: options.visibility ?? "team",
+    candidateMeta: {
+      uses: candidate.uses,
+      spanDays: candidate.spanDays,
+      firstSeenAt: candidate.firstSeenAt,
+      lastSeenAt: candidate.lastSeenAt,
+      score: candidate.score
+    }
+  };
+  const fetchImpl = options.fetchImpl ?? fetch;
+  let res;
+  try {
+    res = await fetchImpl(`${apiBase}/api/v1/operons`, {
+      method: "POST",
+      headers: {
+        "content-type": "application/json",
+        "x-operon-source": "cli",
+        authorization: `Bearer ${token}`
+      },
+      body: JSON.stringify(body)
+    });
+  } catch (e) {
+    throw new PushOperonError(
+      `network error: ${e.message}`,
+      EXIT.network
+    );
+  }
+  if (!res.ok) {
+    const text = await res.text().catch(() => "<unreadable>");
+    throw new PushOperonError(
+      `server returned ${res.status}: ${text.slice(0, 400)}`,
+      res.status === 401 ? EXIT.auth : EXIT.err,
+      res.status,
+      text
+    );
+  }
+  const json = await res.json();
+  return {
+    ...json,
+    url: `${apiBase}/${json.workspaceSlug}/${options.slug}`,
+    usedDraftPrompt: skill.usedDraftPrompt
+  };
+}
+async function readTestsYaml(slug) {
+  try {
+    return await readFile6(join8(candidateDir(slug), "tests.yaml"), "utf8");
+  } catch {
+    return void 0;
+  }
+}
+async function readSkillMarkdown(candidate) {
+  try {
+    return {
+      markdown: await readFile6(
+        join8(candidateDir(candidate.slug), "polished.md"),
+        "utf8"
+      ),
+      usedDraftPrompt: false
+    };
+  } catch {
+    return {
+      markdown: `---
+name: ${candidate.slug}
+description: ${truncate(candidate.summary, 90)}
+---
+
+${candidate.draftPrompt}
+`,
+      usedDraftPrompt: true
+    };
+  }
+}
+function titleCase(slug) {
+  return slug.split("-").map((p) => p.length === 0 ? p : p[0].toUpperCase() + p.slice(1)).join(" ");
+}
+function truncate(s, max) {
+  if (s.length <= max) return s;
+  return `${s.slice(0, max - 1)}\u2026`;
+}
+
+// src/commands/mine.ts
+var SOURCES = ["claude-code", "codex", "cursor", "chatgpt"];
+var slugRe2 = /^[a-z0-9-]+$/;
+var optsSchema5 = z8.object({
+  source: z8.array(z8.enum(SOURCES)).default([...SOURCES]),
+  workspace: z8.string().min(1).max(64).regex(slugRe2).optional(),
+  since: z8.string().default("30d"),
+  top: z8.coerce.number().int().positive().default(5),
+  dryRun: z8.boolean().default(false),
+  yes: z8.boolean().default(false),
+  apiBase: z8.string().url().optional()
+});
+function mineCommand() {
+  return new Command6("mine").description(
+    "Mine local sessions, preview suggestions, and publish accepted ones."
+  ).addOption(
+    new Option2("--source <src...>", "Limit to one or more sources").choices([
+      ...SOURCES
+    ])
+  ).option("--workspace <slug>", "Override the default workspace from config").option("--since <duration>", "Window to scan (e.g. 7d, 30d, 90d)", "30d").option("--top <N>", "Max candidates to preview", "5").option("--dry-run", "Print candidates, do not publish", false).option("--yes", "Skip prompts and publish all candidates", false).option("--api-base <url>", "Override platform base URL").action(async (rawOpts) => {
+    const opts = optsSchema5.parse(rawOpts);
+    let since;
+    try {
+      since = new Date(Date.now() - parseDuration(opts.since));
+    } catch (e) {
+      log.err(e.message);
+      process.exit(EXIT.config);
+      return;
+    }
+    const eventClient = await tryCreateEventClient({
+      ...opts.apiBase !== void 0 ? { apiBase: opts.apiBase } : {},
+      ...opts.workspace !== void 0 ? { workspace: opts.workspace } : {}
+    });
+    const startedAt = Date.now();
+    const sources = opts.source.filter(
+      (s) => ADAPTERS[s] !== void 0
+    );
+    await sendMiningEvent(eventClient, "mining_scan_started", {
+      since: opts.since,
+      sources
+    });
+    const allSessions = await collectSessions(sources, since);
+    if (allSessions.length === 0) {
+      await sendMiningEvent(eventClient, "mining_scan_completed", {
+        sessionCount: 0,
+        durationMs: Date.now() - startedAt
+      });
+      log.err(
+        `no sessions in last ${opts.since}. Try --since=90d or --since=365d.`
+      );
+      process.exit(EXIT.noWork);
+      return;
+    }
+    if (!getGlobals().json) {
+      log.step(
+        `mining ${allSessions.length} sessions from last ${opts.since}...`
+      );
+    }
+    const result = mineSessions(allSessions, { render: { top: opts.top } });
+    await sendMiningEvent(eventClient, "mining_scan_completed", {
+      sessionCount: result.sessionCountKept,
+      durationMs: Date.now() - startedAt
+    });
+    const candidates = result.candidates.slice(0, opts.top);
+    if (candidates.length === 0) {
+      log.info("no reusable patterns found. Try widening --since.");
+      process.exit(EXIT.noWork);
+      return;
+    }
+    const sessionsById = new Map(allSessions.map((s) => [s.id, s]));
+    for (const candidate of candidates) {
+      await persistCandidate(candidate, sessionsById);
+      await sendMiningEvent(eventClient, "pattern_detected", {
+        clusterId: candidate.promptShape,
+        clusterSize: candidate.uses,
+        score: candidate.score,
+        keywords: candidate.suggestedTools
+      });
+    }
+    const existing = await loadExistingPreviews(candidates, {
+      ...opts.apiBase !== void 0 ? { apiBase: opts.apiBase } : {},
+      ...opts.workspace !== void 0 ? { workspace: opts.workspace } : {}
+    });
+    const jsonPreviewOnly = getGlobals().json && !opts.yes;
+    const preview = {
+      input: result.sessionCountInput,
+      kept: result.sessionCountKept,
+      clusters: result.clusterCount,
+      dryRun: opts.dryRun || jsonPreviewOnly,
+      candidates: candidates.map(
+        (candidate) => candidateJson(candidate, existing.get(candidate.slug))
+      )
+    };
+    if (!getGlobals().json) {
+      log.info("");
+      log.info("Mined candidates:");
+      log.info("");
+      for (const [index, candidate] of candidates.entries()) {
+        printCandidate(index + 1, candidate, existing.get(candidate.slug));
+      }
+    }
+    if (opts.dryRun || jsonPreviewOnly) {
+      if (getGlobals().json) {
+        log.json(preview);
+      }
+      await sendMiningEvent(eventClient, "mining_session_completed", {
+        candidatesShown: candidates.length,
+        candidatesAccepted: 0,
+        candidatesSkipped: 0,
+        durationMs: Date.now() - startedAt
+      });
+      process.exit(EXIT.ok);
+      return;
+    }
+    const published = [];
+    let dismissed = 0;
+    const rl = opts.yes || getGlobals().json ? void 0 : createInterface3({ input, output });
+    try {
+      for (const candidate of candidates) {
+        let targetSlug = candidate.slug;
+        const decision = opts.yes ? { kind: "publish" } : await promptForDecision(rl, candidate, targetSlug);
+        if (decision.kind === "quit") break;
+        if (decision.kind === "skip") {
+          dismissed += 1;
+          await sendMiningEvent(eventClient, "suggestion_dismissed", {
+            clusterId: candidate.promptShape,
+            slug: targetSlug
+          });
+          continue;
+        }
+        if (decision.kind === "edit") {
+          targetSlug = decision.slug;
+        }
+        try {
+          if (!getGlobals().json) {
+            log.step(`publishing ${targetSlug} ...`);
+          }
+          const pushedResult = await pushOperon({
+            slug: targetSlug,
+            candidate,
+            ...opts.workspace !== void 0 ? { workspace: opts.workspace } : {},
+            ...opts.apiBase !== void 0 ? { apiBase: opts.apiBase } : {}
+          });
+          published.push({ slug: targetSlug, url: pushedResult.url });
+          await sendMiningEvent(eventClient, "suggestion_accepted", {
+            clusterId: candidate.promptShape,
+            slug: targetSlug,
+            score: candidate.score
+          });
+        } catch (e) {
+          if (e instanceof PushOperonError) {
+            log.err(e.message);
+            process.exit(e.exitCode);
+            return;
+          }
+          throw e;
+        }
+      }
+    } finally {
+      rl?.close();
+    }
+    await sendMiningEvent(eventClient, "mining_session_completed", {
+      candidatesShown: candidates.length,
+      candidatesAccepted: published.length,
+      candidatesSkipped: dismissed,
+      durationMs: Date.now() - startedAt
+    });
+    if (getGlobals().json) {
+      log.json({ ...preview, published, dismissed });
+    } else {
+      log.info("");
+      log.step(`Published ${published.length} of ${candidates.length}.`);
+      for (const item of published) {
+        log.info(`  ${item.slug}: ${item.url}`);
+      }
+    }
+    process.exit(EXIT.ok);
+  });
+}
+async function collectSessions(sources, since) {
+  const allSessions = [];
+  for (const sourceName of sources) {
+    const adapter = ADAPTERS[sourceName];
+    if (adapter === void 0) continue;
+    const detect = await adapter.detect();
+    if (!detect.present) continue;
+    for await (const raw of adapter.enumerate({ since })) {
+      let session = await adapter.normalize(raw);
+      session = redactSession(session);
+      allSessions.push(session);
+    }
+  }
+  return allSessions;
+}
+async function persistCandidate(candidate, sessionsById) {
+  const exemplars = candidate.exemplarSessionIds.map((id) => sessionsById.get(id)).filter((s) => s !== void 0);
+  await writeCandidate(candidate, exemplars);
+}
+function printCandidate(index, candidate, existing) {
+  const keywords = candidate.suggestedTools.slice(0, 3);
+  log.info(`  ${index}. ${titleCase(candidate.slug)} (${candidate.slug})`);
+  log.info(
+    `     cluster ${candidate.uses} sessions, ${candidate.spanDays}d span, score ${candidate.score}`
+  );
+  log.info(`     seen ${candidate.firstSeenAt} -> ${candidate.lastSeenAt}`);
+  log.info(`     keywords: ${keywords.join(", ") || "(none)"}`);
+  log.info(`     existing: ${existing?.summary ?? "unchecked"}`);
+  log.info("");
+}
+async function promptForDecision(rl, candidate, targetSlug) {
+  if (rl === void 0) return { kind: "publish" };
+  for (; ; ) {
+    const raw = (await rl.question(
+      `${candidate.slug} [p]ublish, [s]kip, [e]dit slug, [q]uit? `
+    )).trim().toLowerCase();
+    if (raw === "" || raw === "p" || raw === "publish") {
+      return { kind: "publish" };
+    }
+    if (raw === "s" || raw === "skip") return { kind: "skip" };
+    if (raw === "q" || raw === "quit") return { kind: "quit" };
+    if (raw === "e" || raw === "edit") {
+      const next = (await rl.question(`slug (${targetSlug}): `)).trim();
+      if (!slugRe2.test(next)) {
+        log.warn("slug must match /^[a-z0-9-]+$/");
+        continue;
+      }
+      return { kind: "edit", slug: next };
+    }
+  }
+}
+async function tryCreateEventClient(opts) {
+  try {
+    return await createPlatformEventClient({
+      ...opts.apiBase !== void 0 ? { apiBase: opts.apiBase } : {},
+      ...opts.workspace !== void 0 ? { workspaceSlug: opts.workspace } : {}
+    });
+  } catch (e) {
+    if (e instanceof PlatformEventError) {
+      log.debug(`telemetry disabled: ${e.message}`);
+      return void 0;
+    }
+    throw e;
+  }
+}
+async function sendMiningEvent(client, event, properties) {
+  if (client === void 0) return;
+  try {
+    await client.send(event, properties);
+  } catch (e) {
+    if (e instanceof PlatformEventError) {
+      log.warn(`telemetry skipped: ${e.message}`);
+      return;
+    }
+    throw e;
+  }
+}
+async function loadExistingPreviews(candidates, opts) {
+  const out = /* @__PURE__ */ new Map();
+  const config = await readConfig();
+  const workspace = opts.workspace ?? config.platform.workspaceSlug;
+  const token = config.platform.accessToken;
+  if (workspace === void 0 || token === void 0 || token.length === 0) {
+    for (const candidate of candidates) {
+      out.set(candidate.slug, {
+        status: "unchecked",
+        summary: "unchecked (missing workspace or login)"
+      });
+    }
+    return out;
+  }
+  const apiBase = (opts.apiBase ?? config.platform.apiBase ?? "https://app.withoperon.com").replace(/\/+$/, "");
+  for (const candidate of candidates) {
+    out.set(
+      candidate.slug,
+      await loadExistingPreview({ apiBase, workspace, token, candidate })
+    );
+  }
+  return out;
+}
+async function loadExistingPreview(input2) {
+  try {
+    const res = await fetch(
+      `${input2.apiBase}/api/v1/workspaces/${input2.workspace}/operons/${input2.candidate.slug}`,
+      {
+        headers: {
+          "x-operon-source": "cli",
+          authorization: `Bearer ${input2.token}`
+        }
+      }
+    );
+    if (res.status === 404) return { status: "new", summary: "new" };
+    if (!res.ok) {
+      return {
+        status: "unchecked",
+        summary: `unchecked (${res.status})`
+      };
+    }
+    const json = await res.json();
+    if (typeof json.skillUrl !== "string") {
+      return { status: "unchecked", summary: "unchecked (no skill url)" };
+    }
+    const current = await fetch(json.skillUrl).then(
+      (r) => r.ok ? r.text() : void 0
+    );
+    if (current === void 0) {
+      return { status: "unchecked", summary: "unchecked (skill unavailable)" };
+    }
+    const next = await readSkillMarkdown(input2.candidate);
+    if (current === next.markdown) {
+      return { status: "same", summary: "no SKILL.md changes" };
+    }
+    return {
+      status: "changed",
+      summary: `SKILL.md differs (${lineCount(current)} -> ${lineCount(next.markdown)} lines)`
+    };
+  } catch (e) {
+    return {
+      status: "unchecked",
+      summary: `unchecked (${e.message})`
+    };
+  }
+}
+function lineCount(s) {
+  return s.split("\n").length;
+}
+function candidateJson(candidate, existing) {
+  return {
+    slug: candidate.slug,
+    name: titleCase(candidate.slug),
+    uses: candidate.uses,
+    spanDays: candidate.spanDays,
+    score: candidate.score,
+    firstSeenAt: candidate.firstSeenAt,
+    lastSeenAt: candidate.lastSeenAt,
+    keywords: candidate.suggestedTools.slice(0, 3),
+    existing: existing ?? { status: "unchecked", summary: "unchecked" }
+  };
+}
+
+// src/commands/mcp.ts
+import { Command as Command7 } from "commander";
+
+// ../mcp/src/index.ts
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+
+// ../mcp/src/tools.ts
+import { createHash as createHash3 } from "crypto";
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { z as z9 } from "zod";
+var DEFAULT_API_BASE = "https://app.withoperon.com";
+var slugRe3 = /^[a-z0-9-]+$/;
+var semverRe2 = /^\d+\.\d+\.\d+(-[a-z0-9.]+)?$/;
+var sha256HexRe2 = /^[a-f0-9]{64}$/i;
+var maxInt2 = 2147483647;
+var workspaceSchema2 = z9.string().min(1).max(64).regex(slugRe3);
+var slugSchema2 = z9.string().min(1).max(64).regex(slugRe3);
+var semverSchema = z9.string().min(1).max(64).regex(semverRe2);
+var listOperonsResponseSchema = z9.object({
+  workspace: z9.object({
+    slug: z9.string(),
+    name: z9.string()
+  }),
+  operons: z9.array(
+    z9.object({
+      slug: z9.string(),
+      name: z9.string(),
+      description: z9.string().nullable(),
+      visibility: z9.string(),
+      tags: z9.array(z9.string()),
+      updatedAt: z9.string(),
+      currentVersion: z9.object({
+        semver: z9.string(),
+        contentHash: z9.string().regex(sha256HexRe2),
+        publishStatus: z9.string(),
+        evalStatus: z9.string()
+      }).nullable()
+    })
+  )
+});
+var pullResponseSchema = z9.object({
+  workspace: z9.object({
+    slug: z9.string(),
+    name: z9.string()
+  }),
+  operon: z9.object({
+    slug: z9.string(),
+    name: z9.string(),
+    description: z9.string().nullable(),
+    visibility: z9.string(),
+    tags: z9.array(z9.string())
+  }),
+  version: z9.object({
+    semver: z9.string(),
+    contentHash: z9.string().regex(sha256HexRe2),
+    publishStatus: z9.string(),
+    evalStatus: z9.string(),
+    createdAt: z9.string(),
+    changelog: z9.string().nullable()
+  }),
+  skillUrl: z9.string().url()
+});
+var recordRunResponseSchema2 = z9.object({
+  runId: z9.string().uuid(),
+  status: z9.enum(["running", "succeeded", "failed", "timeout"]),
+  runsUsedMtd: z9.number().int().nonnegative(),
+  runsCap: z9.number().int().nonnegative().nullable(),
+  overCap: z9.boolean()
+});
+var OperonApiClient = class {
+  apiBase;
+  token;
+  fetchImpl;
+  constructor(options) {
+    this.apiBase = options.apiBase.replace(/\/+$/, "");
+    this.token = options.token;
+    const fetchImpl = options.fetchImpl ?? globalThis.fetch;
+    this.fetchImpl = (input2, init) => fetchImpl(input2, init);
+  }
+  async validateToken() {
+    await this.requestJson(`${this.apiBase}/api/v1/whoami`, z9.object({}));
+  }
+  listOperons(workspace) {
+    return this.requestJson(
+      `${this.apiBase}/api/v1/workspaces/${workspace}/operons`,
+      listOperonsResponseSchema
+    );
+  }
+  async getOperon(input2) {
+    const params = new URLSearchParams();
+    if (input2.semver !== void 0) params.set("semver", input2.semver);
+    const query = params.size > 0 ? `?${params.toString()}` : "";
+    const metadata = await this.requestJson(
+      `${this.apiBase}/api/v1/workspaces/${input2.workspace}/operons/${input2.slug}${query}`,
+      pullResponseSchema
+    );
+    const skillRes = await this.fetchImpl(metadata.skillUrl);
+    if (!skillRes.ok) {
+      throw new Error(`skill download returned ${skillRes.status}`);
+    }
+    const skillMarkdown = await skillRes.text();
+    const actualHash = createHash3("sha256").update(skillMarkdown).digest("hex");
+    const expectedHash = metadata.version.contentHash.toLowerCase();
+    if (actualHash !== expectedHash) {
+      throw new Error(
+        `content hash mismatch: expected ${expectedHash}, got ${actualHash}`
+      );
+    }
+    return {
+      workspace: metadata.workspace.slug,
+      slug: metadata.operon.slug,
+      name: metadata.operon.name,
+      semver: metadata.version.semver,
+      contentHash: expectedHash,
+      skillMarkdown
+    };
+  }
+  recordRun(input2) {
+    const payload = {
+      workspaceSlug: input2.workspace,
+      operonSlug: input2.operonSlug,
+      semver: input2.semver,
+      invocationSource: "mcp",
+      status: input2.status,
+      ...input2.startedAt !== void 0 ? { startedAt: input2.startedAt } : {},
+      ...input2.finishedAt !== void 0 ? { finishedAt: input2.finishedAt } : {},
+      ...input2.durationMs !== void 0 ? { durationMs: input2.durationMs } : {},
+      ...input2.inputHash !== void 0 ? { inputHash: input2.inputHash } : {},
+      ...input2.tokenIn !== void 0 ? { tokenIn: input2.tokenIn } : {},
+      ...input2.tokenOut !== void 0 ? { tokenOut: input2.tokenOut } : {},
+      ...input2.costUsdEstimated !== void 0 ? { costUsdEstimated: input2.costUsdEstimated } : {},
+      ...input2.billedRunCount !== void 0 ? { billedRunCount: input2.billedRunCount } : {}
+    };
+    return this.requestJson(
+      `${this.apiBase}/api/v1/runs`,
+      recordRunResponseSchema2,
+      {
+        method: "POST",
+        headers: { "content-type": "application/json" },
+        body: JSON.stringify(payload)
+      }
+    );
+  }
+  async requestJson(url, schema, init = {}) {
+    let res;
+    try {
+      res = await this.fetchImpl(url, {
+        ...init,
+        headers: {
+          ...init.headers,
+          "x-operon-source": "mcp",
+          authorization: `Bearer ${this.token}`
+        }
+      });
+    } catch (e) {
+      throw new Error(`network error: ${e.message}`);
+    }
+    if (!res.ok) {
+      const body = await res.text().catch(() => "<unreadable>");
+      throw new Error(`server returned ${res.status}: ${body.slice(0, 400)}`);
+    }
+    return schema.parse(await res.json());
+  }
+};
+async function createOperonMcpServer(options = {}) {
+  const apiBase = options.apiBase ?? process.env["OPERON_API_BASE"] ?? DEFAULT_API_BASE;
+  const token = options.token ?? process.env["OPERON_TOKEN"];
+  if (token === void 0 || token.length === 0) {
+    throw new Error("OPERON_TOKEN is required");
+  }
+  const client = new OperonApiClient({
+    apiBase,
+    token,
+    fetchImpl: options.fetchImpl
+  });
+  if (options.validateOnStart !== false) {
+    await client.validateToken();
+  }
+  const server = new McpServer({
+    name: "operon",
+    version: "0.1.0"
+  });
+  server.registerTool(
+    "list_operons",
+    {
+      title: "List Operons",
+      description: "List operons visible to a workspace member.",
+      inputSchema: {
+        workspace: workspaceSchema2.describe("Workspace slug")
+      }
+    },
+    async ({ workspace }) => jsonResult(await client.listOperons(workspace))
+  );
+  server.registerTool(
+    "get_operon",
+    {
+      title: "Get Operon",
+      description: "Fetch an operon's SKILL.md and version metadata for use as context.",
+      inputSchema: {
+        workspace: workspaceSchema2.describe("Workspace slug"),
+        slug: slugSchema2.describe("Operon slug"),
+        semver: semverSchema.optional().describe("Optional semver; defaults to current version")
+      }
+    },
+    async ({ workspace, slug, semver }) => {
+      const operon = await client.getOperon({ workspace, slug, semver });
+      return {
+        content: [
+          {
+            type: "text",
+            text: `# ${operon.workspace}/${operon.slug}@${operon.semver}
+
+${operon.skillMarkdown}`
+          }
+        ]
+      };
+    }
+  );
+  server.registerTool(
+    "record_run",
+    {
+      title: "Record Run",
+      description: "Record an MCP invocation against an operon version.",
+      inputSchema: {
+        workspace: workspaceSchema2.describe("Workspace slug"),
+        operonSlug: slugSchema2.describe("Operon slug"),
+        semver: semverSchema.describe("Version semver"),
+        status: z9.enum(["running", "succeeded", "failed", "timeout"]).describe("Run status"),
+        startedAt: z9.string().datetime({ offset: true }).optional(),
+        finishedAt: z9.string().datetime({ offset: true }).optional(),
+        durationMs: z9.number().int().min(0).max(maxInt2).optional(),
+        inputHash: z9.string().regex(sha256HexRe2).optional(),
+        tokenIn: z9.number().int().min(0).max(maxInt2).optional(),
+        tokenOut: z9.number().int().min(0).max(maxInt2).optional(),
+        costUsdEstimated: z9.number().finite().min(0).max(9999.999999).optional(),
+        billedRunCount: z9.number().int().min(1).max(maxInt2).optional()
+      }
+    },
+    async (input2) => jsonResult(await client.recordRun(input2))
+  );
+  return server;
+}
+function jsonResult(value) {
+  return {
+    content: [
+      {
+        type: "text",
+        text: JSON.stringify(value, null, 2)
+      }
+    ]
+  };
+}
+
+// ../mcp/src/index.ts
+async function runStdioServer(options = {}) {
+  const server = await createOperonMcpServer(options);
+  const transport = new StdioServerTransport();
+  await server.connect(transport);
+}
+
+// src/commands/mcp.ts
+function mcpCommand() {
+  return new Command7("mcp").description("Launch the Operon MCP server over stdio.").action(async () => {
+    try {
+      await runStdioServer();
+    } catch (e) {
+      log.err(e instanceof Error ? e.message : String(e));
+      process.exit(EXIT.err);
+    }
+  });
+}
+
+// src/commands/polish.ts
+import { writeFile as writeFile5 } from "fs/promises";
+import { join as join9 } from "path";
+import { Command as Command8 } from "commander";
+import { z as z10 } from "zod";
+
+// src/llm/polish.ts
+var API = "https://api.anthropic.com/v1/messages";
+var MODEL = "claude-sonnet-4-6";
+var MAX_TOKENS = 1500;
+async function polishCandidate(candidate, exemplars) {
+  const apiKey = process.env["ANTHROPIC_API_KEY"];
+  if (apiKey === void 0 || apiKey.length === 0) {
+    return { error: { kind: "no-api-key" } };
+  }
+  const prompt = buildPrompt(candidate, exemplars);
+  let res;
+  try {
+    res = await fetch(API, {
+      method: "POST",
+      headers: {
+        "x-api-key": apiKey,
+        "anthropic-version": "2023-06-01",
+        "content-type": "application/json"
+      },
+      body: JSON.stringify({
+        model: MODEL,
+        max_tokens: MAX_TOKENS,
+        messages: [{ role: "user", content: prompt }]
+      })
+    });
+  } catch (e) {
+    return {
+      error: { kind: "network-error", message: e.message }
+    };
+  }
+  if (!res.ok) {
+    const body = await res.text().catch(() => "<unreadable>");
+    return { error: { kind: "http-error", status: res.status, body } };
+  }
+  const json = await res.json();
+  const text = json.content?.filter((b) => b.type === "text").map((b) => b.text ?? "").join("\n").trim();
+  if (text === void 0 || text.length === 0) {
+    return { error: { kind: "empty-response" } };
+  }
+  return {
+    slug: candidate.slug,
+    markdown: text,
+    model: MODEL,
+    usage: {
+      inputTokens: json.usage?.input_tokens ?? 0,
+      outputTokens: json.usage?.output_tokens ?? 0
+    }
+  };
+}
+function buildPrompt(c, exemplars) {
+  const exemplarBlocks = exemplars.slice(0, 3).map((s, i) => {
+    const userMsg = s.messages.find((m) => m.role === "user");
+    const lastAssistant = [...s.messages].reverse().find((m) => m.role === "assistant");
+    const tools = s.toolCalls.map((t) => t.name).slice(0, 12).join(", ");
+    return `### Exemplar ${i + 1}
+session: ${s.id}
+duration: ${s.durationSec}s
+cwd: ${s.cwd ?? "(unknown)"}
+tools used: ${tools || "(none)"}
+file extensions: ${s.fileTouches.map((f) => `${f.extension}:${f.count}`).join(", ") || "(none)"}
+
+first user prompt (truncated to 800c):
+${(userMsg?.content ?? "").slice(0, 800)}
+
+last assistant message (truncated to 500c):
+${(lastAssistant?.content ?? "").slice(0, 500)}`;
+  });
+  return `You are helping a developer turn a recurring Claude Code workflow into a reusable Skill.
+
+The Operon mining pipeline detected this pattern across ${c.uses} sessions over ${c.spanDays} day(s). The candidate's auto-generated metadata:
+
+slug: ${c.slug}
+suggested tools: ${c.suggestedTools.join(", ") || "(none)"}
+file extensions touched: (see exemplars below)
+
+Below are ${exemplars.length} exemplar sessions that all matched this pattern. Read them carefully.
+
+${exemplarBlocks.join("\n\n")}
+
+---
+
+Now write a clean SKILL.md that:
+
+1. Starts with a 1-sentence "When to use this skill" trigger that captures what the user is actually trying to accomplish (NOT what tools they used \u2014 those are an implementation detail).
+2. Lists 3-7 specific, actionable steps. Each step should be concrete enough that an agent reading just this skill can execute it. Reference the actual pattern observed across the exemplars \u2014 paths, commands, decisions.
+3. Has an "Allowed tools" line listing the most-used tools from the exemplars.
+4. Ends with one short example invocation in a fenced code block.
+
+Output ONLY the SKILL.md content, with frontmatter:
+---
+name: ${c.slug}
+description: <short description, under 100 chars, what this skill does>
+allowed-tools: <comma-separated tool list>
+---
+
+(then the body)
+
+No preamble, no explanation, no "Here is the SKILL.md". Just the file content.`;
+}
+
+// src/commands/polish.ts
+var slugSchema3 = z10.string().min(1).max(64).regex(/^[a-z0-9-]+$/);
+var optsSchema6 = z10.object({
+  batch: z10.boolean().default(false),
+  minScore: z10.coerce.number().default(0),
+  limit: z10.coerce.number().int().positive().default(10)
+});
+function polishCommand() {
+  return new Command8("polish").argument("[slug]", "Candidate slug to polish (omit with --batch)").description(
+    "Use Claude to turn a candidate into a clean SKILL.md. Requires ANTHROPIC_API_KEY."
+  ).option("--batch", "Polish every candidate above --min-score", false).option("--min-score <n>", "Score threshold for --batch (default 0)", "0").option(
+    "--limit <n>",
+    "Cap the number of candidates polished in --batch",
+    "10"
+  ).action(async (slugArg, rawOpts) => {
+    const opts = optsSchema6.parse(rawOpts);
+    if (opts.batch) {
+      await runBatch(opts.minScore, opts.limit);
+      return;
+    }
+    if (slugArg === void 0) {
+      log.err("polish: pass a slug or --batch");
+      process.exit(EXIT.config);
+      return;
+    }
+    const slug = slugSchema3.parse(slugArg);
+    const candidate = await readCandidate(slug);
+    if (candidate === void 0) {
+      log.err(`no candidate "${slug}" found`);
+      process.exit(EXIT.noWork);
+      return;
+    }
+    const result = await polishOne(candidate);
+    if ("error" in result) {
+      exitFromPolishError(result.error);
+      return;
+    }
+    if (getGlobals().json) {
+      log.json({
+        slug: result.slug,
+        path: join9(candidateDir(slug), "polished.md"),
+        model: result.model,
+        usage: result.usage
+      });
+    } else {
+      log.step(
+        `wrote ${join9(candidateDir(slug), "polished.md")}  (${result.usage.inputTokens} in / ${result.usage.outputTokens} out tokens)`
+      );
+      log.info("");
+      log.info(result.markdown);
+    }
+    process.exit(EXIT.ok);
+  });
+}
+async function runBatch(minScore, limit) {
+  const all = await listCandidates();
+  const eligible = all.filter((c) => c.score >= minScore).sort((a, b) => b.score - a.score).slice(0, limit);
+  if (eligible.length === 0) {
+    log.err(
+      `no candidates above min-score=${minScore} (out of ${all.length} total)`
+    );
+    process.exit(EXIT.noWork);
+    return;
+  }
+  log.step(
+    `batch polishing ${eligible.length} candidate${eligible.length === 1 ? "" : "s"} via Claude...`
+  );
+  const results = [];
+  for (const c of eligible) {
+    const r = await polishOne(c);
+    if ("error" in r) {
+      if (r.error.kind === "no-api-key") {
+        log.err(
+          "ANTHROPIC_API_KEY is not set. Polish requires explicit opt-in via the env var."
+        );
+        process.exit(EXIT.config);
+        return;
+      }
+      results.push({ slug: c.slug, ok: false, error: errorMessage(r.error) });
+      log.warn(`  ${c.slug}: ${errorMessage(r.error)}`);
+      continue;
+    }
+    results.push({
+      slug: c.slug,
+      ok: true,
+      inputTokens: r.usage.inputTokens,
+      outputTokens: r.usage.outputTokens
+    });
+    log.info(
+      `  ${c.slug}  (${r.usage.inputTokens} in / ${r.usage.outputTokens} out)`
+    );
+  }
+  const okCount = results.filter((r) => r.ok).length;
+  if (getGlobals().json) {
+    log.json({ polished: okCount, total: eligible.length, results });
+  } else {
+    log.step(`polished ${okCount}/${eligible.length}`);
+  }
+  process.exit(okCount > 0 ? EXIT.ok : EXIT.err);
+}
+async function polishOne(candidate) {
+  const exemplars = await loadExemplars(candidate.exemplarSessionIds);
+  if (exemplars.length === 0) {
+    return {
+      error: {
+        kind: "empty-response"
+      }
+    };
+  }
+  const result = await polishCandidate(candidate, exemplars);
+  if ("error" in result) return result;
+  const path = join9(candidateDir(candidate.slug), "polished.md");
+  await writeFile5(path, `${result.markdown}
+`, "utf8");
+  return result;
+}
+function errorMessage(e) {
+  switch (e.kind) {
+    case "no-api-key":
+      return "ANTHROPIC_API_KEY not set";
+    case "http-error":
+      return `HTTP ${e.status}: ${e.body.slice(0, 200)}`;
+    case "network-error":
+      return `network: ${e.message}`;
+    case "empty-response":
+      return "empty/missing exemplars or response";
+  }
+}
+function exitFromPolishError(e) {
+  switch (e.kind) {
+    case "no-api-key":
+      log.err(
+        "ANTHROPIC_API_KEY is not set. Polish requires explicit opt-in via the env var."
+      );
+      process.exit(EXIT.config);
+      return;
+    case "http-error":
+      log.err(`Anthropic API returned ${e.status}: ${e.body.slice(0, 400)}`);
+      process.exit(EXIT.network);
+      return;
+    case "network-error":
+      log.err(`network error: ${e.message}`);
+      process.exit(EXIT.network);
+      return;
+    case "empty-response":
+      log.err("Anthropic API returned empty content (or no exemplars)");
+      process.exit(EXIT.err);
+      return;
+  }
+}
+async function loadExemplars(ids) {
+  const wanted = new Set(ids);
+  const out = [];
+  for (const adapter of Object.values(ADAPTERS)) {
+    if (adapter === void 0) continue;
+    const detect = await adapter.detect();
+    if (!detect.present) continue;
+    for await (const raw of adapter.enumerate({})) {
+      const id = `${adapter.name}:${raw.rawId}`;
+      if (!wanted.has(id)) continue;
+      const session = await adapter.normalize(raw);
+      out.push(session);
+      wanted.delete(id);
+      if (wanted.size === 0) return out;
+    }
+  }
+  return out;
+}
+
+// src/commands/publish.ts
+import { Command as Command9 } from "commander";
+import { z as z11 } from "zod";
+var slugSchema4 = z11.string().min(1).max(64).regex(/^[a-z0-9-]+$/);
+var optsSchema7 = z11.object({
+  workspace: z11.string().min(1).max(64).optional(),
+  visibility: z11.enum(["private", "team"]).default("team"),
+  apiBase: z11.string().url().optional()
+});
+function publishCommand() {
+  return new Command9("publish").argument("<slug>", "Candidate slug to publish").description(
+    "Upload a polished candidate to the Operon platform (requires `operon login`)."
+  ).option("--workspace <slug>", "Override the default workspace from config").option("--visibility <v>", "private | team (default: team)", "team").option("--api-base <url>", "Override platform base URL").action(async (slugArg, rawOpts) => {
+    const slug = slugSchema4.parse(slugArg);
+    const opts = optsSchema7.parse(rawOpts);
+    log.step(`publishing ${slug} ...`);
+    let json;
+    try {
+      json = await pushOperon({
+        slug,
+        ...opts.workspace !== void 0 ? { workspace: opts.workspace } : {},
+        visibility: opts.visibility,
+        ...opts.apiBase !== void 0 ? { apiBase: opts.apiBase } : {}
+      });
+    } catch (e) {
+      if (e instanceof PushOperonError) {
+        log.err(e.message);
+        process.exit(e.exitCode);
+        return;
+      }
+      throw e;
+    }
+    if (json.usedDraftPrompt) {
+      log.warn(
+        `${slug} hasn't been polished yet. Publishing the raw draft prompt instead.`
+      );
+      log.warn(
+        `For better results: ANTHROPIC_API_KEY=... operon polish ${slug}`
+      );
+    }
+    if (getGlobals().json) {
+      log.json(json);
+    } else {
+      log.step(`published ${slug}@${json.semver} to ${json.url}`);
+      log.info(`  storage: ${json.storagePath}`);
+    }
+    process.exit(EXIT.ok);
+  });
+}
+
+// src/commands/prune.ts
+import { Command as Command10 } from "commander";
+import { z as z12 } from "zod";
+var optsSchema8 = z12.object({
+  olderThan: z12.string().default("60d"),
+  apply: z12.boolean().default(false),
+  yes: z12.boolean().default(false)
+});
+function pruneCommand() {
+  return new Command10("prune").description(
+    "Archive stale candidates (lastSeenAt older than --older-than)."
+  ).option(
+    "--older-than <duration>",
+    "Staleness threshold (e.g. 30d, 60d, 90d)",
+    "60d"
+  ).option("--apply", "Actually archive (default: dry-run)", false).option("--yes", "Skip the confirmation prompt", false).action(async (rawOpts) => {
+    const opts = optsSchema8.parse(rawOpts);
+    let cutoff;
+    try {
+      cutoff = new Date(Date.now() - parseDuration(opts.olderThan));
+    } catch (e) {
+      log.err(e.message);
+      process.exit(EXIT.config);
+      return;
+    }
+    const all = await listCandidates();
+    const stale = all.filter((c) => new Date(c.lastSeenAt) < cutoff);
+    if (getGlobals().json) {
+      log.json({
+        olderThan: opts.olderThan,
+        cutoff: cutoff.toISOString(),
+        totalCandidates: all.length,
+        staleCount: stale.length,
+        stale: stale.map((c) => ({
+          slug: c.slug,
+          lastSeenAt: c.lastSeenAt,
+          uses: c.uses
+        })),
+        applied: opts.apply
+      });
+      if (opts.apply && stale.length > 0) {
+        for (const c of stale) await trashCandidate(c.slug);
+      }
+      process.exit(stale.length > 0 ? EXIT.ok : EXIT.noWork);
+    }
+    if (stale.length === 0) {
+      log.info(
+        `nothing to prune (0 of ${all.length} candidates older than ${opts.olderThan})`
+      );
+      process.exit(EXIT.noWork);
+    }
+    log.step(
+      `${stale.length} stale candidate${stale.length === 1 ? "" : "s"} (lastSeenAt < ${cutoff.toISOString().slice(0, 10)}):`
+    );
+    for (const c of stale) {
+      const lastSeen = c.lastSeenAt.slice(0, 10);
+      log.info(`  ${c.slug}  (${c.uses} uses, last seen ${lastSeen})`);
+    }
+    if (!opts.apply) {
+      log.info("");
+      log.info("Dry run. Re-run with --apply to archive.");
+      process.exit(EXIT.ok);
+    }
+    if (!opts.yes) {
+      log.err(
+        "Refusing to archive without --yes. Re-run: operon prune --apply --yes"
+      );
+      process.exit(EXIT.config);
+      return;
+    }
+    const undoIds = [];
+    for (const c of stale) {
+      const undoId = await trashCandidate(c.slug);
+      undoIds.push(undoId);
+    }
+    log.step(
+      `archived ${undoIds.length} candidate${undoIds.length === 1 ? "" : "s"} \u2192 ~/.operon/.trash/`
+    );
+    log.info("Restore via: operon undo --list");
+    process.exit(EXIT.ok);
+  });
+}
+
+// src/commands/scan.ts
+import { Command as Command11, Option as Option3 } from "commander";
+import { z as z13 } from "zod";
+
+// src/peer/discover.ts
+import { readdir as readdir6, readFile as readFile7 } from "fs/promises";
+import { basename as basename4, join as join10 } from "path";
+async function discoverPeerSkills(repoPaths) {
+  const out = [];
+  for (const repo of repoPaths) {
+    const skillsDir = join10(repo, ".claude", "skills");
+    let entries;
+    try {
+      entries = await readdir6(skillsDir, { withFileTypes: true });
+    } catch {
+      continue;
+    }
+    for (const entry of entries) {
+      if (!entry.isDirectory()) continue;
+      const path = join10(skillsDir, entry.name, "SKILL.md");
+      let raw;
+      try {
+        raw = await readFile7(path, "utf8");
+      } catch {
+        continue;
+      }
+      const name = parseFrontmatterName(raw) ?? basename4(entry.name);
+      out.push({ name, repo, path });
+    }
+  }
+  return out;
+}
+var FM_NAME_RE = /^---[\r\n]+([\s\S]*?)[\r\n]+---/;
+function parseFrontmatterName(raw) {
+  const fm = FM_NAME_RE.exec(raw);
+  if (fm?.[1] === void 0) return void 0;
+  for (const line of fm[1].split(/\r?\n/)) {
+    const m = /^name:\s*(.+?)\s*$/.exec(line);
+    if (m?.[1] !== void 0) return m[1];
+  }
+  return void 0;
+}
+function annotateWithPeers(candidates, peers) {
+  const bySlug = /* @__PURE__ */ new Map();
+  for (const p of peers) {
+    const arr = bySlug.get(p.name) ?? [];
+    arr.push(p.repo);
+    bySlug.set(p.name, arr);
+  }
+  return candidates.map((c) => ({
+    ...c,
+    peerRepos: bySlug.get(c.slug) ?? []
+  }));
+}
+
+// src/commands/scan.ts
+var SOURCES2 = ["claude-code", "codex", "cursor", "chatgpt"];
+var optsSchema9 = z13.object({
+  source: z13.array(z13.enum(SOURCES2)).default([...SOURCES2]),
+  since: z13.string().optional(),
+  top: z13.coerce.number().int().positive().default(10),
+  redact: z13.boolean().default(true),
+  anonStats: z13.boolean().default(false),
+  peer: z13.array(z13.string()).default([])
+});
+function scanCommand() {
+  return new Command11("scan").description(
+    "Mine local Claude Code, Codex, and Cursor sessions and render candidate operons."
+  ).addOption(
+    new Option3("--source <src...>", "Limit to one or more sources").choices([
+      ...SOURCES2
+    ])
+  ).option(
+    "--since <duration>",
+    "Only consider sessions newer than (e.g. 30d, 14d, 24h)"
+  ).option("--top <N>", "Render top N candidates", "10").option("--no-redact", "Skip secrets redaction (warns loudly; dev-only)").option("--anon-stats", "Opt in to anonymous usage stats (one-time)", false).option(
+    "--peer <repo...>",
+    "Cross-reference candidates against peer repos' .claude/skills/"
+  ).action(async (rawOpts) => {
+    const opts = optsSchema9.parse(rawOpts);
+    log.debug(`scan opts: ${JSON.stringify(opts)}`);
+    let since;
+    if (opts.since !== void 0) {
+      try {
+        since = new Date(Date.now() - parseDuration(opts.since));
+      } catch (e) {
+        log.err(e.message);
+        process.exit(EXIT.config);
+      }
+    }
+    if (!opts.redact) {
+      log.warn(
+        "redaction disabled \u2014 secrets in your sessions may surface in output"
+      );
+    }
+    const sources = opts.source.filter(
+      (s) => ADAPTERS[s] !== void 0
+    );
+    if (sources.length === 0) {
+      log.err("no enabled sources detected (claude-code, codex, cursor)");
+      process.exit(EXIT.noWork);
+    }
+    const summary = {};
+    const allSessions = [];
+    for (const sourceName of sources) {
+      const adapter = ADAPTERS[sourceName];
+      if (adapter === void 0) continue;
+      const detect = await adapter.detect();
+      if (!detect.present) {
+        log.debug(`${sourceName}: not present (${detect.reason ?? ""})`);
+        continue;
+      }
+      log.step(`scanning ${sourceName}...`);
+      const stats = { sessions: 0, messages: 0 };
+      const enumerateOpts = {};
+      if (since !== void 0) enumerateOpts.since = since;
+      for await (const raw of adapter.enumerate(enumerateOpts)) {
+        let session = await adapter.normalize(raw);
+        if (opts.redact) session = redactSession(session);
+        stats.sessions += 1;
+        stats.messages += session.messages.length;
+        allSessions.push(session);
+      }
+      summary[sourceName] = stats;
+    }
+    if (allSessions.length === 0) {
+      log.err(
+        "no sessions found in --since window. Try --since=365d to widen."
+      );
+      process.exit(EXIT.noWork);
+    }
+    log.step(`mining ${allSessions.length} sessions (top ${opts.top})...`);
+    const result = mineSessions(allSessions, {
+      render: { top: opts.top }
+    });
+    const peers = opts.peer.length > 0 ? await discoverPeerSkills(opts.peer) : [];
+    const candidatesWithPeers = annotateWithPeers(result.candidates, peers);
+    const teamCount = candidatesWithPeers.filter(
+      (c) => c.peerRepos.length > 0
+    ).length;
+    const sessionsById = new Map(allSessions.map((s) => [s.id, s]));
+    for (const c of result.candidates) {
+      const exemplars = c.exemplarSessionIds.map((id) => sessionsById.get(id)).filter((s) => s !== void 0);
+      await writeCandidate(c, exemplars);
+    }
+    if (getGlobals().json) {
+      log.json({
+        summary,
+        input: result.sessionCountInput,
+        kept: result.sessionCountKept,
+        clusters: result.clusterCount,
+        candidates: candidatesWithPeers
+      });
+    } else {
+      for (const [src, s] of Object.entries(summary)) {
+        log.info(`  ${src}: ${s.sessions} sessions, ${s.messages} messages`);
+      }
+      log.info(
+        `kept ${result.sessionCountKept}/${result.sessionCountInput} sessions, ${result.clusterCount} clusters, ${result.candidates.length} candidates` + (teamCount > 0 ? `, ${teamCount} team-recurring` : "")
+      );
+      if (result.candidates.length > 0) {
+        log.info("");
+        log.info(renderCandidateTable(result.candidates));
+        for (const c of candidatesWithPeers) {
+          if (c.peerRepos.length > 0) {
+            log.info(
+              `  \u2605 ${c.slug} also lives at ${c.peerRepos.join(", ")} \u2014 team-recurring`
+            );
+          }
+        }
+      }
+    }
+    process.exit(result.candidates.length > 0 ? EXIT.ok : EXIT.noWork);
+  });
+}
+
+// src/commands/show.ts
+import { Command as Command12 } from "commander";
+import { z as z14 } from "zod";
+
+// src/render/show-detail.ts
+import chalk4 from "chalk";
+function renderCandidateDetail(c) {
+  const colored = !getGlobals().noColor;
+  const bold2 = (s) => colored ? chalk4.bold(s) : s;
+  const dim2 = (s) => colored ? chalk4.dim(s) : s;
+  const breakdown = Object.entries(c.scoreBreakdown).map(([k, v]) => `${k}=${v.toFixed(3)}`).join("  ");
+  return [
+    `${bold2("slug")}        ${c.slug}`,
+    `${bold2("score")}       ${c.score.toFixed(3)}  ${dim2(`(${breakdown})`)}`,
+    `${bold2("uses")}        ${c.uses} across ${c.spanDays} day(s)`,
+    `${bold2("tools")}       ${c.suggestedTools.join(", ") || "(none)"}`,
+    `${bold2("exemplars")}   ${c.exemplarSessionIds.join(", ")}`,
+    "",
+    bold2("draft prompt"),
+    indent(c.draftPrompt),
+    "",
+    bold2("summary"),
+    indent(c.summary),
+    "",
+    bold2("draft eval"),
+    indent(JSON.stringify(c.draftEval, null, 2))
+  ].join("\n");
+}
+function indent(s) {
+  return s.split("\n").map((line) => `  ${line}`).join("\n");
+}
+
+// src/commands/show.ts
+var slugSchema5 = z14.string().min(1).max(64).regex(/^[a-z0-9-]+$/, "lowercase letters, digits, hyphens only");
+function showCommand() {
+  return new Command12("show").argument("<slug>", "Candidate or operon slug").description("Pretty-print a candidate or operon.").option("--exemplars <N>", "Show N exemplar sessions", "3").option("--full", "Show full prompt and tool details", false).action(async (slugArg) => {
+    const slug = slugSchema5.parse(slugArg);
+    const candidate = await readCandidate(slug);
+    if (candidate === void 0) {
+      log.err(`no candidate found at ~/.operon/candidates/${slug}/`);
+      process.exit(EXIT.noWork);
+    }
+    if (getGlobals().json) {
+      log.json(candidate);
+      process.exit(EXIT.ok);
+    }
+    log.info(renderCandidateDetail(candidate));
+    process.exit(EXIT.ok);
+  });
+}
+
+// src/commands/suggest.ts
+import { Command as Command13, Option as Option4 } from "commander";
+import { z as z15 } from "zod";
+
+// src/lib/suggestions.ts
+var SubmitSuggestionError = class extends Error {
+  exitCode;
+  constructor(message, exitCode) {
+    super(message);
+    this.name = "SubmitSuggestionError";
+    this.exitCode = exitCode;
+  }
+};
+async function submitMiningSuggestion(candidate, options = {}) {
+  const config = await readConfig();
+  const apiBase = (options.apiBase ?? config.platform.apiBase ?? "https://app.withoperon.com").replace(/\/+$/, "");
+  const token = options.token ?? config.platform.accessToken;
+  if (token === void 0 || token.length === 0) {
+    throw new SubmitSuggestionError(
+      "not signed in. Run: operon login",
+      EXIT.auth
+    );
+  }
+  const workspaceSlug = options.workspaceSlug ?? config.platform.workspaceSlug;
+  if (workspaceSlug === void 0 || workspaceSlug.length === 0) {
+    throw new SubmitSuggestionError(
+      "missing workspace. Pass --workspace or run: operon login --workspace <slug>",
+      EXIT.config
+    );
+  }
+  const skill = await readSkillMarkdown(candidate);
+  const fetchImpl = options.fetchImpl ?? fetch;
+  let res;
+  try {
+    res = await fetchImpl(
+      `${apiBase}/api/v1/workspaces/${workspaceSlug}/suggestions`,
+      {
+        method: "POST",
+        headers: {
+          "content-type": "application/json",
+          "x-operon-source": "cli",
+          authorization: `Bearer ${token}`
+        },
+        body: JSON.stringify({
+          clusterId: candidate.promptShape,
+          suggestedSlug: candidate.slug,
+          suggestedName: titleCase(candidate.slug),
+          skillMarkdown: skill.markdown,
+          keywords: candidate.suggestedTools.slice(0, 8),
+          clusterSize: candidate.uses,
+          firstSeenAt: candidate.firstSeenAt,
+          lastSeenAt: candidate.lastSeenAt,
+          score: candidate.score
+        })
+      }
+    );
+  } catch (e) {
+    throw new SubmitSuggestionError(
+      `network error: ${e.message}`,
+      EXIT.network
+    );
+  }
+  if (!res.ok) {
+    const body = await res.text().catch(() => "<unreadable>");
+    throw new SubmitSuggestionError(
+      `server returned ${res.status}: ${body.slice(0, 400)}`,
+      res.status === 401 ? EXIT.auth : EXIT.err
+    );
+  }
+  return await res.json();
+}
+
+// src/commands/suggest.ts
+import { writeFile as writeFile6 } from "fs/promises";
+import { join as join11 } from "path";
+var SOURCES3 = ["claude-code", "codex", "cursor", "chatgpt"];
+var optsSchema10 = z15.object({
+  source: z15.array(z15.enum(SOURCES3)).default([...SOURCES3]),
+  since: z15.string().default("30d"),
+  top: z15.coerce.number().int().positive().default(5),
+  polish: z15.boolean().default(false),
+  minUses: z15.coerce.number().int().positive().default(2),
+  submit: z15.boolean().default(false),
+  workspace: z15.string().min(1).max(64).optional(),
+  apiBase: z15.string().url().optional()
+});
+function suggestCommand() {
+  return new Command13("suggest").description(
+    "Scan + rank + (optionally) polish \u2014 surface what's actually worth saving."
+  ).addOption(
+    new Option4("--source <src...>", "Limit to one or more sources").choices([
+      ...SOURCES3
+    ])
+  ).option("--since <duration>", "Window to scan (e.g. 7d, 30d)", "30d").option("--top <N>", "Show the top N suggestions", "5").option(
+    "--polish",
+    "Also call Claude to draft a clean SKILL.md per suggestion (needs ANTHROPIC_API_KEY)",
+    false
+  ).option(
+    "--min-uses <n>",
+    "Only suggest patterns with at least this many sessions",
+    "2"
+  ).option(
+    "--submit",
+    "Submit mining telemetry to the Operon platform (requires operon login)",
+    false
+  ).option("--workspace <slug>", "Workspace slug for submitted telemetry").option("--api-base <url>", "Override platform base URL").action(async (rawOpts) => {
+    const opts = optsSchema10.parse(rawOpts);
+    let since;
+    try {
+      since = new Date(Date.now() - parseDuration(opts.since));
+    } catch (e) {
+      log.err(e.message);
+      process.exit(EXIT.config);
+      return;
+    }
+    let eventClient;
+    if (opts.submit) {
+      try {
+        eventClient = await createPlatformEventClient({
+          ...opts.apiBase !== void 0 ? { apiBase: opts.apiBase } : {},
+          ...opts.workspace !== void 0 ? { workspaceSlug: opts.workspace } : {}
+        });
+      } catch (e) {
+        if (e instanceof PlatformEventError) {
+          log.err(e.message);
+          process.exit(e.exitCode);
+          return;
+        }
+        throw e;
+      }
+    }
+    const sources = opts.source.filter(
+      (s) => ADAPTERS[s] !== void 0
+    );
+    const startedAt = Date.now();
+    await sendMiningEvent2(eventClient, "mining_scan_started", {
+      since: opts.since,
+      sources
+    });
+    const allSessions = [];
+    for (const sourceName of sources) {
+      const adapter = ADAPTERS[sourceName];
+      if (adapter === void 0) continue;
+      const detect = await adapter.detect();
+      if (!detect.present) continue;
+      for await (const raw of adapter.enumerate({ since })) {
+        let session = await adapter.normalize(raw);
+        session = redactSession(session);
+        allSessions.push(session);
+      }
+    }
+    if (allSessions.length === 0) {
+      await sendMiningEvent2(eventClient, "mining_scan_completed", {
+        sessionCount: 0,
+        durationMs: Date.now() - startedAt
+      });
+      log.err(
+        `no sessions in last ${opts.since}. Try --since=90d or --since=365d.`
+      );
+      process.exit(EXIT.noWork);
+      return;
+    }
+    log.step(
+      `mining ${allSessions.length} sessions from last ${opts.since}...`
+    );
+    const result = mineSessions(allSessions, { render: { top: opts.top } });
+    const top = result.candidates.filter((c) => c.uses >= opts.minUses);
+    await sendMiningEvent2(eventClient, "mining_scan_completed", {
+      sessionCount: result.sessionCountKept,
+      durationMs: Date.now() - startedAt
+    });
+    if (top.length === 0) {
+      log.info(
+        `no patterns with >= ${opts.minUses} uses found. Either widen --since or work some more :)`
+      );
+      process.exit(EXIT.noWork);
+      return;
+    }
+    for (const c of top) {
+      await sendMiningEvent2(eventClient, "pattern_detected", {
+        clusterId: c.promptShape,
+        clusterSize: c.uses,
+        score: c.score,
+        keywords: c.suggestedTools
+      });
+    }
+    const sessionsById = new Map(allSessions.map((s) => [s.id, s]));
+    for (const c of top) {
+      const exemplars = c.exemplarSessionIds.map((id) => sessionsById.get(id)).filter((s) => s !== void 0);
+      await writeCandidate(c, exemplars);
+    }
+    const polished = /* @__PURE__ */ new Set();
+    if (opts.polish) {
+      log.step(`polishing ${top.length} via Claude...`);
+      for (const c of top) {
+        const exemplars = c.exemplarSessionIds.map((id) => sessionsById.get(id)).filter((s) => s !== void 0);
+        const r = await polishCandidate(c, exemplars);
+        if ("error" in r) {
+          if (r.error.kind === "no-api-key") {
+            log.warn(
+              "ANTHROPIC_API_KEY not set \u2014 skipping --polish for the rest."
+            );
+            break;
+          }
+          log.warn(`  ${c.slug}: polish failed (${r.error.kind})`);
+          continue;
+        }
+        await writeFile6(
+          join11(candidateDir(c.slug), "polished.md"),
+          `${r.markdown}
+`,
+          "utf8"
+        );
+        polished.add(c.slug);
+      }
+    }
+    if (opts.submit) {
+      let submitted = 0;
+      for (const c of top) {
+        try {
+          await submitMiningSuggestion(c, {
+            ...opts.apiBase !== void 0 ? { apiBase: opts.apiBase } : {},
+            ...opts.workspace !== void 0 ? { workspaceSlug: opts.workspace } : {}
+          });
+          submitted += 1;
+        } catch (e) {
+          if (e instanceof SubmitSuggestionError) {
+            log.warn(`  ${c.slug}: submit failed (${e.message})`);
+            continue;
+          }
+          throw e;
+        }
+      }
+      log.step(
+        `${submitted} suggestion${submitted === 1 ? "" : "s"} submitted`
+      );
+    }
+    if (getGlobals().json) {
+      log.json({
+        suggestions: top.map((c) => ({
+          slug: c.slug,
+          uses: c.uses,
+          spanDays: c.spanDays,
+          score: c.score,
+          firstSeenAt: c.firstSeenAt,
+          lastSeenAt: c.lastSeenAt,
+          polished: polished.has(c.slug)
+        }))
+      });
+      process.exit(EXIT.ok);
+    }
+    log.info("");
+    log.info("You've done these recently:");
+    log.info("");
+    for (const [i, c] of top.entries()) {
+      const days = c.spanDays === 0 ? "today" : `${c.spanDays}d span`;
+      const ready = polished.has(c.slug) ? "  \u2605 polished" : "";
+      log.info(
+        `  ${i + 1}. ${c.slug.padEnd(28)} (${c.uses} uses, ${days})${ready}`
+      );
+    }
+    log.info("");
+    log.info("Save the most useful ones as team skills:");
+    const example = top[0];
+    if (!polished.has(example.slug) && !opts.polish) {
+      log.info(
+        `  operon polish ${example.slug}                     # draft a clean SKILL.md`
+      );
+    }
+    log.info(
+      `  operon publish ${example.slug} --workspace <slug>   # upload to your team`
+    );
+    log.info(
+      `  operon install <workspace>/${example.slug}          # install after publish`
+    );
+    process.exit(EXIT.ok);
+  });
+}
+async function sendMiningEvent2(client, event, properties) {
+  if (client === void 0) return;
+  try {
+    await client.send(event, properties);
+  } catch (e) {
+    if (e instanceof PlatformEventError) {
+      log.warn(`telemetry skipped: ${e.message}`);
+      return;
+    }
+    throw e;
+  }
+}
+
+// src/commands/undo.ts
+import { readdir as readdir7 } from "fs/promises";
+import { Command as Command14 } from "commander";
+import { z as z16 } from "zod";
+var optsSchema11 = z16.object({
+  list: z16.boolean().default(false),
+  id: z16.string().min(1).max(64).optional()
+});
+function undoCommand() {
+  return new Command14("undo").description("Reverse the most recent destructive action.").argument("[slug]", "Operon slug whose promotion to undo").option("--list", "List recent undoable actions", false).option("--id <undo-id>", "Undo a specific action by id").action(async (slugArg, rawOpts) => {
+    const opts = optsSchema11.parse(rawOpts);
+    if (opts.list) {
+      let entries;
+      try {
+        entries = await readdir7(TRASH_DIR);
+      } catch {
+        entries = [];
+      }
+      if (getGlobals().json) {
+        log.json({ trashed: entries });
+      } else if (entries.length === 0) {
+        log.info("nothing in trash");
+      } else {
+        for (const e of entries) log.info(`  ${e}`);
+      }
+      process.exit(EXIT.ok);
+    }
+    if (slugArg === void 0) {
+      log.err("undo: pass a slug or --list to inspect the trash bin");
+      process.exit(EXIT.config);
+    }
+    try {
+      const undoId = await trashOperon(slugArg);
+      log.step(
+        `moved operons/${slugArg} \u2192 .trash/${undoId}/ \u2014 restore with mv`
+      );
+      process.exit(EXIT.ok);
+    } catch (e) {
+      log.err(e.message);
+      process.exit(EXIT.err);
+    }
+  });
+}
+
+// src/cli.ts
+var program = new Command15();
+program.name("operon").description("Team agent memory for AI-native engineering teams.").version(CLI_VERSION).option("--json", "Machine-readable JSON output", false).option("--no-color", "Disable ANSI color").option("-q, --quiet", "Suppress non-error output", false).option("-v, --verbose", "Show debug-level info", false).option("--config <path>", "Override default ~/.operon/config.toml").option("--cwd <path>", "Override the inferred project root").addOption(new Option5("--no-redact", "Skip secrets redaction").hideHelp()).hook("preAction", (thisCommand) => {
+  const o = thisCommand.opts();
+  setGlobals({
+    json: o.json ?? false,
+    noColor: o.color === false,
+    quiet: o.quiet ?? false,
+    verbose: o.verbose ?? false,
+    configPath: o.config,
+    cwd: o.cwd ?? process.cwd()
+  });
+});
+program.addCommand(scanCommand());
+program.addCommand(suggestCommand());
+program.addCommand(mineCommand());
+program.addCommand(listCommand());
+program.addCommand(showCommand());
+program.addCommand(polishCommand());
+program.addCommand(pruneCommand());
+program.addCommand(loginCommand());
+program.addCommand(mcpCommand());
+program.addCommand(installCommand());
+program.addCommand(publishCommand());
+program.addCommand(doctorCommand());
+program.addCommand(undoCommand());
+program.addCommand(configCommand());
+program.parseAsync().catch((err) => {
+  log.err(err instanceof Error ? err.message : String(err));
+  process.exit(1);
+});
+//# sourceMappingURL=cli.js.map