cue-ai 0.5.0 → 0.7.0

package/src/commands/new.ts

@@ -181,7 +181,7 @@ async function createFromSeed(args: NewArgs): Promise<number> {
 }
 
 async function createEmpty(args: NewArgs): Promise<number> {
-  const description = `Custom soul profile ${args.name}`;
+  const description = `Custom cue profile ${args.name}`;
   const generated = {
     profile: { name: args.name!, description, agents: ["claude-code", "codex"] },
     yaml: [

package/src/commands/optimizer.ts

@@ -59,7 +59,17 @@ const KNOWN_CLIS = new Set([
   "aws", "gcloud", "az", "curl", "wget", "jq", "yq",
   "git", "gh", "glab", "npm", "npx", "bun", "pnpm", "yarn",
   "python", "pip", "uv", "uvx", "node", "deno",
-  "go", "cargo", "rustc", "gcc", "make", "cmake",
+  "go", "cargo", "rustc", "rustup", "clippy", "rustfmt", "gcc", "make", "cmake",
+  "cargo-watch", "cargo-nextest", "cargo-edit", "cargo-expand", "cargo-machete",
+  "cargo-outdated", "cargo-udeps", "cargo-audit", "cargo-deny", "cargo-geiger",
+  "cargo-vet", "cargo-crev", "cargo-flamegraph", "cargo-criterion", "cargo-bloat",
+  "bacon", "sccache", "wasm-pack", "trunk", "dioxus", "tauri",
+  "sqlx", "sea-orm-cli", "diesel", "mdbook", "cross", "just",
+  "tokio-console", "cargo-insta", "cargo-fuzz", "cargo-hack", "cargo-mutants",
+  "release-plz", "typos", "cargo-chef", "cargo-msrv", "cargo-readme",
+  "maturin", "napi", "uniffi-bindgen", "bindgen", "cbindgen",
+  "probe-rs", "cargo-embed", "cargo-binutils", "chisel",
+  "chromium", "chrome", "google-chrome", "microsoft-edge",
   "openssl", "ssh", "ncat", "netcat", "socat",
   "splunk", "elastic", "kibana", "logstash",
   "peepdf", "pdfid", "pdf-parser", "olevba", "oletools",
@@ -80,59 +90,92 @@ interface ProfileReport {
   clis: Map<string, string[]>; // cli → [skills that use it]
 }
 
-function extractCLIsFromSkill(skillSlug: string): string[] {
-  const clis: Set<string> = new Set();
+/**
+ * Pure parser: extract metadata (domain, tags, one-line description) from a
+ * SKILL.md's frontmatter. Used by marketplace discover to suggest which cue
+ * profile a repo would fit and what it's good for.
+ */
+export interface SkillMetadata {
+  description: string;  // one-line summary
+  domain: string;       // top-level category (e.g. "cybersecurity", "marketing")
+  tags: string[];       // free-form tag list
+  category: string;     // legacy alias for domain
+  name: string;
+}
 
-  // Try to read SKILL.md from resources or ~/.claude/skills
-  let content = "";
-  const paths = [
-    join(HOME_SKILLS, skillSlug, "SKILL.md"),
-    // Try all category subdirs in resources
-    ...(() => {
-      try {
-        return readdirSync(SKILLS_ROOT)
-          .map((cat) => join(SKILLS_ROOT, cat, skillSlug, "SKILL.md"));
-      } catch { return []; }
-    })(),
-  ];
+export function parseMetadataFromContent(content: string): SkillMetadata {
+  const empty: SkillMetadata = { description: "", domain: "", tags: [], category: "", name: "" };
+  if (!content) return empty;
+  const fm = content.match(/^---\n([\s\S]*?)\n---/);
+  if (!fm) return empty;
+  const yaml = fm[1]!;
 
-  for (const p of paths) {
-    try { content = readFileSync(p, "utf8"); break; } catch {}
+  const get = (key: string): string => {
+    const m = yaml.match(new RegExp(`^${key}:\\s*(.+?)\\s*$`, "m"));
+    return m ? m[1]!.replace(/^["'>|]\s*/, "").replace(/["']$/, "").trim() : "";
+  };
+
+  // Tags can be either inline `tags: [a, b]` or YAML list `tags:\n  - a\n  - b`.
+  let tags: string[] = [];
+  const inline = yaml.match(/^tags:\s*\[([^\]]*)\]/m);
+  if (inline) {
+    tags = inline[1]!.split(",").map((s) => s.trim().replace(/^["']|["']$/g, "")).filter(Boolean);
+  } else {
+    const block = yaml.match(/^tags:\s*\n((?:\s+-\s+.+\n?)+)/m);
+    if (block) {
+      tags = block[1]!.split("\n").map((l) => l.replace(/^\s*-\s*/, "").trim().replace(/^["']|["']$/g, "")).filter(Boolean);
+    }
   }
 
-  if (!content) {
-    return [...clis];
+  // Multi-line description: handle `description: >-\n  text\n  more text` and `description: |`.
+  let description = get("description");
+  if (!description) {
+    const multi = yaml.match(/^description:\s*[>|]-?\s*\n((?:\s+.+\n?)+)/m);
+    if (multi) description = multi[1]!.split("\n").map((l) => l.trim()).filter(Boolean).join(" ");
   }
 
+  return {
+    description: description.slice(0, 200),
+    domain: get("domain") || get("category"),
+    category: get("category") || get("domain"),
+    tags,
+    name: get("name"),
+  };
+}
+
+/**
+ * Pure parser: extract CLI names from a SKILL.md's raw text. Used by both
+ * disk-loading callers and network-fetched content (marketplace discover).
+ */
+export function parseCLIsFromContent(content: string): string[] {
+  const clis: Set<string> = new Set();
+  if (!content) return [];
+
   const fmMatch = content.match(/^---\n([\s\S]*?)\n---/);
   if (fmMatch) {
     const fm = fmMatch[1]!;
-
-    // Extract from allowed-tools (actual runtime CLI dependencies)
     const toolsMatch = fm.match(/^allowed-tools:\s*(.+)$/m);
     if (toolsMatch) {
       const tools = toolsMatch[1]!;
-      // Parse Bash(aws:*), Bash(curl:*), Bash(npx medusa ...) etc.
       const bashTools = tools.match(/Bash\(([^:)]+)/g);
       if (bashTools) {
         for (const bt of bashTools) {
-          const cli = bt.replace("Bash(", "").trim().split(" ")[0]!.toLowerCase();
-          if (cli && cli !== "bash") clis.add(cli);
+          // Preserve case — Linux binary names are case-sensitive (e.g. `Xvfb`,
+          // not `xvfb`). Lowercasing here used to surface false-negatives.
+          const cli = bt.replace("Bash(", "").trim().split(" ")[0]!;
+          if (cli && cli.toLowerCase() !== "bash") clis.add(cli);
         }
       }
     }
   }
 
-  // Extract from Prerequisites section (lists what needs to be installed)
   const prereqMatch = content.match(/## Prerequisites\n([\s\S]*?)(?=\n##|\n$)/);
   if (prereqMatch) {
     const prereqs = prereqMatch[1]!;
-    // Match lines like "- Nmap 7.90+ installed" or "- apktool (for ...)"
     const lines = prereqs.split("\n").filter((l) => l.startsWith("-") || l.startsWith("*"));
     for (const line of lines) {
       const lower = line.toLowerCase();
       for (const cli of KNOWN_CLIS) {
-        // Only match if CLI appears as a word boundary (not substring of another word)
         const re = new RegExp(`\\b${cli}\\b`);
         if (re.test(lower)) clis.add(cli);
       }
@@ -142,6 +185,27 @@ function extractCLIsFromSkill(skillSlug: string): string[] {
   return [...clis];
 }
 
+export function extractCLIsFromSkill(skillSlug: string): string[] {
+  // Try to read SKILL.md from resources or ~/.claude/skills
+  let content = "";
+  const paths = [
+    join(HOME_SKILLS, skillSlug, "SKILL.md"),
+    // Try all category subdirs in resources
+    ...(() => {
+      try {
+        return readdirSync(SKILLS_ROOT)
+          .map((cat) => join(SKILLS_ROOT, cat, skillSlug, "SKILL.md"));
+      } catch { return []; }
+    })(),
+  ];
+
+  for (const p of paths) {
+    try { content = readFileSync(p, "utf8"); break; } catch {}
+  }
+
+  return parseCLIsFromContent(content);
+}
+
 function parseProfile(name: string): ProfileReport {
   const yamlPath = join(PROFILES_DIR, name, "profile.yaml");
   let icon = "  ";
@@ -543,7 +607,7 @@ Examples:
     if (repoSkillMap.size > 0 || localCount > 0) {
       process.stdout.write(`│\n│   ┌─ 🐙 Sources\n`);
       if (localCount > 0) {
-        process.stdout.write(`│   │  📁 recodeee/cue (${localCount} skills)\n`);
+        process.stdout.write(`│   │  📁 opencue/cue (${localCount} skills)\n`);
       }
       for (const [repo, count] of [...repoSkillMap.entries()].sort((a, b) => b[1] - a[1])) {
         let repoIconStr = "";

package/src/commands/profile-draft-skill.test.ts

@@ -0,0 +1,96 @@
+/**
+ * Tests for `cue profile draft-skill` — covers the help path and the
+ * empty-corpus path. The Claude-call path is exercised through the underlying
+ * cluster-skills lib and skill-subset (already tested) — no point mocking
+ * claude --print here since the fail-open behavior is the contract that
+ * matters.
+ */
+
+import { describe, expect, test, beforeAll, afterAll } from "bun:test";
+import { mkdirSync, writeFileSync, rmSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+
+const TMP = join(tmpdir(), `cue-draft-skill-test-${Date.now()}-${Math.random().toString(36).slice(2)}`);
+const ORIG_XDG = process.env.XDG_CONFIG_HOME;
+
+beforeAll(() => {
+  mkdirSync(join(TMP, "cue"), { recursive: true });
+  process.env.XDG_CONFIG_HOME = TMP;
+});
+
+afterAll(() => {
+  if (ORIG_XDG === undefined) delete process.env.XDG_CONFIG_HOME;
+  else process.env.XDG_CONFIG_HOME = ORIG_XDG;
+  try { rmSync(TMP, { recursive: true, force: true }); } catch {}
+});
+
+function captureStdout<T>(fn: () => Promise<T>): Promise<{ result: T; out: string }> {
+  const orig = process.stdout.write.bind(process.stdout);
+  let buf = "";
+  (process.stdout as any).write = (chunk: string | Uint8Array) => { buf += String(chunk); return true; };
+  return fn()
+    .then(result => ({ result, out: buf }))
+    .finally(() => { (process.stdout as any).write = orig; });
+}
+
+describe("cue profile draft-skill", () => {
+  test("--help prints usage", async () => {
+    const { run } = await import("./profile-draft-skill");
+    const { result, out } = await captureStdout(() => run(["--help"]));
+    expect(result).toBe(0);
+    expect(out).toContain("cue profile draft-skill");
+    expect(out).toContain("first-prompts");
+    expect(out).toContain("--dry-run");
+  });
+
+  test("with no captured prompts → reports nothing to draft (non-error)", async () => {
+    const { run } = await import("./profile-draft-skill");
+    const { result, out } = await captureStdout(() => run([]));
+    expect(result).toBe(0);
+    expect(out).toContain("No first-prompts captured");
+  });
+
+  test("with synthetic captured prompts < minSize → reports insufficient data", async () => {
+    const dir = join(TMP, "cue", "first-prompts");
+    mkdirSync(dir, { recursive: true });
+    const ts = new Date().toISOString();
+    writeFileSync(join(dir, "aaa.json"), JSON.stringify({
+      ts, cwd: "/x", session_id: "s1", prompt: "fix the auth bug in the OAuth flow",
+    }));
+    writeFileSync(join(dir, "bbb.json"), JSON.stringify({
+      ts, cwd: "/y", session_id: "s2", prompt: "add unit tests for the rust crate",
+    }));
+    // Only 2 prompts — below the default minSize of 3.
+
+    const { run } = await import("./profile-draft-skill");
+    const { result, out } = await captureStdout(() => run([]));
+    expect(result).toBe(0);
+    expect(out).toContain("need ≥3");
+  });
+
+  test("with ≥3 similar captured prompts + --no-claude + --dry-run → reports clusters without writing", async () => {
+    const dir = join(TMP, "cue", "first-prompts");
+    mkdirSync(dir, { recursive: true });
+    const ts = new Date().toISOString();
+    // Three prompts sharing "deploy" + "coolify" → one cluster
+    const prompts = [
+      { id: "c", prompt: "deploy this app via coolify to my VPS" },
+      { id: "d", prompt: "deploy the new build to coolify production" },
+      { id: "e", prompt: "set up coolify deploy with environment variables" },
+    ];
+    for (const p of prompts) {
+      writeFileSync(join(dir, `${p.id}.json`), JSON.stringify({
+        ts, cwd: `/x-${p.id}`, session_id: `s-${p.id}`, prompt: p.prompt,
+      }));
+    }
+
+    const { run } = await import("./profile-draft-skill");
+    const { result, out } = await captureStdout(() => run(["--no-claude", "--dry-run"]));
+    expect(result).toBe(0);
+    expect(out).toContain("session pattern cluster");
+    expect(out).toContain("[dry-run]");
+    // The cluster term should be a content word from the shared prompts.
+    expect(out.toLowerCase()).toMatch(/coolify|deploy/);
+  });
+});

package/src/commands/profile-draft-skill.ts

@@ -0,0 +1,287 @@
+/**
+ * `cue profile draft-skill [<profile>]` — propose new SKILL.md files based on
+ * recurring session patterns.
+ *
+ * Data sources (all populated by hooks installed in profiles/core):
+ *   • ~/.config/cue/first-prompts/<cwd-hash>.json   first prompt per cwd
+ *   • ~/.config/cue/analytics.jsonl                 session start/end/skill_hit
+ *
+ * Pipeline:
+ *   1. For each captured first-prompt, look up the session's profile via
+ *      analytics (cwd/time-window match).
+ *   2. Cluster first-prompts by keyword similarity (reuses cluster-skills lib).
+ *   3. For each cluster of ≥3 similar sessions, ask Claude to draft a SKILL.md
+ *      describing the pattern. (Fail-open: cluster name used if claude is
+ *      unavailable.)
+ *   4. Write drafts under .cue-skill-drafts/<slug>/SKILL.md for review.
+ *
+ * Closes the learning loop opened by `cue profile evolve`: detect the gap,
+ * suggest the skill, let the user adopt it.
+ */
+
+import { spawnSync } from "node:child_process";
+import { existsSync, readFileSync, readdirSync, writeFileSync, mkdirSync } from "node:fs";
+import { join, resolve, dirname } from "node:path";
+import { fileURLToPath } from "node:url";
+import { homedir } from "node:os";
+
+import { clusterByKeywords, type ClusterItem } from "../lib/cluster-skills";
+import { readEvents, type SessionEvent } from "../lib/analytics";
+import { findRealClaudeBin } from "../lib/claude-binary";
+
+const REPO_ROOT = resolve(dirname(fileURLToPath(import.meta.url)), "..", "..");
+const FIRST_PROMPTS_DIR = join(
+  process.env.XDG_CONFIG_HOME ?? join(homedir(), ".config"),
+  "cue", "first-prompts",
+);
+
+interface CapturedPrompt {
+  ts: string;
+  cwd: string;
+  session_id: string;
+  prompt: string;
+}
+
+interface SessionPattern {
+  prompt: string;
+  cwd: string;
+  ts: string;
+  profile: string | null;
+}
+
+function loadCapturedPrompts(): CapturedPrompt[] {
+  if (!existsSync(FIRST_PROMPTS_DIR)) return [];
+  const out: CapturedPrompt[] = [];
+  for (const f of readdirSync(FIRST_PROMPTS_DIR)) {
+    if (!f.endsWith(".json")) continue;
+    try {
+      const doc = JSON.parse(readFileSync(join(FIRST_PROMPTS_DIR, f), "utf8")) as CapturedPrompt;
+      if (doc?.prompt && doc.cwd) out.push(doc);
+    } catch { /* skip malformed */ }
+  }
+  return out;
+}
+
+/**
+ * Match each captured prompt to a profile by finding the analytics `start`
+ * event with the same cwd whose ts is within 60s of the prompt's ts.
+ */
+function attributeProfiles(prompts: CapturedPrompt[], since: Date): SessionPattern[] {
+  const events = readEvents(since).filter(e => e.event === "start");
+  return prompts.map(p => {
+    const promptTs = new Date(p.ts).getTime();
+    let bestProfile: string | null = null;
+    let bestDelta = Infinity;
+    for (const e of events) {
+      if (e.cwd !== p.cwd) continue;
+      const delta = Math.abs(new Date(e.ts).getTime() - promptTs);
+      if (delta < bestDelta && delta < 60 * 60 * 1000) {
+        bestDelta = delta;
+        bestProfile = e.profile;
+      }
+    }
+    return { prompt: p.prompt, cwd: p.cwd, ts: p.ts, profile: bestProfile };
+  });
+}
+
+interface DraftedSkill {
+  slug: string;
+  description: string;
+  pattern: string;
+  examplePrompts: string[];
+}
+
+function draftSkillWithClaude(clusterTerm: string, examples: string[]): DraftedSkill {
+  const exemplars = examples.slice(0, 6).map(s => `- ${s.slice(0, 200)}`).join("\n");
+  const prompt = `You draft Claude Code SKILL.md files. Given a cluster of recurring user prompts that the agent currently has NO dedicated skill for, propose a new skill.
+
+Cluster keyword: "${clusterTerm}"
+Example prompts:
+${exemplars}
+
+Output EXACTLY this format (no other text):
+SLUG: <lowercase-kebab, 1-3 words>
+DESCRIPTION: <one line, under 100 chars, what this skill is for>
+PATTERN: <2-3 short sentences describing the workflow the skill should encode>`;
+
+  const tryOne = (bin: string) => spawnSync(bin, ["--print", "-p", prompt], {
+    encoding: "utf8", timeout: 30_000, env: { ...process.env, CUE_BYPASS: "1" },
+  });
+  let res = tryOne("claude");
+  if (res.status !== 0 || !res.stdout?.trim()) {
+    const fallback = findRealClaudeBin();
+    if (fallback) res = tryOne(fallback);
+  }
+
+  const fallbackSlug = clusterTerm.toLowerCase().replace(/\s+/g, "-").replace(/[^a-z0-9-]/g, "");
+  if (res.status !== 0 || !res.stdout?.trim()) {
+    return {
+      slug: fallbackSlug,
+      description: `Skill for sessions about "${clusterTerm}" (Claude unavailable — name from cluster term)`,
+      pattern: "Pattern detected from recurring user prompts. Fill this in by hand.",
+      examplePrompts: examples,
+    };
+  }
+  const out = res.stdout.trim();
+  const slugMatch = out.match(/SLUG:\s*([a-z0-9][a-z0-9-]*)/i);
+  const descMatch = out.match(/DESCRIPTION:\s*(.+)/i);
+  const patternMatch = out.match(/PATTERN:\s*([\s\S]+?)(?:\n[A-Z]+:|$)/i);
+  return {
+    slug: (slugMatch?.[1] ?? fallbackSlug).toLowerCase(),
+    description: (descMatch?.[1] ?? `Pattern around "${clusterTerm}"`).trim().slice(0, 120),
+    pattern: (patternMatch?.[1] ?? "").trim().slice(0, 500) || `Pattern: recurring prompts about ${clusterTerm}`,
+    examplePrompts: examples,
+  };
+}
+
+function buildSkillMd(draft: DraftedSkill): string {
+  return `---
+name: ${draft.slug}
+description: ${draft.description}
+domain: drafted
+tags: [drafted, from-sessions]
+---
+
+# ${draft.slug}
+
+> Drafted by \`cue profile draft-skill\` from ${draft.examplePrompts.length} recurring session prompts.
+> Review, refine, then move to \`resources/skills/skills/<category>/${draft.slug}/SKILL.md\` to adopt.
+
+## When to use
+
+${draft.description}
+
+## Pattern
+
+${draft.pattern}
+
+## Example prompts that triggered this draft
+
+${draft.examplePrompts.slice(0, 8).map(p => `- ${p}`).join("\n")}
+
+## TODO
+
+- [ ] Sharpen the description (current one is auto-generated).
+- [ ] Decide the right \`category/slug\` location.
+- [ ] Add concrete steps the agent should follow.
+- [ ] Pick \`allowed-tools\`, \`model\` overrides, etc., if needed.
+- [ ] Delete this TODO section before adopting.
+`;
+}
+
+// ---------------------------------------------------------------------------
+// Tiny ANSI helpers
+// ---------------------------------------------------------------------------
+
+const noColor = !process.stdout.isTTY || !!process.env.NO_COLOR;
+const bold = (s: string) => noColor ? s : `\x1b[1m${s}\x1b[0m`;
+const dim = (s: string) => noColor ? s : `\x1b[2m${s}\x1b[0m`;
+
+// ---------------------------------------------------------------------------
+// Entry point
+// ---------------------------------------------------------------------------
+
+export async function run(args: string[]): Promise<number> {
+  if (args.includes("-h") || args.includes("--help")) {
+    process.stdout.write(`cue profile draft-skill — propose new SKILL.md files from recurring session prompts
+
+Usage:
+  cue profile draft-skill                  All profiles
+  cue profile draft-skill <profile>        One profile
+
+Options:
+  --since <days>     Only consider prompts in the last N days (default: 90)
+  --min-size <n>     Cluster size threshold (default: 3)
+  --out <dir>        Output directory (default: .cue-skill-drafts/)
+  --no-claude        Skip naming step; use cluster term verbatim
+  --dry-run          Preview without writing files
+
+Data source: ~/.config/cue/first-prompts/  (populated by first-prompt-capture hook)
+             ~/.config/cue/analytics.jsonl (populated by cue launch + Stop hooks)
+
+Output: draft SKILL.md files under .cue-skill-drafts/<slug>/ for manual review.
+`);
+    return 0;
+  }
+
+  const sinceIdx = args.indexOf("--since");
+  const sinceDays = sinceIdx >= 0 ? parseInt(args[sinceIdx + 1] ?? "90", 10) : 90;
+  const minSizeIdx = args.indexOf("--min-size");
+  const minSize = minSizeIdx >= 0 ? parseInt(args[minSizeIdx + 1] ?? "3", 10) : 3;
+  const outIdx = args.indexOf("--out");
+  const outDir = outIdx >= 0 && args[outIdx + 1] ? args[outIdx + 1]!
+    : join(REPO_ROOT, ".cue-skill-drafts");
+  const dryRun = args.includes("--dry-run");
+  const noClaude = args.includes("--no-claude");
+
+  const positional = args.filter((a, i) =>
+    !a.startsWith("--") && (i === 0 || !["--since", "--min-size", "--out"].includes(args[i - 1] ?? "")),
+  );
+  const targetProfile = positional[0];
+
+  const since = new Date(Date.now() - sinceDays * 86_400_000);
+  const captured = loadCapturedPrompts();
+
+  if (captured.length === 0) {
+    process.stdout.write(`\n  ${dim("No first-prompts captured yet.")}\n`);
+    process.stdout.write(`  ${dim("Set CUE_SMART_SUBSET=1 in your shell and run a few cue launch sessions.")}\n`);
+    process.stdout.write(`  ${dim("The first-prompt-capture hook (in profiles/core) will populate ~/.config/cue/first-prompts/.")}\n\n`);
+    return 0;
+  }
+
+  let patterns = attributeProfiles(captured, since);
+  if (targetProfile) patterns = patterns.filter(p => p.profile === targetProfile);
+
+  if (patterns.length < minSize) {
+    process.stdout.write(`\n  Only ${patterns.length} captured prompt(s)${targetProfile ? ` for profile ${targetProfile}` : ""} — need ≥${minSize} to cluster.\n\n`);
+    return 0;
+  }
+
+  const items: ClusterItem[] = patterns.map((p, i) => ({
+    id: `prompt-${i}`,
+    text: p.prompt,
+  }));
+
+  const clusters = clusterByKeywords(items, { minSize, maxClusters: 6 });
+  if (clusters.length === 0) {
+    process.stdout.write(`\n  No clusters of ≥${minSize} similar prompts found among ${patterns.length} captures.\n`);
+    process.stdout.write(`  ${dim("Try a wider --since window once you've used cue more.")}\n\n`);
+    return 0;
+  }
+
+  process.stdout.write(`\n  ${bold(`Found ${clusters.length} session pattern cluster(s)`)} ${dim(`from ${patterns.length} captured prompts`)}\n\n`);
+
+  const drafts: DraftedSkill[] = [];
+  for (const cluster of clusters) {
+    const examples = cluster.items.map(i => patterns[parseInt(i.id.replace("prompt-", ""), 10)]!.prompt);
+    process.stdout.write(`  ▸ "${cluster.term}" (${cluster.items.length} sessions)\n`);
+    for (const ex of examples.slice(0, 3)) {
+      process.stdout.write(`      · ${ex.slice(0, 80)}${ex.length > 80 ? "…" : ""}\n`);
+    }
+    const draft = noClaude
+      ? {
+          slug: cluster.term.replace(/\s+/g, "-").toLowerCase(),
+          description: `Pattern around "${cluster.term}"`,
+          pattern: "Recurring user prompts share this keyword.",
+          examplePrompts: examples,
+        }
+      : draftSkillWithClaude(cluster.term, examples);
+    process.stdout.write(`      → drafting skill: ${bold(draft.slug)} — ${draft.description}\n\n`);
+    drafts.push(draft);
+  }
+
+  if (dryRun) {
+    process.stdout.write(`  [dry-run] Would write ${drafts.length} draft SKILL.md file(s) under ${outDir}\n`);
+    return 0;
+  }
+
+  mkdirSync(outDir, { recursive: true });
+  for (const draft of drafts) {
+    const skillDir = join(outDir, draft.slug);
+    mkdirSync(skillDir, { recursive: true });
+    writeFileSync(join(skillDir, "SKILL.md"), buildSkillMd(draft));
+  }
+  process.stdout.write(`  📝 Wrote ${drafts.length} draft SKILL.md file(s) to ${outDir}\n`);
+  process.stdout.write(`     Review, refine, then mv <draft>/ resources/skills/skills/<category>/<slug>/ to adopt.\n`);
+  return 0;
+}