@stackmemoryai/stackmemory 1.12.0 → 1.14.0

package/dist/src/cli/commands/company-os.js

@@ -0,0 +1,184 @@
+#!/usr/bin/env node
+import { fileURLToPath as __fileURLToPath } from 'url';
+import { dirname as __pathDirname } from 'path';
+const __filename = __fileURLToPath(import.meta.url);
+const __dirname = __pathDirname(__filename);
+import { Command } from "commander";
+import chalk from "chalk";
+import { readdirSync, readFileSync, existsSync } from "node:fs";
+import { join, extname } from "node:path";
+const WIKI_DIR = join(process.cwd(), "wiki");
+const WIKI_SOPS_DIR = join(WIKI_DIR, "sops");
+const PROSE_SPEC_PATH = join(
+  process.cwd(),
+  "docs",
+  "specs",
+  "COMPANY-OS-PROSE.md"
+);
+function collectSopFiles() {
+  const files = [];
+  const dirs = [WIKI_DIR];
+  if (existsSync(WIKI_SOPS_DIR)) dirs.push(WIKI_SOPS_DIR);
+  for (const dir of dirs) {
+    if (!existsSync(dir)) continue;
+    for (const entry of readdirSync(dir)) {
+      if (extname(entry) !== ".md") continue;
+      const filePath = join(dir, entry);
+      const content = readFileSync(filePath, "utf8");
+      const idMatch = content.match(/^# (SOP-\d+)/m);
+      const titleMatch = content.match(/^# SOP-\d+\s+(.+)/m);
+      const statusMatch = content.match(/\*\*Status:\*\*\s*(\w+)/);
+      const proseMatch = content.match(/Related PROSE Expectation.*\[(E\.\d+)/);
+      files.push({
+        id: idMatch?.[1] ?? entry.replace(".md", ""),
+        title: titleMatch?.[1] ?? entry,
+        status: statusMatch?.[1] ?? "Unknown",
+        proseId: proseMatch?.[1] ?? null,
+        path: filePath
+      });
+    }
+  }
+  return files;
+}
+function loadValidProseIds() {
+  const ids = /* @__PURE__ */ new Set();
+  if (!existsSync(PROSE_SPEC_PATH)) return ids;
+  const content = readFileSync(PROSE_SPEC_PATH, "utf8");
+  const headingRegex = /^###\s+(E\.\d+)\s+/gm;
+  let match;
+  while ((match = headingRegex.exec(content)) !== null) {
+    ids.add(match[1]);
+  }
+  return ids;
+}
+function validateSop(content) {
+  const errors = [];
+  const required = ["## Objective", "## Procedure", "## Verification"];
+  for (const section of required) {
+    if (!content.includes(section)) {
+      errors.push(`Missing section: ${section}`);
+    }
+  }
+  if (!content.match(/Related PROSE Expectation.*\[E\.\d+/)) {
+    errors.push("Missing or invalid Related PROSE Expectation");
+  }
+  if (!content.match(/^# SOP-\d+/m)) {
+    errors.push("Missing or invalid SOP ID (expected # SOP-NNN ...)");
+  }
+  return errors;
+}
+function createCompanyOsCommand() {
+  const cmd = new Command("company-os").alias("cos").description("Manage Company OS processes, SOPs, and audits");
+  cmd.command("list").description("List SOPs in the Company OS wiki").option("--json", "Output as JSON").action(() => {
+    const sops = collectSopFiles();
+    if (sops.length === 0) {
+      console.log(chalk.yellow("No SOPs found in wiki/"));
+      return;
+    }
+    console.log(chalk.cyan(`
+Company OS SOPs (${sops.length})
+`));
+    for (const sop of sops.sort((a, b) => a.id.localeCompare(b.id))) {
+      console.log(
+        `  ${chalk.bold(sop.id)}  ${chalk.white(sop.title.slice(0, 50))}`
+      );
+      console.log(
+        chalk.gray(
+          `    status: ${sop.status}  PROSE: ${sop.proseId ?? "none"}  ${sop.path}`
+        )
+      );
+    }
+    console.log();
+  });
+  cmd.command("validate").description("Validate all Company OS SOPs against the schema").option("--json", "Output as JSON").action(() => {
+    const sops = collectSopFiles();
+    const validProseIds = loadValidProseIds();
+    const results = [];
+    for (const sop of sops) {
+      const content = readFileSync(sop.path, "utf8");
+      const errors = validateSop(content);
+      if (sop.proseId && !validProseIds.has(sop.proseId)) {
+        errors.push(`Invalid PROSE Expectation: ${sop.proseId}`);
+      }
+      results.push({
+        id: sop.id,
+        path: sop.path,
+        valid: errors.length === 0,
+        errors
+      });
+    }
+    const validCount = results.filter((r) => r.valid).length;
+    if (results.every((r) => r.valid)) {
+      console.log(chalk.green(`
+\u2713 All ${validCount} SOPs are valid.
+`));
+    } else {
+      console.log(chalk.yellow(`
+SOP Validation Results
+`));
+      for (const result of results) {
+        const icon = result.valid ? chalk.green("\u2713") : chalk.red("\u2717");
+        console.log(`${icon} ${result.id}`);
+        for (const error of result.errors) {
+          console.log(chalk.gray(`    - ${error}`));
+        }
+      }
+      console.log(chalk.gray(`
+Valid: ${validCount} / ${results.length}
+`));
+      process.exitCode = 1;
+    }
+  });
+  cmd.command("audit <process>").description(
+    "Audit a Company OS process against its SOP (e.g. onboarding, pto)"
+  ).option("--json", "Output as JSON").action((processName) => {
+    const sops = collectSopFiles();
+    const normalized = processName.toLowerCase().replace(/\s+/g, "-");
+    const sop = sops.find((s) => {
+      const sopNormalized = s.title.toLowerCase().replace(/\s+/g, "-");
+      return sopNormalized.includes(normalized) || s.id.toLowerCase().includes(normalized);
+    });
+    if (!sop) {
+      console.log(
+        chalk.red(`No SOP found matching process "${processName}"`)
+      );
+      console.log(chalk.gray("Run: stackmemory company-os list"));
+      process.exitCode = 1;
+      return;
+    }
+    const content = readFileSync(sop.path, "utf8");
+    const errors = validateSop(content);
+    const validProseIds = loadValidProseIds();
+    if (sop.proseId && !validProseIds.has(sop.proseId)) {
+      errors.push(`Invalid PROSE Expectation: ${sop.proseId}`);
+    }
+    const compliant = errors.length === 0;
+    console.log(chalk.cyan(`
+Company OS Audit: ${sop.id} ${sop.title}
+`));
+    console.log(`  PROSE Expectation: ${sop.proseId ?? "none"}`);
+    console.log(
+      `  Status: ${compliant ? chalk.green("compliant") : chalk.red("non-compliant")}`
+    );
+    if (errors.length > 0) {
+      console.log(chalk.yellow("\n  Findings:"));
+      for (const error of errors) {
+        console.log(chalk.gray(`    - ${error}`));
+      }
+    } else {
+      console.log(
+        chalk.gray(
+          "\n  Note: This POC audit validates SOP structure only. A full audit would check operational data against the SOP."
+        )
+      );
+    }
+    console.log();
+    if (!compliant) {
+      process.exitCode = 1;
+    }
+  });
+  return cmd;
+}
+export {
+  createCompanyOsCommand
+};

package/dist/src/cli/commands/context.js

@@ -34,6 +34,7 @@ function createContextCommands() {
       const frameManager = new FrameManager(db, projectId, {
         skipContextBridge: true
       });
+      await frameManager.initialize();
       const depth = frameManager.getStackDepth();
       const activePath = frameManager.getActiveFramePath();
       console.log(`
@@ -101,6 +102,7 @@ function createContextCommands() {
       const frameManager = new FrameManager(db, projectId, {
         skipContextBridge: true
       });
+      await frameManager.initialize();
       const activePath = frameManager.getActiveFramePath();
       const parentId = activePath.length > 0 ? activePath[activePath.length - 1].frame_id : void 0;
       let inputs = {};
@@ -147,6 +149,7 @@ function createContextCommands() {
       const frameManager = new FrameManager(db, projectId, {
         skipContextBridge: true
       });
+      await frameManager.initialize();
       const activePath = frameManager.getActiveFramePath();
       if (activePath.length === 0) {
         console.log("\u{1F4DA} Stack is already empty.");
@@ -193,6 +196,7 @@ function createContextCommands() {
       const frameManager = new FrameManager(db, projectId, {
         skipContextBridge: true
       });
+      await frameManager.initialize();
       const activePath = frameManager.getActiveFramePath();
       if (activePath.length === 0) {
         console.log("\u26A0\uFE0F No active context frame. Creating one...");
@@ -248,6 +252,7 @@ function createContextCommands() {
       const frameManager = new FrameManager(db, projectId, {
         skipContextBridge: true
       });
+      await frameManager.initialize();
       if (options.list || action === "list") {
         const worktreeFrames = db.prepare(
           `

package/dist/src/cli/commands/operator.js

@@ -0,0 +1,127 @@
+import { fileURLToPath as __fileURLToPath } from 'url';
+import { dirname as __pathDirname } from 'path';
+const __filename = __fileURLToPath(import.meta.url);
+const __dirname = __pathDirname(__filename);
+import { Command } from "commander";
+import { existsSync, writeFileSync, mkdirSync } from "fs";
+import { join } from "path";
+import { homedir } from "os";
+import { OvernightRunner } from "../../features/operator/overnight-runner.js";
+import { OperatorLogger } from "../../features/operator/operator-logger.js";
+const OPERATOR_DIR = join(homedir(), ".stackmemory", "operator");
+const STOP_SIGNAL_FILE = join(OPERATOR_DIR, "stop-signal");
+const LOG_DIR = join(OPERATOR_DIR, "logs");
+function createOperatorCommands() {
+  const operator = new Command("operator").description(
+    "Autonomous Claude Code operator \u2014 drives sessions overnight via tmux"
+  );
+  operator.command("start").description(
+    "Start the operator \u2014 drains task queue using Claude Code in tmux"
+  ).requiredOption("-f, --file <path>", "Path to master-tasks.md").option("--cwd <dir>", "Working directory for Claude", process.cwd()).option("--mode <mode>", "Adapter: tmux | desktop | browser | auto", "auto").option("--poll <ms>", "Poll interval in ms", "2000").option("--stuck-timeout <ms>", "Stuck detection threshold in ms", "300000").option("--session <name>", "tmux session name", "operator").option("--model <model>", "Claude model override (inner agent)").option(
+    "--api-key <key>",
+    "Anthropic API key for LLM outer loop (or ANTHROPIC_API_KEY env)"
+  ).option(
+    "--llm-model <model>",
+    "LLM model for outer loop decisions",
+    "claude-haiku-4-5-20251001"
+  ).option("--no-auto-commit", "Disable auto-commit after each task").option(
+    "--max-restarts <n>",
+    "Max consecutive restarts before stopping",
+    "10"
+  ).option("--log-dir <dir>", "Log directory", LOG_DIR).action(async (opts) => {
+    if (!existsSync(opts.file)) {
+      process.stderr.write(`Error: task file not found: ${opts.file}
+`);
+      process.exit(1);
+    }
+    const apiKey = opts.apiKey ?? process.env.ANTHROPIC_API_KEY;
+    if (opts.mode === "desktop" && !apiKey) {
+      process.stderr.write(
+        "Error: desktop mode requires --api-key or ANTHROPIC_API_KEY for screenshot interpretation\n"
+      );
+      process.exit(1);
+    }
+    const config = {
+      taskFilePath: opts.file,
+      cwd: opts.cwd,
+      adapterMode: opts.mode,
+      pollIntervalMs: parseInt(opts.poll, 10),
+      stuckTimeoutMs: parseInt(opts.stuckTimeout, 10),
+      rateLimitBackoffMs: 6e4,
+      maxRateLimitBackoffMs: 9e5,
+      maxConsecutiveRestarts: parseInt(opts.maxRestarts, 10),
+      sessionName: opts.session,
+      model: opts.model,
+      anthropicApiKey: apiKey,
+      llmModel: opts.llmModel,
+      autoCommit: opts.autoCommit !== false,
+      logDir: opts.logDir
+    };
+    const runner = new OvernightRunner(config);
+    try {
+      await runner.run();
+    } catch (err) {
+      const msg = err instanceof Error ? err.message : String(err);
+      process.stderr.write(`Operator error: ${msg}
+`);
+      process.exit(1);
+    }
+  });
+  operator.command("stop").description("Signal the running operator to stop gracefully").option("--session <name>", "tmux session name", "operator").action((_opts) => {
+    mkdirSync(OPERATOR_DIR, { recursive: true });
+    writeFileSync(STOP_SIGNAL_FILE, String(Date.now()), "utf-8");
+    process.stderr.write(
+      "Stop signal sent. Operator will shut down after current tick.\n"
+    );
+  });
+  operator.command("status").description("Show current operator status from checkpoint").option("--json", "Output raw JSON").action((opts) => {
+    const checkpoint = OperatorLogger.readCheckpoint(OPERATOR_DIR);
+    if (!checkpoint) {
+      process.stderr.write(
+        "No operator checkpoint found. Is the operator running?\n"
+      );
+      process.exit(1);
+    }
+    if (opts.json) {
+      process.stdout.write(JSON.stringify(checkpoint, null, 2) + "\n");
+      return;
+    }
+    const runtime = Date.now() - checkpoint.startedAt;
+    const hrs = Math.floor(runtime / 36e5);
+    const mins = Math.floor(runtime % 36e5 / 6e4);
+    const lines = [
+      `State:       ${checkpoint.currentState}`,
+      `Active task: ${checkpoint.currentTaskId ?? "none"}`,
+      `Completed:   ${checkpoint.tasksCompleted.length}`,
+      `Blocked:     ${checkpoint.tasksBlocked.length}`,
+      `Runtime:     ${hrs}h ${mins}m`,
+      `Restarts:    ${checkpoint.totalRestarts}`,
+      `Approvals:   ${checkpoint.totalPermissionApprovals}`,
+      `Rate limits: ${checkpoint.totalRateLimitHits}`
+    ];
+    process.stdout.write(lines.join("\n") + "\n");
+  });
+  operator.command("attach").description(
+    "Attach to the operator tmux session for live observation (Ctrl-B d to detach)"
+  ).option("--session <name>", "tmux session name", "operator").action((opts) => {
+    try {
+      const {
+        SessionManager
+      } = require("../../features/operator/session-manager.js");
+      const mgr = new SessionManager({
+        sessionName: opts.session,
+        cwd: process.cwd()
+      });
+      mgr.attach();
+    } catch (err) {
+      const msg = err instanceof Error ? err.message : String(err);
+      process.stderr.write(`Attach error: ${msg}
+`);
+      process.exit(1);
+    }
+  });
+  return operator;
+}
+export {
+  createOperatorCommands
+};

package/dist/src/cli/commands/orchestrate.js

@@ -18,6 +18,7 @@ import Database from "better-sqlite3";
 import { logger } from "../../core/monitoring/logger.js";
 import { isProcessAlive } from "../../utils/process-cleanup.js";
 import { Conductor } from "./orchestrator.js";
+import { createVisionCommand } from "./vision.js";
 import {
   getAgentStatusDir,
   getOutcomesLogPath
@@ -668,6 +669,7 @@ function createConductorCommands() {
     }
     cmd.help();
   });
+  cmd.addCommand(createVisionCommand());
   cmd.command("capture").description("Capture workspace context after an agent run").requiredOption("--issue <id>", "Issue identifier (e.g., STA-476)").option("--workspace <path>", "Workspace directory", process.cwd()).option("--attempt <n>", "Attempt number", "1").action(async (options) => {
     const workspace = options.workspace;
     const issueId = options.issue;

package/dist/src/cli/commands/orchestrator.js

@@ -3,6 +3,7 @@ import { dirname as __pathDirname } from 'path';
 const __filename = __fileURLToPath(import.meta.url);
 const __dirname = __pathDirname(__filename);
 import { spawn, execSync } from "child_process";
+import { estimateTokens } from "../../core/cache/token-estimator.js";
 import {
   appendFileSync,
   existsSync,
@@ -1602,7 +1603,7 @@ class Conductor {
                 }
                 if (block.type === "text" && block.text) {
                   const text = block.text;
-                  run.tokensUsed += Math.ceil(text.length / 4);
+                  run.tokensUsed += estimateTokens(text);
                   turnTextParts.push(text);
                 }
               }
@@ -1738,7 +1739,7 @@ class Conductor {
               }
             }
             if (msg.method === "item/text" && params?.text) {
-              run.tokensUsed += Math.ceil(params.text.length / 4);
+              run.tokensUsed += estimateTokens(params.text);
             }
             if (run.toolCalls % 5 === 0 || phase) {
               this.writeAgentStatus(issue.identifier, run);

package/dist/src/cli/commands/patterns.js

@@ -0,0 +1,254 @@
+import { fileURLToPath as __fileURLToPath } from 'url';
+import { dirname as __pathDirname } from 'path';
+const __filename = __fileURLToPath(import.meta.url);
+const __dirname = __pathDirname(__filename);
+import { Command } from "commander";
+import Database from "better-sqlite3";
+import { existsSync, readFileSync, writeFileSync } from "fs";
+import { join } from "path";
+import { homedir } from "os";
+import { PatternStore } from "../../core/patterns/pattern-store.js";
+function getDb() {
+  const dbPath = join(homedir(), ".stackmemory", "stackmemory.db");
+  return new Database(dbPath);
+}
+function getStore() {
+  return new PatternStore(getDb());
+}
+function createPatternsCommand() {
+  const patterns = new Command("patterns").description(
+    "Manage learned behavioral patterns"
+  );
+  patterns.command("list").description("List learned patterns").option("-d, --domain <domain>", "Filter by domain").option("-s, --status <status>", "Filter by status", "active").option("--min-confidence <n>", "Minimum confidence", "0").option("--json", "Output JSON").action((opts) => {
+    const store = getStore();
+    const list = store.list({
+      domain: opts.domain,
+      status: opts.status,
+      minConfidence: parseFloat(opts.minConfidence)
+    });
+    if (opts.json) {
+      process.stdout.write(JSON.stringify(list, null, 2) + "\n");
+      return;
+    }
+    if (list.length === 0) {
+      process.stdout.write("No patterns found.\n");
+      return;
+    }
+    for (const p of list) {
+      const bar = confidenceBar(p.confidence);
+      const scope = p.scope === "global" ? "[global]" : "[project]";
+      process.stdout.write(
+        `${bar} ${p.confidence.toFixed(2)}  ${scope}  ${p.id}
+   trigger: ${p.trigger}
+   action:  ${p.action}
+   domain:  ${p.domain}  obs: ${p.observationCount}  status: ${p.status}
+
+`
+      );
+    }
+  });
+  patterns.command("learn").description("Manually record a pattern").requiredOption("-t, --trigger <text>", "When this happens").requiredOption("-a, --action <text>", "Do this").option("-d, --domain <domain>", "Pattern domain", "general").option("--scope <scope>", "project or global", "project").option("--id <id>", "Pattern ID (auto-generated if omitted)").action((opts) => {
+    const store = getStore();
+    const id = opts.id ?? slugify(`${opts.domain}-${opts.trigger.slice(0, 40)}`);
+    const input = {
+      id,
+      domain: opts.domain,
+      trigger: opts.trigger,
+      action: opts.action,
+      scope: opts.scope,
+      source: "manual",
+      confidence: 0.5
+    };
+    const pattern = store.create(input);
+    process.stdout.write(
+      `Pattern created: ${pattern.id} (confidence: ${pattern.confidence})
+`
+    );
+  });
+  patterns.command("stats").description("Show pattern statistics").option("--json", "Output JSON").action((opts) => {
+    const store = getStore();
+    const s = store.stats();
+    if (opts.json) {
+      process.stdout.write(JSON.stringify(s, null, 2) + "\n");
+      return;
+    }
+    const lines = [
+      `Total patterns: ${s.total}`,
+      `Avg confidence: ${s.avgConfidence.toFixed(2)}`,
+      "",
+      "By domain:",
+      ...Object.entries(s.byDomain).map(([d, n]) => `  ${d}: ${n}`),
+      "",
+      "By status:",
+      ...Object.entries(s.byStatus).map(([d, n]) => `  ${d}: ${n}`)
+    ];
+    if (s.topPatterns.length > 0) {
+      lines.push("", "Top patterns:");
+      for (const p of s.topPatterns) {
+        lines.push(
+          `  ${confidenceBar(p.confidence)} ${p.confidence.toFixed(2)}  ${p.id}`
+        );
+      }
+    }
+    process.stdout.write(lines.join("\n") + "\n");
+  });
+  patterns.command("prune").description("Remove old pending patterns").option("--days <n>", "Max age in days", "30").action((opts) => {
+    const store = getStore();
+    const removed = store.prune(parseInt(opts.days, 10));
+    process.stdout.write(
+      `Pruned ${removed} pending patterns older than ${opts.days} days.
+`
+    );
+  });
+  patterns.command("export").description("Export patterns to JSON file").option("-o, --output <path>", "Output file", "patterns-export.json").option("--min-confidence <n>", "Minimum confidence", "0.3").action((opts) => {
+    const store = getStore();
+    const list = store.list({
+      status: "active",
+      minConfidence: parseFloat(opts.minConfidence)
+    });
+    writeFileSync(opts.output, JSON.stringify(list, null, 2), "utf-8");
+    process.stdout.write(
+      `Exported ${list.length} patterns to ${opts.output}
+`
+    );
+  });
+  patterns.command("import").description("Import patterns from JSON file").argument("<file>", "JSON file to import").option("--scope <scope>", "Override scope", "project").action((file, opts) => {
+    if (!existsSync(file)) {
+      process.stderr.write(`File not found: ${file}
+`);
+      process.exit(1);
+    }
+    const store = getStore();
+    const data = JSON.parse(readFileSync(file, "utf-8"));
+    const patterns2 = Array.isArray(data) ? data : [data];
+    let imported = 0;
+    for (const p of patterns2) {
+      if (!p.id || !p.trigger || !p.action) continue;
+      const existing = store.get(p.id);
+      if (existing) {
+        store.reinforce(p.id, "imported");
+      } else {
+        store.create({
+          id: p.id,
+          domain: p.domain ?? "general",
+          trigger: p.trigger,
+          action: p.action,
+          evidence: p.evidence ?? ["imported"],
+          scope: opts.scope ?? p.scope ?? "project",
+          source: "imported",
+          confidence: p.confidence ?? 0.5
+        });
+      }
+      imported++;
+    }
+    process.stdout.write(`Imported ${imported} patterns.
+`);
+  });
+  patterns.command("promote").description("Promote a project-scoped pattern to global").argument("[id]", "Pattern ID to promote (omit for auto-candidates)").option("--dry-run", "Show candidates without promoting").action((id, opts) => {
+    const store = getStore();
+    if (id) {
+      const pattern = store.get(id);
+      if (!pattern) {
+        process.stderr.write(`Pattern not found: ${id}
+`);
+        process.exit(1);
+      }
+      if (pattern.scope === "global") {
+        process.stdout.write(`Already global: ${id}
+`);
+        return;
+      }
+      if (!opts.dryRun) {
+        store.promote(id);
+        process.stdout.write(`Promoted to global: ${id}
+`);
+      } else {
+        process.stdout.write(
+          `Would promote: ${id} (confidence: ${pattern.confidence.toFixed(2)})
+`
+        );
+      }
+      return;
+    }
+    const candidates = store.promotionCandidates(0.7);
+    if (candidates.length === 0) {
+      process.stdout.write(
+        "No promotion candidates found (need 0.7+ confidence in 2+ projects).\n"
+      );
+      return;
+    }
+    for (const c of candidates) {
+      const action = opts.dryRun ? "candidate" : "promoted";
+      if (!opts.dryRun) store.promote(c.id);
+      process.stdout.write(
+        `${action}: ${c.id} (${c.confidence.toFixed(2)}, project: ${c.projectId})
+`
+      );
+    }
+    if (opts.dryRun) {
+      process.stdout.write(
+        `
+${candidates.length} candidates. Run without --dry-run to promote.
+`
+      );
+    }
+  });
+  patterns.command("projects").description("List projects with pattern counts").option("--json", "Output JSON").action((opts) => {
+    const store = getStore();
+    const projs = store.projects();
+    if (opts.json) {
+      process.stdout.write(JSON.stringify(projs, null, 2) + "\n");
+      return;
+    }
+    if (projs.length === 0) {
+      process.stdout.write("No project-scoped patterns found.\n");
+      return;
+    }
+    for (const p of projs) {
+      process.stdout.write(
+        `${p.projectId}  ${p.count} patterns  avg confidence: ${p.avgConfidence.toFixed(2)}
+`
+      );
+    }
+  });
+  patterns.command("evolve").description("Analyze pattern clusters and suggest evolved structures").option("--min-cluster <n>", "Minimum cluster size", "2").option("--json", "Output JSON").action((opts) => {
+    const store = getStore();
+    const clusters = store.findClusters(parseInt(opts.minCluster, 10));
+    if (opts.json) {
+      process.stdout.write(JSON.stringify(clusters, null, 2) + "\n");
+      return;
+    }
+    if (clusters.length === 0) {
+      process.stdout.write(
+        "No pattern clusters found. Need 2+ active patterns in a domain.\n"
+      );
+      return;
+    }
+    for (const cluster of clusters) {
+      const avgConf = cluster.patterns.reduce((s, p) => s + p.confidence, 0) / cluster.patterns.length;
+      const label = avgConf >= 0.8 ? "SKILL candidate" : avgConf >= 0.6 ? "command candidate" : "cluster";
+      process.stdout.write(
+        `
+[${cluster.domain}] ${cluster.patterns.length} patterns \u2014 ${label} (avg: ${avgConf.toFixed(2)})
+`
+      );
+      for (const p of cluster.patterns) {
+        process.stdout.write(
+          `  ${confidenceBar(p.confidence)} ${p.id}: ${p.trigger}
+`
+        );
+      }
+    }
+  });
+  return patterns;
+}
+function confidenceBar(confidence) {
+  const filled = Math.round(confidence * 10);
+  return "\u2588".repeat(filled) + "\u2591".repeat(10 - filled);
+}
+function slugify(s) {
+  return s.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-|-$/g, "");
+}
+export {
+  createPatternsCommand
+};