@sniper.ai/cli 2.0.0 → 3.0.0

package/dist/index.js

@@ -2,7 +2,7 @@
 
 // src/index.ts
 import { createRequire as createRequire2 } from "module";
-import { defineCommand as defineCommand9, runMain } from "citty";
+import { defineCommand as defineCommand14, runMain } from "citty";
 
 // src/commands/init.ts
 import { defineCommand } from "citty";
@@ -13,15 +13,17 @@ import { readFile, writeFile, access } from "fs/promises";
 import { join, dirname } from "path";
 import { createRequire } from "module";
 import YAML from "yaml";
-var CONFIG_PATH = ".sniper/config.yaml";
-async function sniperConfigExists(cwd) {
-  try {
-    await access(join(cwd, CONFIG_PATH));
-    return true;
-  } catch {
-    return false;
-  }
+function isV2Config(data) {
+  if (!data || typeof data !== "object") return false;
+  const cfg = data;
+  return "review_gates" in cfg || "agent_teams" in cfg || "domain_packs" in cfg;
+}
+function isV3Config(data) {
+  if (!data || typeof data !== "object") return false;
+  const cfg = data;
+  return "agents" in cfg && "routing" in cfg && "visibility" in cfg;
 }
+var CONFIG_PATH = ".sniper/config.yaml";
 function assertField(obj, section, field, type) {
   const val = obj[field];
   if (typeof val !== type) {
@@ -30,18 +32,12 @@ function assertField(obj, section, field, type) {
     );
   }
 }
-function validateConfig(data) {
+function validateV3Config(data) {
   if (!data || typeof data !== "object") {
     throw new Error("Invalid config.yaml: expected an object");
   }
   const cfg = data;
-  for (const key of [
-    "project",
-    "stack",
-    "state",
-    "review_gates",
-    "agent_teams"
-  ]) {
+  for (const key of ["project", "agents", "routing", "cost", "stack"]) {
     if (!cfg[key] || typeof cfg[key] !== "object") {
       throw new Error(`Invalid config.yaml: missing "${key}" section`);
     }
@@ -49,37 +45,72 @@ function validateConfig(data) {
   const project = cfg.project;
   assertField(project, "project", "name", "string");
   assertField(project, "project", "type", "string");
+  assertField(project, "project", "description", "string");
+  const agents = cfg.agents;
+  assertField(agents, "agents", "max_teammates", "number");
   const stack = cfg.stack;
   assertField(stack, "stack", "language", "string");
-  const agentTeams = cfg.agent_teams;
-  assertField(agentTeams, "agent_teams", "max_teammates", "number");
-  const state = cfg.state;
-  if (state.artifacts !== void 0 && typeof state.artifacts !== "object") {
-    throw new Error(
-      'Invalid config.yaml: "state.artifacts" must be an object'
-    );
+  assertField(stack, "stack", "package_manager", "string");
+  if (!cfg.plugins || !Array.isArray(cfg.plugins)) {
+    cfg.plugins = [];
+  }
+  if (!cfg.visibility || typeof cfg.visibility !== "object") {
+    cfg.visibility = {
+      live_status: true,
+      checkpoints: true,
+      cost_tracking: true,
+      auto_retro: true
+    };
   }
-  if (!Array.isArray(cfg.domain_packs)) {
-    cfg.domain_packs = [];
+  if (!cfg.ownership || typeof cfg.ownership !== "object") {
+    cfg.ownership = {};
   }
   return data;
 }
+async function sniperConfigExists(cwd) {
+  try {
+    await access(join(cwd, CONFIG_PATH));
+    return true;
+  } catch {
+    return false;
+  }
+}
 async function readConfig(cwd) {
   const raw = await readFile(join(cwd, CONFIG_PATH), "utf-8");
-  return validateConfig(YAML.parse(raw));
+  const data = YAML.parse(raw);
+  if (isV2Config(data)) {
+    throw new Error(
+      'This project uses SNIPER v2 config. Run "sniper migrate" to upgrade to v3.'
+    );
+  }
+  return validateV3Config(data);
+}
+async function readRawConfig(cwd) {
+  const raw = await readFile(join(cwd, CONFIG_PATH), "utf-8");
+  return YAML.parse(raw);
 }
 async function writeConfig(cwd, config) {
   const content = YAML.stringify(config, { lineWidth: 0 });
   await writeFile(join(cwd, CONFIG_PATH), content, "utf-8");
 }
+var DEFAULT_BUDGETS = Object.freeze({
+  full: 2e6,
+  feature: 8e5,
+  patch: 2e5,
+  ingest: 1e6,
+  explore: 5e5,
+  refactor: 6e5,
+  hotfix: 1e5
+});
 function getCorePath() {
   const require3 = createRequire(import.meta.url);
   try {
     const corePkgPath = require3.resolve("@sniper.ai/core/package.json");
-    return join(dirname(corePkgPath), "framework");
-  } catch {
+    return dirname(corePkgPath);
+  } catch (err) {
     throw new Error(
-      '@sniper.ai/core is not installed. Run "pnpm add -D @sniper.ai/core" first.'
+      '@sniper.ai/core is not installed. Run "pnpm add -D @sniper.ai/core" first.',
+      { cause: err }
     );
   }
 }
@@ -95,119 +126,239 @@ import {
 } from "fs/promises";
 import { join as join2 } from "path";
 import YAML2 from "yaml";
-var FRAMEWORK_DIRS = [
-  "personas",
-  "teams",
-  "templates",
-  "checklists",
-  "workflows",
-  "spawn-prompts"
-];
+function assertSafeName(name, kind) {
+  if (!/^[a-z][a-z0-9-]*$/.test(name)) {
+    throw new Error(
+      `Invalid ${kind} name "${name}": must start with a letter and contain only lowercase letters, digits, and hyphens`
+    );
+  }
+}
 async function ensureDir(dir) {
   await mkdir(dir, { recursive: true });
 }
-async function fileExists(p9) {
+async function fileExists(p14) {
   try {
-    await access2(p9);
+    await access2(p14);
     return true;
   } catch {
     return false;
   }
 }
+async function composeMixin(basePath, mixinPaths) {
+  let content = await readFile2(basePath, "utf-8");
+  for (const mixinPath of mixinPaths) {
+    const mixin = await readFile2(mixinPath, "utf-8");
+    content += "\n\n---\n\n" + mixin;
+  }
+  return content;
+}
+function mergeHooks(base, ...sources) {
+  const result = { ...base };
+  if (!result.hooks || typeof result.hooks !== "object") {
+    result.hooks = {};
+  }
+  const hooks = result.hooks;
+  for (const source of sources) {
+    const sourceHooks = source.hooks || {};
+    for (const [event, entries] of Object.entries(sourceHooks)) {
+      if (!Array.isArray(entries)) continue;
+      if (!hooks[event]) hooks[event] = [];
+      for (const entry of entries) {
+        const desc = entry.description;
+        const existing = hooks[event].find(
+          (h) => h.description === desc
+        );
+        if (!existing) {
+          hooks[event].push(entry);
+        }
+      }
+    }
+  }
+  return result;
+}
 async function scaffoldProject(cwd, config, options = {}) {
   const corePath = getCorePath();
   const sniperDir = join2(cwd, ".sniper");
-  const log9 = [];
+  const claudeDir = join2(cwd, ".claude");
+  const log14 = [];
   const isUpdate = options.update === true;
   await ensureDir(sniperDir);
-  for (const dir of FRAMEWORK_DIRS) {
-    const src = join2(corePath, dir);
-    const dest = join2(sniperDir, dir);
-    await cp(src, dest, { recursive: true, force: true });
-    log9.push(`Copied ${dir}/`);
-  }
-  await ensureDir(join2(sniperDir, "domain-packs"));
-  const memoryDir = join2(sniperDir, "memory");
-  await ensureDir(memoryDir);
-  await ensureDir(join2(memoryDir, "retros"));
-  const memoryFiles = {
-    "conventions.yaml": "conventions: []\n",
-    "anti-patterns.yaml": "anti_patterns: []\n",
-    "decisions.yaml": "decisions: []\n",
-    "estimates.yaml": "calibration:\n  velocity_factor: 1.0\n  common_underestimates: []\n  last_updated: null\n  sprints_analyzed: 0\n"
-  };
-  for (const [filename, content] of Object.entries(memoryFiles)) {
-    const filePath = join2(memoryDir, filename);
-    if (!isUpdate || !await fileExists(filePath)) {
-      await writeFile2(filePath, content, "utf-8");
-    }
+  for (const sub of [
+    "checkpoints",
+    "gates",
+    "retros",
+    "self-reviews",
+    "protocols",
+    "knowledge",
+    "memory/signals"
+  ]) {
+    await ensureDir(join2(sniperDir, sub));
+  }
+  const checklistsSrc = join2(corePath, "checklists");
+  const checklistsDest = join2(sniperDir, "checklists");
+  await cp(checklistsSrc, checklistsDest, { recursive: true, force: true });
+  log14.push("Copied checklists/");
+  const manifestTemplate = join2(corePath, "templates", "knowledge-manifest.yaml");
+  const manifestDest = join2(sniperDir, "knowledge", "manifest.yaml");
+  if (await fileExists(manifestTemplate) && !await fileExists(manifestDest)) {
+    await cp(manifestTemplate, manifestDest);
+    log14.push("Created .sniper/knowledge/manifest.yaml");
   }
-  log9.push("Created memory/ directory");
   if (!isUpdate) {
     const configContent = YAML2.stringify(config, { lineWidth: 0 });
     await writeFile2(join2(sniperDir, "config.yaml"), configContent, "utf-8");
-    log9.push("Created config.yaml");
+    log14.push("Created .sniper/config.yaml");
+  }
+  await ensureDir(claudeDir);
+  await ensureDir(join2(claudeDir, "agents"));
+  const agentsSrc = join2(corePath, "agents");
+  for (const agentName of config.agents.base) {
+    assertSafeName(agentName, "agent");
+    const srcFile = join2(agentsSrc, `${agentName}.md`);
+    if (!await fileExists(srcFile)) continue;
+    const mixinNames = config.agents.mixins[agentName] || [];
+    if (mixinNames.length > 0) {
+      const mixinPaths = mixinNames.map((m) => {
+        assertSafeName(m, "mixin");
+        return join2(corePath, "personas", "cognitive", `${m}.md`);
+      });
+      const composed = await composeMixin(srcFile, mixinPaths);
+      await writeFile2(join2(claudeDir, "agents", `${agentName}.md`), composed, "utf-8");
+    } else {
+      await cp(srcFile, join2(claudeDir, "agents", `${agentName}.md`), { force: true });
+    }
+  }
+  log14.push("Scaffolded .claude/agents/");
+  const skillsSrc = join2(corePath, "skills");
+  const commandsDest = join2(claudeDir, "commands");
+  await ensureDir(commandsDest);
+  if (await fileExists(skillsSrc)) {
+    const skillDirs = await readdir(skillsSrc);
+    for (const skillDir of skillDirs) {
+      const skillFile = join2(skillsSrc, skillDir, "SKILL.md");
+      if (await fileExists(skillFile)) {
+        await cp(skillFile, join2(commandsDest, `${skillDir}.md`), { force: true });
+      }
+    }
+  }
+  log14.push("Copied skills to .claude/commands/");
+  const settingsPath = join2(claudeDir, "settings.json");
+  let settings = {};
+  if (isUpdate && await fileExists(settingsPath)) {
+    const raw = await readFile2(settingsPath, "utf-8");
+    try {
+      settings = JSON.parse(raw);
+    } catch {
+      log14.push("Warning: .claude/settings.json was invalid JSON; starting with empty settings");
+      settings = {};
+    }
+  }
+  const coreHooksPath = join2(corePath, "hooks", "settings-hooks.json");
+  if (await fileExists(coreHooksPath)) {
+    const coreHooks = JSON.parse(await readFile2(coreHooksPath, "utf-8"));
+    settings = mergeHooks(settings, coreHooks);
   }
+  if (!settings.env || typeof settings.env !== "object") {
+    settings.env = {};
+  }
+  settings.env.CLAUDE_CODE_EXPERIMENTAL_AGENT_TEAMS = "1";
+  const settingsExisted = isUpdate && await fileExists(settingsPath);
+  await writeFile2(settingsPath, JSON.stringify(settings, null, 2), "utf-8");
+  log14.push(settingsExisted ? "Updated .claude/settings.json hooks" : "Created .claude/settings.json");
   if (!isUpdate || !await fileExists(join2(cwd, "CLAUDE.md"))) {
     const claudeTemplate = await readFile2(
       join2(corePath, "claude-md.template"),
       "utf-8"
     );
-    await writeFile2(join2(cwd, "CLAUDE.md"), claudeTemplate, "utf-8");
-    log9.push("Created CLAUDE.md");
-  } else {
-    log9.push("Skipped CLAUDE.md (preserved user customizations)");
-  }
-  const settingsDir = join2(cwd, ".claude");
-  await ensureDir(settingsDir);
-  if (!isUpdate || !await fileExists(join2(settingsDir, "settings.json"))) {
-    const settingsTemplate = await readFile2(
-      join2(corePath, "settings.template.json"),
-      "utf-8"
-    );
-    await writeFile2(
-      join2(settingsDir, "settings.json"),
-      settingsTemplate,
-      "utf-8"
-    );
-    log9.push("Created .claude/settings.json");
+    const claudeMd = claudeTemplate.replace("{{PROJECT_NAME}}", config.project.name).replace("{{CUSTOM_INSTRUCTIONS}}", "");
+    await writeFile2(join2(cwd, "CLAUDE.md"), claudeMd, "utf-8");
+    log14.push("Created CLAUDE.md");
   } else {
-    log9.push("Skipped .claude/settings.json (preserved user customizations)");
+    log14.push("Skipped CLAUDE.md (preserved user customizations)");
   }
-  const commandsSrc = join2(corePath, "commands");
-  const commandsDest = join2(settingsDir, "commands");
-  await cp(commandsSrc, commandsDest, { recursive: true, force: true });
-  log9.push("Copied skills to .claude/commands/");
   if (!isUpdate) {
-    for (const sub of ["epics", "stories", "reviews"]) {
-      const dir = join2(cwd, "docs", sub);
-      await ensureDir(dir);
-      try {
-        const entries = await readdir(dir);
-        if (entries.length === 0) {
-          await writeFile2(join2(dir, ".gitkeep"), "", "utf-8");
-        }
-      } catch {
-        await writeFile2(join2(dir, ".gitkeep"), "", "utf-8");
-      }
-    }
-    log9.push("Created docs/ directory");
+    await ensureDir(join2(cwd, "docs"));
+    log14.push("Created docs/");
+  }
+  return log14;
+}
+
+// src/fs-utils.ts
+import { mkdir as mkdir2, access as access3 } from "fs/promises";
+async function ensureDir2(dir) {
+  await mkdir2(dir, { recursive: true });
+}
+async function pathExists(path) {
+  try {
+    await access3(path);
+    return true;
+  } catch {
+    return false;
   }
-  return log9;
 }
 
 // src/commands/init.ts
+import { join as join3, basename } from "path";
+async function detectLanguage(cwd) {
+  const checks = [
+    [["tsconfig.json"], "typescript"],
+    [["pyproject.toml", "requirements.txt"], "python"],
+    [["go.mod"], "go"],
+    [["Cargo.toml"], "rust"],
+    [["pom.xml", "build.gradle"], "java"],
+    [["package.json"], "javascript"]
+  ];
+  for (const [files, lang] of checks) {
+    for (const file of files) {
+      if (await pathExists(join3(cwd, file))) return lang;
+    }
+  }
+  return null;
+}
+async function detectPackageManager(cwd) {
+  const checks = [
+    ["pnpm-lock.yaml", "pnpm"],
+    ["yarn.lock", "yarn"],
+    ["bun.lockb", "bun"],
+    ["package-lock.json", "npm"],
+    ["uv.lock", "uv"],
+    ["poetry.lock", "poetry"]
+  ];
+  for (const [file, pm] of checks) {
+    if (await pathExists(join3(cwd, file))) return pm;
+  }
+  return "npm";
+}
+async function detectTestRunner(cwd) {
+  const checks = [
+    [["vitest.config.ts", "vitest.config.js", "vitest.config.mts"], "vitest"],
+    [["jest.config.ts", "jest.config.js", "jest.config.mjs"], "jest"],
+    [["pytest.ini", "conftest.py", "pyproject.toml"], "pytest"]
+  ];
+  for (const [files, runner] of checks) {
+    for (const file of files) {
+      if (await pathExists(join3(cwd, file))) return runner;
+    }
+  }
+  return null;
+}
 var initCommand = defineCommand({
   meta: {
     name: "init",
-    description: "Initialize a new SNIPER-enabled project"
+    description: "Initialize SNIPER v3 in a project"
   },
   run: async () => {
     const cwd = process.cwd();
-    p.intro("SNIPER \u2014 Project Initialization");
+    p.intro("SNIPER v3 \u2014 Project Initialization");
     if (await sniperConfigExists(cwd)) {
+      const raw = await readRawConfig(cwd);
+      if (isV2Config(raw)) {
+        p.log.warning(
+          'Detected SNIPER v2 config. Run "sniper migrate" to upgrade, or reinitialize.'
+        );
+      }
       const overwrite = await p.confirm({
-        message: "SNIPER is already initialized in this directory. Reinitialize?",
+        message: "SNIPER is already initialized. Reinitialize?",
         initialValue: false
       });
       if (p.isCancel(overwrite) || !overwrite) {
@@ -215,9 +366,14 @@ var initCommand = defineCommand({
         process.exit(0);
       }
     }
+    const detectedLang = await detectLanguage(cwd);
+    const detectedPM = await detectPackageManager(cwd);
+    const detectedTestRunner = await detectTestRunner(cwd);
+    const dirName = basename(cwd);
     const projectName = await p.text({
       message: "Project name:",
-      placeholder: "my-app",
+      placeholder: dirName,
+      initialValue: dirName,
       validate: (v) => v.length === 0 ? "Project name is required" : void 0
     });
     if (p.isCancel(projectName)) {
@@ -240,17 +396,19 @@ var initCommand = defineCommand({
       process.exit(0);
     }
     const description = await p.text({
-      message: "One-line project description:",
-      placeholder: "A brief description of your project"
+      message: "One-line description:",
+      placeholder: "A brief description"
     });
     if (p.isCancel(description)) {
       p.cancel("Aborted.");
       process.exit(0);
     }
     const language = await p.select({
-      message: "Primary language:",
+      message: `Primary language${detectedLang ? ` (detected: ${detectedLang})` : ""}:`,
+      initialValue: detectedLang || "typescript",
       options: [
         { value: "typescript", label: "TypeScript" },
+        { value: "javascript", label: "JavaScript" },
         { value: "python", label: "Python" },
         { value: "go", label: "Go" },
         { value: "rust", label: "Rust" },
@@ -261,63 +419,6 @@ var initCommand = defineCommand({
       p.cancel("Aborted.");
       process.exit(0);
     }
-    const frontend = await p.select({
-      message: "Frontend framework:",
-      options: [
-        { value: "react", label: "React" },
-        { value: "nextjs", label: "Next.js" },
-        { value: "vue", label: "Vue" },
-        { value: "svelte", label: "Svelte" },
-        { value: "none", label: "None" }
-      ]
-    });
-    if (p.isCancel(frontend)) {
-      p.cancel("Aborted.");
-      process.exit(0);
-    }
-    const backend = await p.select({
-      message: "Backend framework:",
-      options: [
-        { value: "node-express", label: "Node + Express" },
-        { value: "node-fastify", label: "Node + Fastify" },
-        { value: "django", label: "Django" },
-        { value: "fastapi", label: "FastAPI" },
-        { value: "gin", label: "Go Gin" },
-        { value: "none", label: "None" }
-      ]
-    });
-    if (p.isCancel(backend)) {
-      p.cancel("Aborted.");
-      process.exit(0);
-    }
-    const database = await p.select({
-      message: "Primary database:",
-      options: [
-        { value: "postgresql", label: "PostgreSQL" },
-        { value: "mysql", label: "MySQL" },
-        { value: "mongodb", label: "MongoDB" },
-        { value: "sqlite", label: "SQLite" },
-        { value: "none", label: "None" }
-      ]
-    });
-    if (p.isCancel(database)) {
-      p.cancel("Aborted.");
-      process.exit(0);
-    }
-    const infrastructure = await p.select({
-      message: "Cloud infrastructure:",
-      options: [
-        { value: "aws", label: "AWS" },
-        { value: "gcp", label: "Google Cloud" },
-        { value: "azure", label: "Azure" },
-        { value: "vercel", label: "Vercel" },
-        { value: "none", label: "None / Self-hosted" }
-      ]
-    });
-    if (p.isCancel(infrastructure)) {
-      p.cancel("Aborted.");
-      process.exit(0);
-    }
     const maxTeammates = await p.text({
       message: "Max concurrent agent teammates:",
       placeholder: "5",
@@ -338,82 +439,83 @@ var initCommand = defineCommand({
         type: projectType,
         description: description || ""
       },
-      stack: {
-        language,
-        frontend: frontend === "none" ? null : frontend,
-        backend: backend === "none" ? null : backend,
-        database: database === "none" ? null : database,
-        cache: null,
-        infrastructure: infrastructure === "none" ? null : infrastructure,
-        test_runner: null,
-        package_manager: "pnpm"
-      },
-      review_gates: {
-        after_discover: "flexible",
-        after_plan: "strict",
-        after_solve: "flexible",
-        after_sprint: "strict"
-      },
-      agent_teams: {
+      agents: {
         max_teammates: parseInt(maxTeammates, 10),
-        default_model: "sonnet",
-        planning_model: "opus",
-        delegate_mode: true,
         plan_approval: true,
-        coordination_timeout: 30
+        coordination_timeout: 30,
+        base: [
+          "lead-orchestrator",
+          "analyst",
+          "architect",
+          "product-manager",
+          "backend-dev",
+          "frontend-dev",
+          "qa-engineer",
+          "code-reviewer",
+          "gate-reviewer",
+          "retro-analyst"
+        ],
+        mixins: {}
+      },
+      routing: {
+        auto_detect: {
+          patch_max_files: 5,
+          feature_max_files: 20
+        },
+        default: "feature",
+        budgets: { ...DEFAULT_BUDGETS }
+      },
+      cost: {
+        warn_threshold: 0.7,
+        soft_cap: 0.9,
+        hard_cap: 1
+      },
+      review: {
+        multi_model: false,
+        models: [],
+        require_consensus: true
       },
-      domain_packs: [],
       ownership: {
-        backend: [
-          "src/backend/",
-          "src/api/",
-          "src/services/",
-          "src/db/",
-          "src/workers/"
-        ],
-        frontend: [
-          "src/frontend/",
-          "src/components/",
-          "src/hooks/",
-          "src/styles/",
-          "src/pages/"
-        ],
-        infrastructure: [
-          "docker/",
-          ".github/",
-          "infra/",
-          "terraform/",
-          "scripts/"
-        ],
+        backend: ["src/backend/", "src/api/", "src/services/", "src/db/"],
+        frontend: ["src/frontend/", "src/components/", "src/hooks/", "src/styles/", "src/pages/"],
+        infrastructure: ["docker/", ".github/", "infra/", "scripts/"],
         tests: ["tests/", "__tests__/", "*.test.*", "*.spec.*"],
-        ai: ["src/ai/", "src/ml/", "src/pipeline/"],
         docs: ["docs/"]
       },
-      state: {
-        current_phase: null,
-        phase_history: [],
-        current_sprint: 0,
-        artifacts: {
-          brief: null,
-          prd: null,
-          architecture: null,
-          ux_spec: null,
-          security: null,
-          epics: null,
-          stories: null
+      stack: {
+        language,
+        frontend: null,
+        backend: null,
+        database: null,
+        infrastructure: null,
+        test_runner: detectedTestRunner,
+        package_manager: detectedPM,
+        commands: {
+          test: "",
+          lint: "",
+          typecheck: "",
+          build: ""
         }
+      },
+      plugins: [],
+      triggers: [],
+      visibility: {
+        live_status: true,
+        checkpoints: true,
+        cost_tracking: true,
+        auto_retro: true
       }
     };
     const s = p.spinner();
-    s.start("Scaffolding SNIPER project...");
+    s.start("Scaffolding SNIPER v3 project...");
     try {
-      const log9 = await scaffoldProject(cwd, config);
+      const log14 = await scaffoldProject(cwd, config);
       s.stop("Done!");
-      for (const entry of log9) {
+      for (const entry of log14) {
         p.log.success(entry);
       }
       p.outro(
-        'SNIPER initialized. Run "sniper add-pack <name>" to add domain packs.'
+        'SNIPER v3 initialized. Run "/sniper-flow" to start your first protocol.'
       );
     } catch (err) {
       s.stop("Failed!");
@@ -426,1302 +528,2682 @@ var initCommand = defineCommand({
 // src/commands/status.ts
 import { defineCommand as defineCommand2 } from "citty";
 import * as p2 from "@clack/prompts";
-var ARTIFACT_ICONS = {
-  approved: "\u2713",
-  draft: "\u25D0"
-};
+import { readFile as readFile3 } from "fs/promises";
+import { join as join4 } from "path";
+import YAML3 from "yaml";
 var statusCommand = defineCommand2({
   meta: {
     name: "status",
-    description: "Show SNIPER lifecycle status and artifact state"
+    description: "Show SNIPER v3 status and protocol progress"
   },
   run: async () => {
     const cwd = process.cwd();
     if (!await sniperConfigExists(cwd)) {
       p2.log.error(
-        'SNIPER is not initialized in this directory. Run "sniper init" first.'
+        'SNIPER is not initialized. Run "sniper init" first.'
       );
       process.exit(1);
     }
     const config = await readConfig(cwd);
-    p2.intro("SNIPER Status");
+    p2.intro("SNIPER v3 Status");
     p2.log.info(
       `Project: ${config.project.name || "(unnamed)"} (${config.project.type})`
     );
-    p2.log.info(
-      `Phase: ${config.state.current_phase || "not started"}`
-    );
-    if (config.state.current_sprint > 0) {
-      p2.log.info(`Sprint: ${config.state.current_sprint}`);
-    }
-    p2.log.step("Artifacts:");
-    const artifacts = config.state.artifacts;
-    for (const [name, status] of Object.entries(artifacts)) {
-      const icon = status ? ARTIFACT_ICONS[status] || "?" : "\u25CB";
-      const label = status || "\u2014";
-      console.log(`  ${icon} ${name.padEnd(16)} ${label}`);
-    }
-    if (config.domain_packs && config.domain_packs.length > 0) {
-      const packNames = config.domain_packs.map((pk) => pk.name).join(", ");
-      p2.log.info(`
-Packs: ${packNames}`);
-    }
-    const stack = config.stack;
     const stackParts = [
-      stack.language,
-      stack.frontend,
-      stack.backend,
-      stack.database,
-      stack.infrastructure
+      config.stack.language,
+      config.stack.frontend,
+      config.stack.backend,
+      config.stack.database,
+      config.stack.infrastructure
     ].filter(Boolean);
     p2.log.info(`Stack: ${stackParts.join(", ")}`);
+    p2.log.info(`Agents: ${config.agents.base.length} configured, max ${config.agents.max_teammates} concurrent`);
+    if (config.plugins.length > 0) {
+      const pluginNames = config.plugins.map((pk) => pk.name).join(", ");
+      p2.log.info(`Plugins: ${pluginNames}`);
+    }
+    const statusPath = join4(cwd, ".sniper", "live-status.yaml");
+    if (await pathExists(statusPath)) {
+      const raw = await readFile3(statusPath, "utf-8");
+      const liveStatus = YAML3.parse(raw);
+      if (liveStatus && liveStatus.protocol) {
+        p2.log.step("Active Protocol:");
+        console.log(`  Protocol: ${liveStatus.protocol}`);
+        console.log(`  Status:   ${liveStatus.status}`);
+        if (liveStatus.current_phase) {
+          console.log(`  Phase:    ${liveStatus.current_phase}`);
+        }
+        if (Array.isArray(liveStatus.phases)) {
+          for (const phase of liveStatus.phases) {
+            const icon = phase.status === "completed" ? "\u2713" : phase.status === "in_progress" ? "\u25B6" : phase.status === "failed" ? "\u2717" : "\u25CB";
+            console.log(`  ${icon} ${phase.name.padEnd(16)} ${phase.status}`);
+          }
+        }
+        if (liveStatus.cost && typeof liveStatus.cost.percent === "number" && typeof liveStatus.cost.tokens_used === "number" && typeof liveStatus.cost.budget === "number") {
+          const pct = Math.max(0, Math.min(100, Math.round(liveStatus.cost.percent * 100)));
+          const bar = "=".repeat(Math.floor(pct / 5)) + "-".repeat(20 - Math.floor(pct / 5));
+          console.log(`
+  Cost: ${(liveStatus.cost.tokens_used / 1e3).toFixed(0)}K / ${(liveStatus.cost.budget / 1e3).toFixed(0)}K tokens (${pct}%)`);
+          console.log(`  [${bar}] ${pct}%`);
+        }
+        if (liveStatus.next_action) {
+          console.log(`
+  Next: ${liveStatus.next_action}`);
+        }
+      }
+    } else {
+      p2.log.info("No active protocol. Run /sniper-flow to start.");
+    }
+    p2.log.step("Protocol Routing:");
+    console.log(`  Default: ${config.routing.default}`);
+    console.log(`  Budgets: full=${(config.routing.budgets.full / 1e6).toFixed(1)}M, feature=${(config.routing.budgets.feature / 1e3).toFixed(0)}K, patch=${(config.routing.budgets.patch / 1e3).toFixed(0)}K`);
+    const velocityPath = join4(cwd, ".sniper", "memory", "velocity.yaml");
+    if (await pathExists(velocityPath)) {
+      const velRaw = await readFile3(velocityPath, "utf-8");
+      const velocity = YAML3.parse(velRaw);
+      if (velocity && velocity.calibrated_budgets && Object.keys(velocity.calibrated_budgets).length > 0) {
+        p2.log.step("Velocity (calibrated budgets):");
+        for (const [protocol, budget] of Object.entries(velocity.calibrated_budgets)) {
+          const configured = config.routing.budgets[protocol];
+          const calibrated = budget;
+          const avg = velocity.rolling_averages?.[protocol];
+          const avgStr = avg ? `${(avg / 1e3).toFixed(0)}K avg` : "";
+          const trend = configured && calibrated < configured * 0.9 ? "\u2193" : calibrated > configured * 1.1 ? "\u2191" : "\u2192";
+          console.log(`  ${protocol}: ${avgStr} (calibrated: ${(calibrated / 1e3).toFixed(0)}K, configured: ${configured ? (configured / 1e3).toFixed(0) + "K" : "N/A"}) ${trend}`);
+        }
+      }
+    }
     p2.outro("");
   }
 });
 
-// src/commands/add-pack.ts
+// src/commands/migrate.ts
 import { defineCommand as defineCommand3 } from "citty";
 import * as p3 from "@clack/prompts";
+import { writeFile as writeFile3, readFile as readFile4 } from "fs/promises";
+import { join as join5 } from "path";
+function migrateV2ToV3(v2) {
+  return {
+    project: {
+      name: v2.project.name,
+      type: v2.project.type,
+      description: v2.project.description || ""
+    },
+    agents: {
+      max_teammates: v2.agent_teams?.max_teammates || 5,
+      plan_approval: v2.agent_teams?.plan_approval ?? true,
+      coordination_timeout: v2.agent_teams?.coordination_timeout || 30,
+      base: [
+        "lead-orchestrator",
+        "analyst",
+        "architect",
+        "product-manager",
+        "backend-dev",
+        "frontend-dev",
+        "qa-engineer",
+        "code-reviewer",
+        "gate-reviewer",
+        "retro-analyst"
+      ],
+      mixins: {}
+    },
+    routing: {
+      auto_detect: {
+        patch_max_files: 5,
+        feature_max_files: 20
+      },
+      default: "feature",
+      budgets: { ...DEFAULT_BUDGETS }
+    },
+    cost: {
+      warn_threshold: 0.7,
+      soft_cap: 0.9,
+      hard_cap: 1
+    },
+    review: {
+      multi_model: false,
+      models: [],
+      require_consensus: true
+    },
+    ownership: v2.ownership || {},
+    stack: {
+      language: v2.stack?.language || "",
+      frontend: v2.stack?.frontend || null,
+      backend: v2.stack?.backend || null,
+      database: v2.stack?.database || null,
+      infrastructure: v2.stack?.infrastructure || null,
+      test_runner: v2.stack?.test_runner || null,
+      package_manager: v2.stack?.package_manager || "npm",
+      commands: {
+        test: v2.stack?.commands?.test || "",
+        lint: v2.stack?.commands?.lint || "",
+        typecheck: v2.stack?.commands?.typecheck || "",
+        build: v2.stack?.commands?.build || ""
+      }
+    },
+    plugins: [],
+    triggers: [],
+    visibility: {
+      live_status: true,
+      checkpoints: true,
+      cost_tracking: true,
+      auto_retro: true
+    }
+  };
+}
+var migrateCommand = defineCommand3({
+  meta: {
+    name: "migrate",
+    description: "Migrate SNIPER v2 config to v3"
+  },
+  run: async () => {
+    const cwd = process.cwd();
+    p3.intro("SNIPER v2 \u2192 v3 Migration");
+    if (!await sniperConfigExists(cwd)) {
+      p3.log.error(
+        'No SNIPER config found. Run "sniper init" to initialize a new project.'
+      );
+      process.exit(1);
+    }
+    const raw = await readRawConfig(cwd);
+    if (isV3Config(raw)) {
+      p3.log.info("This project already uses SNIPER v3 config. No migration needed.");
+      p3.outro("");
+      return;
+    }
+    if (!isV2Config(raw)) {
+      p3.log.error("Unrecognized config format. Cannot migrate.");
+      process.exit(1);
+    }
+    const v2Config = raw;
+    p3.log.info(`Migrating project: ${v2Config.project.name}`);
+    const backupPath = join5(cwd, ".sniper", "config.v2.yaml");
+    const backupContent = await readFile4(join5(cwd, ".sniper", "config.yaml"), "utf-8");
+    await writeFile3(backupPath, backupContent, "utf-8");
+    p3.log.success("Backed up v2 config to .sniper/config.v2.yaml");
+    const v3Config = migrateV2ToV3(v2Config);
+    p3.log.step("Migration changes:");
+    console.log("  - review_gates \u2192 protocol-based gates");
+    console.log("  - agent_teams \u2192 agents (with base roster + mixins)");
+    console.log("  - domain_packs \u2192 plugins");
+    console.log("  - state tracking \u2192 checkpoint files");
+    console.log("  + routing (auto protocol selection)");
+    console.log("  + cost enforcement");
+    console.log("  + visibility settings");
+    const confirm6 = await p3.confirm({
+      message: "Apply migration and re-scaffold?",
+      initialValue: true
+    });
+    if (p3.isCancel(confirm6) || !confirm6) {
+      p3.cancel("Aborted. v2 config preserved.");
+      process.exit(0);
+    }
+    const s = p3.spinner();
+    s.start("Re-scaffolding with v3 structure...");
+    try {
+      const log14 = await scaffoldProject(cwd, v3Config, { update: true });
+      await writeConfig(cwd, v3Config);
+      s.stop("Done!");
+      p3.log.success("Wrote v3 config");
+      for (const entry of log14) {
+        p3.log.success(entry);
+      }
+      p3.log.warning(
+        "Review .sniper/config.yaml to configure stack commands (test, lint, build) and agent mixins."
+      );
+      p3.outro("Migration complete.");
+    } catch (err) {
+      s.stop("Failed!");
+      p3.log.error(`Migration failed: ${err}`);
+      p3.log.info("Your v2 config is preserved at .sniper/config.yaml (backup also at .sniper/config.v2.yaml)");
+      process.exit(1);
+    }
+  }
+});
 
-// src/pack-manager.ts
+// src/commands/plugin.ts
+import { defineCommand as defineCommand4 } from "citty";
+import * as p4 from "@clack/prompts";
+
+// src/plugin-manager.ts
 import {
   cp as cp2,
-  rm,
   readdir as readdir2,
-  readFile as readFile3,
-  stat,
-  access as access3,
-  mkdir as mkdir2
+  readFile as readFile5,
+  access as access4,
+  mkdir as mkdir3
 } from "fs/promises";
-import { join as join3, resolve, sep } from "path";
+import { join as join6, resolve as resolve2, sep as sep2 } from "path";
 import { execFileSync } from "child_process";
-import YAML3 from "yaml";
+import YAML4 from "yaml";
+function getPackageManagerCommand(config) {
+  return config?.stack?.package_manager || "pnpm";
+}
 function assertSafePath(base, untrusted) {
-  const full = resolve(base, untrusted);
-  const safeBase = resolve(base) + sep;
-  if (!full.startsWith(safeBase) && full !== resolve(base)) {
+  const full = resolve2(base, untrusted);
+  const safeBase = resolve2(base) + sep2;
+  if (!full.startsWith(safeBase) && full !== resolve2(base)) {
     throw new Error(
       `Invalid name: path traversal detected in "${untrusted}"`
     );
   }
   return full;
 }
-async function pathExists(p9) {
+async function pathExists2(p14) {
   try {
-    await access3(p9);
+    await access4(p14);
     return true;
   } catch {
     return false;
   }
 }
-async function readJson(p9) {
-  const raw = await readFile3(p9, "utf-8");
-  return JSON.parse(raw);
+function getPackageDir(pkgName, cwd) {
+  return join6(cwd, "node_modules", ...pkgName.split("/"));
 }
-function getPackDir(pkgName, cwd) {
-  const nmPath = join3(cwd, "node_modules", ...pkgName.split("/"));
-  return nmPath;
+async function validatePluginYaml(pluginPath) {
+  const raw = await readFile5(pluginPath, "utf-8");
+  const manifest = YAML4.parse(raw);
+  if (!manifest.name || typeof manifest.name !== "string") {
+    throw new Error("Plugin manifest missing required 'name' field");
+  }
+  if (!manifest.version || typeof manifest.version !== "string") {
+    throw new Error("Plugin manifest missing required 'version' field");
+  }
+  return manifest;
 }
-async function installPack(packageName, cwd) {
-  execFileSync("pnpm", ["add", "-D", packageName], { cwd, stdio: "pipe" });
-  const pkgDir = getPackDir(packageName, cwd);
-  const pkgJson = await readJson(join3(pkgDir, "package.json"));
-  if (!pkgJson.sniper || pkgJson.sniper.type !== "domain-pack") {
-    execFileSync("pnpm", ["remove", packageName], { cwd, stdio: "pipe" });
+async function installPlugin(packageName, cwd) {
+  let projectConfig;
+  try {
+    projectConfig = await readConfig(cwd);
+  } catch {
+  }
+  const pm = getPackageManagerCommand(projectConfig);
+  execFileSync(pm, ["add", "-D", packageName], { cwd, stdio: "pipe" });
+  const pkgDir = getPackageDir(packageName, cwd);
+  const pkgJsonRaw = await readFile5(join6(pkgDir, "package.json"), "utf-8");
+  const pkgJson = JSON.parse(pkgJsonRaw);
+  const validTypes = ["plugin", "agent", "mixin", "pack"];
+  if (!pkgJson.sniper || !validTypes.includes(pkgJson.sniper.type)) {
+    execFileSync(pm, ["remove", packageName], { cwd, stdio: "pipe" });
     throw new Error(
-      `${packageName} is not a valid SNIPER domain pack (missing sniper.type: "domain-pack")`
+      `${packageName} is not a valid SNIPER package (missing sniper.type: one of ${validTypes.join(", ")})`
     );
   }
-  const shortName = packageName.replace(/^@[^/]+\/pack-/, "");
-  const domainPacksDir = join3(cwd, ".sniper", "domain-packs");
-  const packDest = assertSafePath(domainPacksDir, shortName);
-  const packSrc = assertSafePath(pkgDir, pkgJson.sniper.packDir);
-  await mkdir2(packDest, { recursive: true });
-  await cp2(packSrc, packDest, { recursive: true, force: true });
-  const contextDir = join3(packDest, "context");
-  let contextCount = 0;
-  if (await pathExists(contextDir)) {
-    const files = await readdir2(contextDir);
-    contextCount = files.filter((f) => f.endsWith(".md")).length;
+  const sniperType = pkgJson.sniper.type;
+  if (sniperType === "agent") {
+    const agentsDir = join6(cwd, ".claude", "agents");
+    await mkdir3(agentsDir, { recursive: true });
+    const files = await readdir2(pkgDir);
+    for (const file of files) {
+      if (file.endsWith(".md") && file !== "README.md") {
+        const src = assertSafePath(pkgDir, file);
+        await cp2(src, join6(agentsDir, file), { force: true });
+      }
+    }
+    const config2 = await readConfig(cwd);
+    if (!config2.plugins.some((p14) => p14.name === pkgJson.name)) {
+      config2.plugins.push({ name: pkgJson.name, package: packageName });
+    }
+    await writeConfig(cwd, config2);
+    return { name: pkgJson.name, package: packageName, version: pkgJson.version };
+  }
+  if (sniperType === "mixin") {
+    const mixinsDir = join6(cwd, ".claude", "personas", "cognitive");
+    await mkdir3(mixinsDir, { recursive: true });
+    const files = await readdir2(pkgDir);
+    for (const file of files) {
+      if (file.endsWith(".md") && file !== "README.md") {
+        const src = assertSafePath(pkgDir, file);
+        await cp2(src, join6(mixinsDir, file), { force: true });
+      }
+    }
+    const config2 = await readConfig(cwd);
+    if (!config2.plugins.some((p14) => p14.name === pkgJson.name)) {
+      config2.plugins.push({ name: pkgJson.name, package: packageName });
+    }
+    await writeConfig(cwd, config2);
+    return { name: pkgJson.name, package: packageName, version: pkgJson.version };
+  }
+  if (sniperType === "pack") {
+    const sniperDir = join6(cwd, ".sniper");
+    const claudeDir = join6(cwd, ".claude");
+    const contentRoot = pkgJson.sniper?.packDir ? join6(pkgDir, pkgJson.sniper.packDir) : pkgDir;
+    if (pkgJson.sniper?.packDir) {
+      assertSafePath(pkgDir, pkgJson.sniper.packDir);
+    }
+    const knowledgeDir = join6(contentRoot, "knowledge");
+    if (await pathExists2(knowledgeDir)) {
+      const dest = join6(sniperDir, "knowledge");
+      await mkdir3(dest, { recursive: true });
+      await cp2(knowledgeDir, dest, { recursive: true, force: true });
+    }
+    const personasDir = join6(contentRoot, "personas");
+    if (await pathExists2(personasDir)) {
+      const dest = join6(claudeDir, "personas", "cognitive");
+      await mkdir3(dest, { recursive: true });
+      await cp2(personasDir, dest, { recursive: true, force: true });
+    }
+    const checklistsDir = join6(contentRoot, "checklists");
+    if (await pathExists2(checklistsDir)) {
+      const dest = join6(sniperDir, "checklists");
+      await mkdir3(dest, { recursive: true });
+      await cp2(checklistsDir, dest, { recursive: true, force: true });
+    }
+    const templatesDir = join6(contentRoot, "templates");
+    if (await pathExists2(templatesDir)) {
+      const dest = join6(sniperDir, "templates");
+      await mkdir3(dest, { recursive: true });
+      await cp2(templatesDir, dest, { recursive: true, force: true });
+    }
+    const config2 = await readConfig(cwd);
+    if (!config2.plugins.some((p14) => p14.name === pkgJson.name)) {
+      config2.plugins.push({ name: pkgJson.name, package: packageName });
+    }
+    await writeConfig(cwd, config2);
+    return { name: pkgJson.name, package: packageName, version: pkgJson.version };
+  }
+  const pluginYamlPath = join6(pkgDir, "plugin.yaml");
+  if (!await pathExists2(pluginYamlPath)) {
+    execFileSync(pm, ["remove", packageName], { cwd, stdio: "pipe" });
+    throw new Error(`${packageName} is missing plugin.yaml`);
+  }
+  const manifest = await validatePluginYaml(pluginYamlPath);
+  if (manifest.agent_mixins) {
+    const mixinsDir = join6(cwd, ".claude", "personas", "cognitive");
+    await mkdir3(mixinsDir, { recursive: true });
+    for (const [, mixinPaths] of Object.entries(manifest.agent_mixins)) {
+      for (const mixinPath of mixinPaths) {
+        const src = assertSafePath(pkgDir, mixinPath);
+        const parts = mixinPath.split("/");
+        const filename = parts[parts.length - 1];
+        const dest = join6(mixinsDir, filename);
+        await cp2(src, dest, { force: true });
+      }
+    }
   }
   const config = await readConfig(cwd);
-  if (!config.domain_packs) config.domain_packs = [];
-  if (!config.domain_packs.some((p9) => p9.name === shortName)) {
-    config.domain_packs.push({ name: shortName, package: packageName });
+  if (!config.plugins.some((p14) => p14.name === manifest.name)) {
+    config.plugins.push({ name: manifest.name, package: packageName });
   }
   await writeConfig(cwd, config);
   return {
-    name: shortName,
+    name: manifest.name,
     package: packageName,
-    version: pkgJson.version,
-    contextCount
+    version: manifest.version
   };
 }
-async function removePack(packName, cwd) {
+async function removePlugin(pluginName, cwd) {
   const config = await readConfig(cwd);
-  const packEntry = (config.domain_packs || []).find(
-    (p9) => p9.name === packName
-  );
-  const packageName = packEntry?.package || `@sniper.ai/pack-${packName}`;
-  const domainPacksDir = join3(cwd, ".sniper", "domain-packs");
-  const packDir = assertSafePath(domainPacksDir, packName);
-  if (await pathExists(packDir)) {
-    await rm(packDir, { recursive: true, force: true });
-  }
+  const entry = config.plugins.find((p14) => p14.name === pluginName);
+  const packageName = entry?.package || `@sniper.ai/plugin-${pluginName}`;
+  const pm = getPackageManagerCommand(config);
   try {
-    execFileSync("pnpm", ["remove", packageName], { cwd, stdio: "pipe" });
+    execFileSync(pm, ["remove", packageName], { cwd, stdio: "pipe" });
   } catch {
   }
-  config.domain_packs = (config.domain_packs || []).filter(
-    (p9) => p9.name !== packName
-  );
+  config.plugins = config.plugins.filter((p14) => p14.name !== pluginName);
   await writeConfig(cwd, config);
 }
-async function listInstalledPacks(cwd) {
-  const packsDir = join3(cwd, ".sniper", "domain-packs");
-  if (!await pathExists(packsDir)) return [];
-  const entries = await readdir2(packsDir);
-  const packs = [];
-  for (const entry of entries) {
-    const entryPath = join3(packsDir, entry);
-    const s = await stat(entryPath);
-    if (!s.isDirectory()) continue;
-    const packYaml = join3(entryPath, "pack.yaml");
-    if (await pathExists(packYaml)) {
-      const raw = await readFile3(packYaml, "utf-8");
-      const parsed = YAML3.parse(raw);
-      packs.push({ name: entry, version: parsed.version || "unknown" });
-    } else {
-      packs.push({ name: entry, version: "unknown" });
-    }
-  }
-  return packs;
-}
-async function searchRegistryPacks() {
-  try {
-    const result = execFileSync(
-      "npm",
-      ["search", "@sniper.ai/pack-", "--json"],
-      { encoding: "utf-8", timeout: 1e4, stdio: ["pipe", "pipe", "pipe"] }
-    ).toString();
-    const packages = JSON.parse(result);
-    return packages.map(
-      (pkg) => ({
-        name: pkg.name,
-        version: pkg.version,
-        description: pkg.description || ""
-      })
-    );
-  } catch {
-    return [];
-  }
+async function listPlugins(cwd) {
+  const config = await readConfig(cwd);
+  return config.plugins;
 }
 
-// src/commands/add-pack.ts
-var addPackCommand = defineCommand3({
+// src/commands/plugin.ts
+var installSubcommand = defineCommand4({
   meta: {
-    name: "add-pack",
-    description: "Add a domain pack to the current project"
+    name: "install",
+    description: "Install a SNIPER plugin"
   },
   args: {
-    name: {
+    package: {
       type: "positional",
-      description: "Pack name or full npm package name (e.g., sales-dialer or @sniper.ai/pack-sales-dialer)",
+      description: "Plugin package name (e.g. @sniper.ai/plugin-typescript)",
       required: true
     }
   },
   run: async ({ args }) => {
     const cwd = process.cwd();
     if (!await sniperConfigExists(cwd)) {
-      p3.log.error(
-        'SNIPER is not initialized in this directory. Run "sniper init" first.'
-      );
+      p4.log.error('SNIPER is not initialized. Run "sniper init" first.');
       process.exit(1);
     }
-    let packageName = args.name;
-    if (!packageName.startsWith("@") && !packageName.includes("/")) {
-      packageName = `@sniper.ai/pack-${packageName}`;
-    }
-    const s = p3.spinner();
-    s.start(`Installing ${packageName}...`);
+    const s = p4.spinner();
+    s.start(`Installing ${args.package}...`);
     try {
-      const result = await installPack(packageName, cwd);
+      const result = await installPlugin(args.package, cwd);
       s.stop("Done!");
-      p3.log.success(`Installed ${result.package}@${result.version}`);
-      p3.log.success(
-        `Copied pack to .sniper/domain-packs/${result.name}/`
-      );
-      p3.log.success("Updated config.yaml with pack reference");
-      p3.log.info(
-        `
-Pack "${result.name}" added. ${result.contextCount} context files available.`
-      );
+      p4.log.success(`Installed plugin: ${result.name} v${result.version}`);
+      p4.log.info("Plugin mixins and hooks have been merged into your project.");
     } catch (err) {
       s.stop("Failed!");
-      p3.log.error(`${err}`);
+      p4.log.error(`Installation failed: ${err}`);
       process.exit(1);
     }
   }
 });
-
-// src/commands/remove-pack.ts
-import { defineCommand as defineCommand4 } from "citty";
-import * as p4 from "@clack/prompts";
-var removePackCommand = defineCommand4({
+var removeSubcommand = defineCommand4({
   meta: {
-    name: "remove-pack",
-    description: "Remove a domain pack from the current project"
+    name: "remove",
+    description: "Remove a SNIPER plugin"
   },
   args: {
     name: {
       type: "positional",
-      description: "Pack name to remove (e.g., sales-dialer)",
+      description: "Plugin name to remove",
       required: true
     }
   },
   run: async ({ args }) => {
     const cwd = process.cwd();
     if (!await sniperConfigExists(cwd)) {
-      p4.log.error(
-        'SNIPER is not initialized in this directory. Run "sniper init" first.'
-      );
+      p4.log.error('SNIPER is not initialized. Run "sniper init" first.');
       process.exit(1);
     }
-    const confirm4 = await p4.confirm({
-      message: `Remove pack "${args.name}" and all its files?`
-    });
-    if (p4.isCancel(confirm4) || !confirm4) {
-      p4.cancel("Aborted.");
-      process.exit(0);
-    }
     const s = p4.spinner();
     s.start(`Removing ${args.name}...`);
     try {
-      await removePack(args.name, cwd);
+      await removePlugin(args.name, cwd);
       s.stop("Done!");
-      p4.log.success(`Removed pack "${args.name}"`);
-      p4.log.success("Updated config.yaml");
+      p4.log.success(`Removed plugin: ${args.name}`);
     } catch (err) {
       s.stop("Failed!");
-      p4.log.error(`${err}`);
+      p4.log.error(`Removal failed: ${err}`);
       process.exit(1);
     }
   }
 });
-
-// src/commands/list-packs.ts
-import { defineCommand as defineCommand5 } from "citty";
-import * as p5 from "@clack/prompts";
-var listPacksCommand = defineCommand5({
+var listSubcommand = defineCommand4({
   meta: {
-    name: "list-packs",
-    description: "List available and installed domain packs"
+    name: "list",
+    description: "List installed SNIPER plugins"
   },
   run: async () => {
     const cwd = process.cwd();
-    p5.intro("SNIPER Domain Packs");
-    const s = p5.spinner();
-    s.start("Searching npm registry for @sniper.ai/pack-*...");
-    const available = await searchRegistryPacks();
-    s.stop(
-      available.length > 0 ? `Found ${available.length} pack(s) on npm` : "No packs found on npm registry (packages may not be published yet)"
-    );
-    if (available.length > 0) {
-      p5.log.step("Available packs:");
-      for (const pkg of available) {
-        console.log(
-          `  ${pkg.name.padEnd(40)} v${pkg.version.padEnd(10)} ${pkg.description}`
-        );
-      }
+    if (!await sniperConfigExists(cwd)) {
+      p4.log.error('SNIPER is not initialized. Run "sniper init" first.');
+      process.exit(1);
     }
-    if (await sniperConfigExists(cwd)) {
-      const installed = await listInstalledPacks(cwd);
-      if (installed.length > 0) {
-        p5.log.step("\nInstalled:");
-        for (const pack of installed) {
-          console.log(`  ${pack.name.padEnd(20)} v${pack.version}`);
-        }
-      } else {
-        p5.log.info("\nNo packs installed.");
-      }
+    const plugins = await listPlugins(cwd);
+    if (plugins.length === 0) {
+      p4.log.info("No plugins installed.");
+      return;
     }
-    p5.outro("");
+    p4.log.step("Installed plugins:");
+    for (const plugin of plugins) {
+      console.log(`  - ${plugin.name} (${plugin.package})`);
+    }
+  }
+});
+var pluginCommand = defineCommand4({
+  meta: {
+    name: "plugin",
+    description: "Manage SNIPER plugins"
+  },
+  subCommands: {
+    install: installSubcommand,
+    remove: removeSubcommand,
+    list: listSubcommand
   }
 });
 
-// src/commands/update.ts
-import { defineCommand as defineCommand6 } from "citty";
-import * as p6 from "@clack/prompts";
-var updateCommand = defineCommand6({
+// src/commands/protocol.ts
+import { defineCommand as defineCommand5 } from "citty";
+import * as p5 from "@clack/prompts";
+import { readdir as readdir3, readFile as readFile6, writeFile as writeFile4, mkdir as mkdir4, access as access5 } from "fs/promises";
+import { join as join7 } from "path";
+import YAML5 from "yaml";
+var CUSTOM_PROTOCOLS_DIR = ".sniper/protocols";
+function validateProtocol(data) {
+  const errors = [];
+  if (!data || typeof data !== "object") {
+    errors.push({ path: "(root)", message: "Expected a YAML object" });
+    return errors;
+  }
+  const proto = data;
+  if (typeof proto.name !== "string" || proto.name.length === 0) {
+    errors.push({ path: "name", message: "Required string field" });
+  }
+  if (typeof proto.description !== "string" || proto.description.length === 0) {
+    errors.push({ path: "description", message: "Required string field" });
+  }
+  if (typeof proto.budget !== "number" || !Number.isInteger(proto.budget) || proto.budget < 1) {
+    errors.push({ path: "budget", message: "Required positive integer" });
+  }
+  if (proto.auto_retro !== void 0 && typeof proto.auto_retro !== "boolean") {
+    errors.push({ path: "auto_retro", message: "Must be a boolean" });
+  }
+  if (!Array.isArray(proto.phases) || proto.phases.length === 0) {
+    errors.push({ path: "phases", message: "Required non-empty array" });
+    return errors;
+  }
+  for (let i = 0; i < proto.phases.length; i++) {
+    const phase = proto.phases[i];
+    const prefix = `phases[${i}]`;
+    if (!phase || typeof phase !== "object") {
+      errors.push({ path: prefix, message: "Must be an object" });
+      continue;
+    }
+    if (typeof phase.name !== "string" || phase.name.length === 0) {
+      errors.push({ path: `${prefix}.name`, message: "Required string field" });
+    }
+    if (typeof phase.description !== "string" || phase.description.length === 0) {
+      errors.push({ path: `${prefix}.description`, message: "Required string field" });
+    }
+    if (!Array.isArray(phase.agents) || phase.agents.length === 0) {
+      errors.push({ path: `${prefix}.agents`, message: "Required non-empty array of strings" });
+    } else {
+      for (let j = 0; j < phase.agents.length; j++) {
+        if (typeof phase.agents[j] !== "string") {
+          errors.push({ path: `${prefix}.agents[${j}]`, message: "Must be a string" });
+        }
+      }
+    }
+    if (phase.spawn_strategy !== "single" && phase.spawn_strategy !== "team") {
+      errors.push({ path: `${prefix}.spawn_strategy`, message: 'Must be "single" or "team"' });
+    }
+    if (phase.gate !== void 0) {
+      if (!phase.gate || typeof phase.gate !== "object") {
+        errors.push({ path: `${prefix}.gate`, message: "Must be an object" });
+      } else {
+        const gate = phase.gate;
+        if (typeof gate.checklist !== "string") {
+          errors.push({ path: `${prefix}.gate.checklist`, message: "Required string field" });
+        }
+        if (typeof gate.human_approval !== "boolean") {
+          errors.push({ path: `${prefix}.gate.human_approval`, message: "Required boolean field" });
+        }
+      }
+    }
+    if (phase.plan_approval !== void 0 && typeof phase.plan_approval !== "boolean") {
+      errors.push({ path: `${prefix}.plan_approval`, message: "Must be a boolean" });
+    }
+    if (phase.outputs !== void 0) {
+      if (!Array.isArray(phase.outputs)) {
+        errors.push({ path: `${prefix}.outputs`, message: "Must be an array of strings" });
+      }
+    }
+    if (phase.coordination !== void 0) {
+      if (!Array.isArray(phase.coordination)) {
+        errors.push({ path: `${prefix}.coordination`, message: "Must be an array" });
+      }
+    }
+  }
+  return errors;
+}
+var createSubcommand = defineCommand5({
   meta: {
-    name: "update",
-    description: "Update SNIPER core and installed packs"
+    name: "create",
+    description: "Create a new custom protocol"
   },
-  run: async () => {
+  args: {
+    name: {
+      type: "positional",
+      description: "Protocol name (e.g. my-workflow)",
+      required: true
+    }
+  },
+  run: async ({ args }) => {
     const cwd = process.cwd();
     if (!await sniperConfigExists(cwd)) {
-      p6.log.error(
-        'SNIPER is not initialized in this directory. Run "sniper init" first.'
-      );
+      p5.log.error('SNIPER is not initialized. Run "sniper init" first.');
+      process.exit(1);
+    }
+    const protocolName = args.name;
+    if (!/^[a-z][a-z0-9-]*$/.test(protocolName)) {
+      p5.log.error("Protocol name must start with a letter and contain only lowercase letters, digits, and hyphens.");
+      process.exit(1);
+    }
+    const protocolsDir = join7(cwd, CUSTOM_PROTOCOLS_DIR);
+    const targetPath = join7(protocolsDir, `${protocolName}.yaml`);
+    try {
+      await access5(targetPath);
+      p5.log.error(`Protocol "${args.name}" already exists at ${CUSTOM_PROTOCOLS_DIR}/${args.name}.yaml`);
       process.exit(1);
+    } catch {
+    }
+    const description = await p5.text({
+      message: "Protocol description:",
+      placeholder: "Describe the goal of your protocol",
+      validate: (val) => {
+        if (!val || val.trim().length === 0) return "Description is required";
+      }
+    });
+    if (p5.isCancel(description)) {
+      p5.cancel("Cancelled.");
+      process.exit(0);
     }
-    p6.intro("SNIPER Update");
-    const currentConfig = await readConfig(cwd);
-    const confirm4 = await p6.confirm({
-      message: "This will update framework files (personas, teams, templates, etc.) while preserving your config.yaml customizations. Continue?"
+    const budgetStr = await p5.text({
+      message: "Token budget:",
+      placeholder: "500000",
+      initialValue: "500000",
+      validate: (val) => {
+        const n = Number(val);
+        if (!Number.isInteger(n) || n < 1) return "Must be a positive integer";
+      }
     });
-    if (p6.isCancel(confirm4) || !confirm4) {
-      p6.cancel("Aborted.");
+    if (p5.isCancel(budgetStr)) {
+      p5.cancel("Cancelled.");
       process.exit(0);
     }
-    const s = p6.spinner();
-    s.start("Updating framework files...");
+    const budget = Number(budgetStr);
+    let templateContent;
     try {
-      const log9 = await scaffoldProject(cwd, currentConfig, { update: true });
-      s.stop("Done!");
-      for (const entry of log9) {
-        p6.log.success(entry);
+      const corePath = getCorePath();
+      templateContent = await readFile6(
+        join7(corePath, "templates", "custom-protocol.yaml"),
+        "utf-8"
+      );
+    } catch {
+      p5.log.warn("Could not read template from @sniper.ai/core. Using minimal template.");
+      templateContent = YAML5.stringify({
+        name: args.name,
+        description,
+        budget,
+        phases: [
+          {
+            name: "implement",
+            description: "Implementation phase",
+            agents: ["fullstack-dev"],
+            spawn_strategy: "single",
+            gate: { checklist: "implement", human_approval: false },
+            outputs: ["source code changes"]
+          }
+        ],
+        auto_retro: true
+      });
+    }
+    let content;
+    try {
+      const parsed = YAML5.parse(templateContent);
+      parsed.name = protocolName;
+      parsed.description = description;
+      parsed.budget = budget;
+      content = YAML5.stringify(parsed, { lineWidth: 0 });
+    } catch {
+      content = templateContent.replace(/^name: .+$/m, `name: ${protocolName}`).replace(/^description: .+$/m, `description: ${YAML5.stringify(description).trim()}`).replace(/^budget: .+$/m, `budget: ${budget}`);
+    }
+    await mkdir4(protocolsDir, { recursive: true });
+    await writeFile4(targetPath, content, "utf-8");
+    p5.log.success(`Created custom protocol: ${CUSTOM_PROTOCOLS_DIR}/${protocolName}.yaml`);
+    p5.log.info("Edit the file to customize phases, agents, and gates.");
+    p5.log.info(`Run "sniper protocol validate ${protocolName}" to check your protocol.`);
+  }
+});
+var listSubcommand2 = defineCommand5({
+  meta: {
+    name: "list",
+    description: "List all available protocols (built-in and custom)"
+  },
+  run: async () => {
+    const cwd = process.cwd();
+    if (!await sniperConfigExists(cwd)) {
+      p5.log.error('SNIPER is not initialized. Run "sniper init" first.');
+      process.exit(1);
+    }
+    let builtInFiles = [];
+    try {
+      const corePath = getCorePath();
+      const protocolsPath = join7(corePath, "protocols");
+      const files = await readdir3(protocolsPath);
+      builtInFiles = files.filter((f) => f.endsWith(".yaml"));
+    } catch {
+      p5.log.warn("Could not read built-in protocols from @sniper.ai/core.");
+    }
+    let customFiles = [];
+    try {
+      const customDir = join7(cwd, CUSTOM_PROTOCOLS_DIR);
+      const files = await readdir3(customDir);
+      customFiles = files.filter((f) => f.endsWith(".yaml"));
+    } catch {
+    }
+    if (builtInFiles.length === 0 && customFiles.length === 0) {
+      p5.log.info("No protocols found.");
+      return;
+    }
+    if (builtInFiles.length > 0) {
+      const corePathForList = getCorePath();
+      p5.log.step("Built-in protocols:");
+      for (const file of builtInFiles) {
+        const name = file.replace(/\.yaml$/, "");
+        try {
+          const raw = await readFile6(join7(corePathForList, "protocols", file), "utf-8");
+          const data = YAML5.parse(raw);
+          console.log(`  - ${name}: ${data.description || "(no description)"}`);
+        } catch {
+          console.log(`  - ${name}`);
+        }
+      }
+    }
+    if (customFiles.length > 0) {
+      p5.log.step("Custom protocols:");
+      for (const file of customFiles) {
+        const name = file.replace(/\.yaml$/, "");
+        try {
+          const raw = await readFile6(join7(cwd, CUSTOM_PROTOCOLS_DIR, file), "utf-8");
+          const data = YAML5.parse(raw);
+          console.log(`  - ${name}: ${data.description || "(no description)"}`);
+        } catch {
+          console.log(`  - ${name}`);
+        }
       }
-      p6.outro("SNIPER updated successfully.");
+    }
+  }
+});
+var validateSubcommand = defineCommand5({
+  meta: {
+    name: "validate",
+    description: "Validate a custom protocol against the schema"
+  },
+  args: {
+    name: {
+      type: "positional",
+      description: "Protocol name to validate",
+      required: true
+    }
+  },
+  run: async ({ args }) => {
+    const cwd = process.cwd();
+    if (!await sniperConfigExists(cwd)) {
+      p5.log.error('SNIPER is not initialized. Run "sniper init" first.');
+      process.exit(1);
+    }
+    if (!/^[a-z][a-z0-9-]*$/.test(args.name)) {
+      p5.log.error("Protocol name must be lowercase alphanumeric with hyphens");
+      process.exit(1);
+    }
+    const filePath = join7(cwd, CUSTOM_PROTOCOLS_DIR, `${args.name}.yaml`);
+    let raw;
+    try {
+      raw = await readFile6(filePath, "utf-8");
+    } catch {
+      p5.log.error(`Protocol not found: ${CUSTOM_PROTOCOLS_DIR}/${args.name}.yaml`);
+      process.exit(1);
+    }
+    let data;
+    try {
+      data = YAML5.parse(raw);
     } catch (err) {
-      s.stop("Failed!");
-      p6.log.error(`Update failed: ${err}`);
+      p5.log.error(`Invalid YAML: ${err}`);
+      process.exit(1);
+    }
+    const errors = validateProtocol(data);
+    if (errors.length === 0) {
+      p5.log.success(`Protocol "${args.name}" is valid.`);
+    } else {
+      p5.log.error(`Protocol "${args.name}" has ${errors.length} error(s):`);
+      for (const err of errors) {
+        console.log(`  ${err.path}: ${err.message}`);
+      }
+      process.exit(1);
+    }
+  }
+});
+var protocolCommand = defineCommand5({
+  meta: {
+    name: "protocol",
+    description: "Manage SNIPER protocols"
+  },
+  subCommands: {
+    create: createSubcommand,
+    list: listSubcommand2,
+    validate: validateSubcommand
+  }
+});
+
+// src/commands/dashboard.ts
+import { defineCommand as defineCommand6 } from "citty";
+import * as p6 from "@clack/prompts";
+import { readFile as readFile7, readdir as readdir4 } from "fs/promises";
+import { join as join8 } from "path";
+import YAML6 from "yaml";
+async function readYamlDir(dirPath) {
+  if (!await pathExists(dirPath)) return [];
+  const files = await readdir4(dirPath);
+  const yamlFiles = files.filter((f) => f.endsWith(".yaml") || f.endsWith(".yml"));
+  const results = [];
+  for (const file of yamlFiles) {
+    try {
+      const raw = await readFile7(join8(dirPath, file), "utf-8");
+      const parsed = YAML6.parse(raw);
+      if (parsed) results.push(parsed);
+    } catch {
+    }
+  }
+  return results;
+}
+function formatTokens(n) {
+  if (n >= 1e6) return `${(n / 1e6).toFixed(1)}M`;
+  if (n >= 1e3) return `${(n / 1e3).toFixed(0)}K`;
+  return String(n);
+}
+function aggregateData(checkpoints, gates, velocity, protocolFilter) {
+  const filtered = protocolFilter ? checkpoints.filter((c) => c.protocol === protocolFilter) : checkpoints;
+  const byProtocol = {};
+  for (const cp3 of filtered) {
+    if (!byProtocol[cp3.protocol]) {
+      byProtocol[cp3.protocol] = { phase_tokens: 0, cumulative_tokens: 0, phases: [] };
+    }
+    const entry = byProtocol[cp3.protocol];
+    entry.phase_tokens += cp3.token_usage?.phase_tokens ?? 0;
+    if (cp3.token_usage?.cumulative_tokens && cp3.token_usage.cumulative_tokens > entry.cumulative_tokens) {
+      entry.cumulative_tokens = cp3.token_usage.cumulative_tokens;
+    }
+    if (!entry.phases.includes(cp3.phase)) {
+      entry.phases.push(cp3.phase);
+    }
+  }
+  const byAgent = {};
+  for (const cp3 of filtered) {
+    const agentCount = cp3.agents?.length ?? 1;
+    const tokensPerAgent = agentCount > 0 ? (cp3.token_usage?.phase_tokens ?? 0) / agentCount : 0;
+    for (const agent of cp3.agents ?? []) {
+      if (!byAgent[agent.name]) {
+        byAgent[agent.name] = { tokens: 0, tasks_completed: 0, tasks_total: 0 };
+      }
+      byAgent[agent.name].tokens += tokensPerAgent;
+      byAgent[agent.name].tasks_completed += agent.tasks_completed;
+      byAgent[agent.name].tasks_total += agent.tasks_total;
+    }
+  }
+  const filteredGates = protocolFilter ? gates.filter((g) => g.protocol === protocolFilter) : gates;
+  const gateRates = {};
+  for (const g of filteredGates) {
+    const key = g.protocol ? `${g.protocol}/${g.gate}` : g.gate;
+    if (!gateRates[key]) {
+      gateRates[key] = { pass: 0, fail: 0, total_checks: 0 };
+    }
+    if (g.result === "pass") gateRates[key].pass++;
+    else gateRates[key].fail++;
+    gateRates[key].total_checks += g.total_checks;
+  }
+  const agentEfficiency = {};
+  for (const [name, data] of Object.entries(byAgent)) {
+    const totalTasks = data.tasks_completed || 1;
+    agentEfficiency[name] = {
+      tokens_per_task: Math.round(data.tokens / totalTasks),
+      total_tokens: Math.round(data.tokens),
+      total_tasks: data.tasks_completed
+    };
+  }
+  const executions = velocity?.executions ?? [];
+  const filteredExecs = protocolFilter ? executions.filter((e) => e.protocol === protocolFilter) : executions;
+  const timeline = [];
+  for (const cp3 of filtered) {
+    timeline.push({
+      timestamp: cp3.timestamp,
+      type: "checkpoint",
+      protocol: cp3.protocol,
+      phase: cp3.phase,
+      status: cp3.status
+    });
+  }
+  for (const g of filteredGates) {
+    timeline.push({
+      timestamp: g.timestamp,
+      type: "gate",
+      protocol: g.protocol ?? "unknown",
+      phase: g.gate,
+      status: g.result
+    });
+  }
+  timeline.sort((a, b) => b.timestamp.localeCompare(a.timestamp));
+  return {
+    cost_breakdown: { by_protocol: byProtocol, by_agent: byAgent },
+    performance_trends: {
+      executions: filteredExecs,
+      calibrated_budgets: velocity?.calibrated_budgets ?? {},
+      rolling_averages: velocity?.rolling_averages ?? {}
+    },
+    gate_pass_rates: gateRates,
+    agent_efficiency: agentEfficiency,
+    timeline: timeline.slice(0, 20)
+  };
+}
+function renderDashboard(data, config) {
+  p6.log.step("Cost Breakdown");
+  const protocols = Object.entries(data.cost_breakdown.by_protocol);
+  if (protocols.length === 0) {
+    console.log("  No checkpoint data found.");
+  } else {
+    for (const [protocol, info] of protocols) {
+      const budget = config.routing.budgets[protocol];
+      const budgetStr = budget ? ` / ${formatTokens(budget)} budget` : "";
+      console.log(`  ${protocol}: ${formatTokens(info.cumulative_tokens)} cumulative${budgetStr}`);
+      console.log(`    Phase tokens: ${formatTokens(info.phase_tokens)} across ${info.phases.length} phase(s)`);
+    }
+  }
+  const agents = Object.entries(data.cost_breakdown.by_agent);
+  if (agents.length > 0) {
+    console.log("");
+    console.log("  By Agent:");
+    for (const [name, info] of agents) {
+      console.log(`    ${name.padEnd(24)} ${formatTokens(info.tokens).padStart(8)} tokens  (${info.tasks_completed}/${info.tasks_total} tasks)`);
+    }
+  }
+  p6.log.step("Performance Trends");
+  const execs = data.performance_trends.executions;
+  if (execs.length === 0) {
+    console.log("  No execution history found.");
+  } else {
+    const byProto = {};
+    for (const e of execs) {
+      if (!byProto[e.protocol]) byProto[e.protocol] = [];
+      byProto[e.protocol].push(e);
+    }
+    for (const [proto, runs] of Object.entries(byProto)) {
+      const avg = Math.round(runs.reduce((s, r) => s + r.tokens_used, 0) / runs.length);
+      const calibrated = data.performance_trends.calibrated_budgets[proto];
+      const rolling = data.performance_trends.rolling_averages[proto];
+      console.log(`  ${proto}: ${runs.length} execution(s), avg ${formatTokens(avg)} tokens`);
+      if (rolling) console.log(`    Rolling average: ${formatTokens(rolling)}`);
+      if (calibrated) console.log(`    Calibrated budget (p75): ${formatTokens(calibrated)}`);
+    }
+  }
+  p6.log.step("Gate Pass Rates");
+  const gateEntries = Object.entries(data.gate_pass_rates);
+  if (gateEntries.length === 0) {
+    console.log("  No gate results found.");
+  } else {
+    for (const [key, info] of gateEntries) {
+      const total = info.pass + info.fail;
+      const rate = total > 0 ? Math.round(info.pass / total * 100) : 0;
+      const icon = rate === 100 ? "\u2713" : rate >= 50 ? "~" : "\u2717";
+      console.log(`  ${icon} ${key.padEnd(28)} ${rate}% pass (${info.pass}/${total}), ${info.total_checks} checks`);
+    }
+  }
+  p6.log.step("Agent Efficiency");
+  const effEntries = Object.entries(data.agent_efficiency);
+  if (effEntries.length === 0) {
+    console.log("  No agent data found.");
+  } else {
+    for (const [name, info] of effEntries) {
+      console.log(`  ${name.padEnd(24)} ${formatTokens(info.tokens_per_task).padStart(8)} tokens/task  (${info.total_tasks} tasks, ${formatTokens(info.total_tokens)} total)`);
+    }
+  }
+  p6.log.step("Timeline (recent)");
+  if (data.timeline.length === 0) {
+    console.log("  No recent activity.");
+  } else {
+    for (const entry of data.timeline.slice(0, 10)) {
+      const ts = entry.timestamp.replace("T", " ").substring(0, 19);
+      const icon = entry.type === "gate" ? entry.status === "pass" ? "\u2713" : "\u2717" : "\u25B6";
+      const phaseStr = entry.phase ? `/${entry.phase}` : "";
+      console.log(`  ${ts}  ${icon} ${entry.type.padEnd(12)} ${entry.protocol}${phaseStr} [${entry.status}]`);
+    }
+  }
+}
+var dashboardCommand = defineCommand6({
+  meta: {
+    name: "dashboard",
+    description: "Show observability dashboard with cost, performance, gates, and agent metrics"
+  },
+  args: {
+    protocol: {
+      type: "string",
+      description: "Filter by protocol name",
+      required: false
+    },
+    json: {
+      type: "boolean",
+      description: "Output structured JSON instead of formatted text",
+      required: false
+    }
+  },
+  run: async ({ args }) => {
+    const cwd = process.cwd();
+    if (!await sniperConfigExists(cwd)) {
+      p6.log.error('SNIPER is not initialized. Run "sniper init" first.');
       process.exit(1);
     }
+    const config = await readConfig(cwd);
+    const sniperDir = join8(cwd, ".sniper");
+    const checkpoints = await readYamlDir(join8(sniperDir, "checkpoints"));
+    const gates = await readYamlDir(join8(sniperDir, "gates"));
+    let velocity = null;
+    const velocityPath = join8(sniperDir, "memory", "velocity.yaml");
+    if (await pathExists(velocityPath)) {
+      try {
+        const raw = await readFile7(velocityPath, "utf-8");
+        velocity = YAML6.parse(raw);
+      } catch {
+      }
+    }
+    const protocolFilter = args.protocol || void 0;
+    const data = aggregateData(checkpoints, gates, velocity, protocolFilter);
+    if (args.json) {
+      console.log(JSON.stringify(data, null, 2));
+      return;
+    }
+    const title = protocolFilter ? `SNIPER Dashboard \u2014 ${protocolFilter}` : "SNIPER Dashboard";
+    p6.intro(title);
+    if (checkpoints.length === 0 && gates.length === 0 && !velocity) {
+      p6.log.info("No observability data found yet. Run a protocol to generate metrics.");
+      p6.outro("");
+      return;
+    }
+    renderDashboard(data, config);
+    p6.outro("");
   }
 });
 
-// src/commands/memory.ts
-import { readFile as readFile4, writeFile as writeFile3, readdir as readdir3 } from "fs/promises";
-import { join as join4 } from "path";
+// src/commands/workspace.ts
 import { defineCommand as defineCommand7 } from "citty";
 import * as p7 from "@clack/prompts";
-import YAML4 from "yaml";
 
-// src/fs-utils.ts
-import { mkdir as mkdir3, access as access4 } from "fs/promises";
-async function ensureDir2(dir) {
-  await mkdir3(dir, { recursive: true });
-}
-async function pathExists2(path) {
+// src/workspace-manager.ts
+import { readFile as readFile8, writeFile as writeFile5, access as access6, mkdir as mkdir5 } from "fs/promises";
+import { join as join9, resolve as resolve3, dirname as dirname2 } from "path";
+import YAML7 from "yaml";
+var WORKSPACE_DIR = ".sniper-workspace";
+var WORKSPACE_CONFIG = "config.yaml";
+async function pathExists3(p14) {
   try {
-    await access4(path);
+    await access6(p14);
     return true;
   } catch {
     return false;
   }
 }
-
-// src/commands/memory.ts
-async function readYamlArray(filePath, key) {
-  if (!await pathExists2(filePath)) return [];
-  try {
-    const raw = await readFile4(filePath, "utf-8");
-    const parsed = YAML4.parse(raw);
-    return Array.isArray(parsed?.[key]) ? parsed[key] : [];
-  } catch {
-    return [];
+async function findWorkspaceRoot(cwd) {
+  let dir = resolve3(cwd);
+  while (true) {
+    const configPath = join9(dir, WORKSPACE_DIR, WORKSPACE_CONFIG);
+    if (await pathExists3(configPath)) {
+      return dir;
+    }
+    const parent = dirname2(dir);
+    if (parent === dir) break;
+    dir = parent;
+  }
+  return null;
+}
+async function readWorkspaceConfig(workspaceRoot) {
+  const configPath = join9(workspaceRoot, WORKSPACE_DIR, WORKSPACE_CONFIG);
+  const raw = await readFile8(configPath, "utf-8");
+  const data = YAML7.parse(raw);
+  if (!data || typeof data !== "object") {
+    throw new Error("Invalid workspace config: expected an object");
+  }
+  if (!data.name || typeof data.name !== "string") {
+    throw new Error('Invalid workspace config: missing "name"');
+  }
+  if (!Array.isArray(data.projects)) {
+    throw new Error('Invalid workspace config: missing "projects" array');
   }
+  return data;
 }
-async function writeYamlArray(filePath, key, entries) {
-  const content = YAML4.stringify({ [key]: entries }, { lineWidth: 0 });
-  await writeFile3(filePath, content, "utf-8");
+async function addProject(workspaceRoot, name, path) {
+  if (path.includes("..")) {
+    throw new Error(`Project path must not contain '..': ${path}`);
+  }
+  const config = await readWorkspaceConfig(workspaceRoot);
+  if (config.projects.some((p14) => p14.name === name)) {
+    throw new Error(`Project "${name}" already exists in workspace`);
+  }
+  config.projects.push({ name, path });
+  const configPath = join9(workspaceRoot, WORKSPACE_DIR, WORKSPACE_CONFIG);
+  await writeFile5(configPath, YAML7.stringify(config, { lineWidth: 0 }), "utf-8");
 }
-function nextId(entries, prefix) {
-  let max = 0;
-  for (const entry of entries) {
-    const match = entry.id?.match(new RegExp(`^${prefix}-(\\d+)$`));
-    if (match) {
-      const num = parseInt(match[1], 10);
-      if (num > max) max = num;
+async function syncConventions(workspaceRoot) {
+  const config = await readWorkspaceConfig(workspaceRoot);
+  const candidates = [];
+  for (const project of config.projects) {
+    const projectConfigPath = join9(
+      workspaceRoot,
+      project.path,
+      ".sniper",
+      "config.yaml"
+    );
+    if (await pathExists3(projectConfigPath)) {
+      candidates.push(project.name);
     }
   }
-  return `${prefix}-${String(max + 1).padStart(3, "0")}`;
+  return candidates;
 }
-var memoryCommand = defineCommand7({
+async function initWorkspace(cwd, name) {
+  const wsDir = join9(cwd, WORKSPACE_DIR);
+  const memoryDir = join9(wsDir, "memory");
+  const locksDir2 = join9(wsDir, "locks");
+  await mkdir5(wsDir, { recursive: true });
+  await mkdir5(memoryDir, { recursive: true });
+  await mkdir5(locksDir2, { recursive: true });
+  const config = {
+    name,
+    projects: [],
+    shared: {
+      conventions: [],
+      anti_patterns: [],
+      architectural_decisions: []
+    },
+    memory: {
+      directory: `${WORKSPACE_DIR}/memory`
+    }
+  };
+  const configPath = join9(wsDir, WORKSPACE_CONFIG);
+  await writeFile5(configPath, YAML7.stringify(config, { lineWidth: 0 }), "utf-8");
+  return wsDir;
+}
+
+// src/commands/workspace.ts
+var initSubcommand = defineCommand7({
+  meta: {
+    name: "init",
+    description: "Initialize a SNIPER workspace for multi-project orchestration"
+  },
+  args: {
+    name: {
+      type: "string",
+      description: "Workspace name",
+      required: false
+    }
+  },
+  run: async ({ args }) => {
+    const cwd = process.cwd();
+    p7.intro("SNIPER Workspace \u2014 Initialization");
+    const existing = await findWorkspaceRoot(cwd);
+    if (existing) {
+      p7.log.warning(`Workspace already exists at ${existing}`);
+      const overwrite = await p7.confirm({
+        message: "Reinitialize workspace?",
+        initialValue: false
+      });
+      if (p7.isCancel(overwrite) || !overwrite) {
+        p7.cancel("Aborted.");
+        process.exit(0);
+      }
+    }
+    let name = args.name;
+    if (!name) {
+      const input = await p7.text({
+        message: "Workspace name:",
+        placeholder: "my-workspace",
+        validate: (v) => v.length === 0 ? "Name is required" : void 0
+      });
+      if (p7.isCancel(input)) {
+        p7.cancel("Aborted.");
+        process.exit(0);
+      }
+      name = input;
+    }
+    const s = p7.spinner();
+    s.start("Creating workspace...");
+    try {
+      const wsDir = await initWorkspace(cwd, name);
+      s.stop("Done!");
+      p7.log.success(`Workspace "${name}" created at ${wsDir}`);
+      p7.log.info("Created: config.yaml, memory/, locks/");
+      p7.outro('Add projects with "sniper workspace add <name> --path <dir>"');
+    } catch (err) {
+      s.stop("Failed!");
+      p7.log.error(`Workspace init failed: ${err}`);
+      process.exit(1);
+    }
+  }
+});
+var addSubcommand = defineCommand7({
+  meta: {
+    name: "add",
+    description: "Add a project to the workspace"
+  },
+  args: {
+    name: {
+      type: "positional",
+      description: "Project name",
+      required: true
+    },
+    path: {
+      type: "string",
+      description: "Relative path to the project directory",
+      required: true
+    }
+  },
+  run: async ({ args }) => {
+    const cwd = process.cwd();
+    const wsRoot = await findWorkspaceRoot(cwd);
+    if (!wsRoot) {
+      p7.log.error('No workspace found. Run "sniper workspace init" first.');
+      process.exit(1);
+    }
+    try {
+      await addProject(wsRoot, args.name, args.path);
+      p7.log.success(`Added project "${args.name}" (${args.path}) to workspace.`);
+    } catch (err) {
+      p7.log.error(`Failed to add project: ${err}`);
+      process.exit(1);
+    }
+  }
+});
+var statusSubcommand = defineCommand7({
+  meta: {
+    name: "status",
+    description: "Show workspace status"
+  },
+  run: async () => {
+    const cwd = process.cwd();
+    const wsRoot = await findWorkspaceRoot(cwd);
+    if (!wsRoot) {
+      p7.log.error('No workspace found. Run "sniper workspace init" first.');
+      process.exit(1);
+    }
+    const config = await readWorkspaceConfig(wsRoot);
+    p7.intro(`Workspace: ${config.name}`);
+    p7.log.step("Projects:");
+    if (config.projects.length === 0) {
+      console.log("  (none)");
+    } else {
+      for (const proj of config.projects) {
+        const typeLabel = proj.type ? ` (${proj.type})` : "";
+        console.log(`  - ${proj.name}: ${proj.path}${typeLabel}`);
+      }
+    }
+    const conventions = config.shared?.conventions ?? [];
+    p7.log.info(`Shared conventions: ${conventions.length}`);
+    const antiPatterns = config.shared?.anti_patterns ?? [];
+    p7.log.info(`Anti-patterns: ${antiPatterns.length}`);
+    const adrs = config.shared?.architectural_decisions ?? [];
+    p7.log.info(`Architectural decisions: ${adrs.length}`);
+    const memDir = config.memory?.directory;
+    p7.log.info(`Memory: ${memDir ? memDir : "not configured"}`);
+    p7.outro("");
+  }
+});
+var syncSubcommand = defineCommand7({
+  meta: {
+    name: "sync",
+    description: "Sync shared conventions to workspace projects"
+  },
+  run: async () => {
+    const cwd = process.cwd();
+    const wsRoot = await findWorkspaceRoot(cwd);
+    if (!wsRoot) {
+      p7.log.error('No workspace found. Run "sniper workspace init" first.');
+      process.exit(1);
+    }
+    const s = p7.spinner();
+    s.start("Syncing conventions...");
+    try {
+      const synced = await syncConventions(wsRoot);
+      s.stop("Done!");
+      if (synced.length === 0) {
+        p7.log.info("No projects with .sniper/config.yaml found to sync.");
+      } else {
+        for (const name of synced) {
+          p7.log.success(`Checked: ${name}`);
+        }
+      }
+    } catch (err) {
+      s.stop("Failed!");
+      p7.log.error(`Sync failed: ${err}`);
+      process.exit(1);
+    }
+  }
+});
+var workspaceCommand = defineCommand7({
+  meta: {
+    name: "workspace",
+    description: "Manage SNIPER workspaces for multi-project orchestration"
+  },
+  subCommands: {
+    init: initSubcommand,
+    add: addSubcommand,
+    status: statusSubcommand,
+    sync: syncSubcommand
+  }
+});
+
+// src/commands/revert.ts
+import { defineCommand as defineCommand8 } from "citty";
+import * as p8 from "@clack/prompts";
+import { readFile as readFile9, readdir as readdir5 } from "fs/promises";
+import { join as join10 } from "path";
+import { execFileSync as execFileSync2 } from "child_process";
+import YAML8 from "yaml";
+function isValidSha(sha) {
+  return /^[0-9a-f]{7,40}$/i.test(sha);
+}
+var revertCommand = defineCommand8({
+  meta: {
+    name: "revert",
+    description: "Logically revert a SNIPER protocol, phase, or checkpoint"
+  },
+  args: {
+    protocol: {
+      type: "string",
+      description: "Protocol ID to revert"
+    },
+    phase: {
+      type: "string",
+      description: "Specific phase to revert"
+    },
+    checkpoint: {
+      type: "string",
+      description: "Specific checkpoint file to revert"
+    },
+    "dry-run": {
+      type: "boolean",
+      description: "Show what would be reverted without doing it",
+      default: false
+    },
+    yes: {
+      type: "boolean",
+      description: "Skip confirmation prompt",
+      default: false
+    }
+  },
+  run: async ({ args }) => {
+    const cwd = process.cwd();
+    if (!await sniperConfigExists(cwd)) {
+      p8.log.error(
+        'SNIPER is not initialized. Run "sniper init" first.'
+      );
+      process.exit(1);
+    }
+    p8.intro("SNIPER v3 \u2014 Logical Revert");
+    const checkpointsDir = join10(cwd, ".sniper", "checkpoints");
+    if (!await pathExists(checkpointsDir)) {
+      p8.log.error("No checkpoints found. Nothing to revert.");
+      process.exit(1);
+    }
+    const files = await readdir5(checkpointsDir);
+    const yamlFiles = files.filter(
+      (f) => f.endsWith(".yaml") || f.endsWith(".yml")
+    );
+    if (yamlFiles.length === 0) {
+      p8.log.error("No checkpoint files found. Nothing to revert.");
+      process.exit(1);
+    }
+    const checkpoints = [];
+    for (const file of yamlFiles) {
+      const raw = await readFile9(join10(checkpointsDir, file), "utf-8");
+      const data = YAML8.parse(raw);
+      if (data) {
+        checkpoints.push({ filename: file, data });
+      }
+    }
+    let filtered = checkpoints;
+    if (args.checkpoint) {
+      filtered = filtered.filter((c) => c.filename === args.checkpoint);
+    }
+    if (args.protocol) {
+      filtered = filtered.filter((c) => c.data.protocol === args.protocol);
+    }
+    if (args.phase) {
+      filtered = filtered.filter((c) => c.data.phase === args.phase);
+    }
+    if (filtered.length === 0) {
+      p8.log.error("No matching checkpoints found for the given filters.");
+      process.exit(1);
+    }
+    const commits = [];
+    for (const cp3 of filtered) {
+      if (Array.isArray(cp3.data.commits)) {
+        for (const commit of cp3.data.commits) {
+          if (!commits.some((c) => c.sha === commit.sha)) {
+            commits.push(commit);
+          }
+        }
+      }
+    }
+    if (commits.length === 0) {
+      p8.log.error(
+        "No commits found in matching checkpoints. Nothing to revert."
+      );
+      process.exit(1);
+    }
+    const protocolLabel = args.protocol || filtered[0].data.protocol;
+    const phaseLabel = args.phase || "(all phases)";
+    p8.log.step(
+      `Revert plan: ${commits.length} commit(s) from protocol "${protocolLabel}" ${args.phase ? `phase "${phaseLabel}"` : ""}`
+    );
+    for (const commit of commits) {
+      console.log(`  ${commit.sha.substring(0, 8)} ${commit.message} (${commit.agent})`);
+    }
+    if (args["dry-run"]) {
+      p8.log.info("Dry run complete. No changes were made.");
+      p8.outro("");
+      return;
+    }
+    if (!args.yes) {
+      const confirmed = await p8.confirm({
+        message: `Revert ${commits.length} commit(s)? A backup branch will be created.`,
+        initialValue: false
+      });
+      if (p8.isCancel(confirmed) || !confirmed) {
+        p8.cancel("Revert aborted.");
+        process.exit(0);
+      }
+    }
+    const timestamp = Date.now();
+    const backupBranch = `sniper-revert-backup-${timestamp}`;
+    try {
+      execFileSync2("git", ["branch", backupBranch], { cwd });
+      p8.log.success(`Created backup branch: ${backupBranch}`);
+    } catch (err) {
+      p8.log.error(`Failed to create backup branch: ${err}`);
+      process.exit(1);
+    }
+    const s = p8.spinner();
+    s.start("Reverting commits...");
+    try {
+      for (const commit of commits) {
+        if (!isValidSha(commit.sha)) {
+          throw new Error(`Invalid commit SHA: ${commit.sha}`);
+        }
+        execFileSync2("git", ["revert", "--no-commit", commit.sha], { cwd });
+      }
+      const revertMessage = `revert: undo ${commits.length} commit(s) from protocol "${protocolLabel}"${args.phase ? ` phase "${phaseLabel}"` : ""}
+
+Reverted commits:
+${commits.map((c) => `  - ${c.sha.substring(0, 8)} ${c.message}`).join("\n")}
+
+Backup branch: ${backupBranch}`;
+      execFileSync2("git", ["commit", "-m", revertMessage], { cwd });
+      s.stop("Revert complete!");
+      p8.log.success(
+        `Successfully reverted ${commits.length} commit(s). Backup branch: ${backupBranch}`
+      );
+      p8.outro("");
+    } catch (err) {
+      s.stop("Revert failed!");
+      p8.log.error(`Revert failed: ${err}`);
+      p8.log.info(
+        `Your backup branch "${backupBranch}" is intact. You can run "git revert --abort" to undo the partial revert.`
+      );
+      process.exit(1);
+    }
+  }
+});
+
+// src/commands/run.ts
+import { defineCommand as defineCommand9 } from "citty";
+import * as p9 from "@clack/prompts";
+
+// src/headless.ts
+import { readFile as readFile10 } from "fs/promises";
+import { join as join11 } from "path";
+import YAML9 from "yaml";
+var BUILT_IN_PROTOCOLS = [
+  "full",
+  "feature",
+  "patch",
+  "ingest",
+  "explore",
+  "refactor",
+  "hotfix"
+];
+var HeadlessRunner = class {
+  cwd;
+  options;
+  constructor(cwd, options) {
+    this.cwd = cwd;
+    this.options = options;
+  }
+  async run() {
+    const startTime = Date.now();
+    const errors = [];
+    let config;
+    try {
+      config = await readConfig(this.cwd);
+    } catch (err) {
+      return {
+        exitCode: 4 /* ConfigError */,
+        protocol: this.options.protocol,
+        phases: [],
+        totalTokens: 0,
+        duration: Date.now() - startTime,
+        errors: [
+          `Config error: ${err instanceof Error ? err.message : String(err)}`
+        ]
+      };
+    }
+    if (!/^[a-z][a-z0-9-]*$/.test(this.options.protocol)) {
+      return {
+        exitCode: 4 /* ConfigError */,
+        protocol: this.options.protocol,
+        phases: [],
+        totalTokens: 0,
+        duration: Date.now() - startTime,
+        errors: [
+          `Invalid protocol name: "${this.options.protocol}". Must be lowercase alphanumeric with hyphens.`
+        ]
+      };
+    }
+    const isBuiltIn = BUILT_IN_PROTOCOLS.includes(this.options.protocol);
+    let isCustom = false;
+    if (!isBuiltIn) {
+      try {
+        const customPath = join11(
+          this.cwd,
+          ".sniper",
+          "protocols",
+          `${this.options.protocol}.yaml`
+        );
+        await readFile10(customPath, "utf-8");
+        isCustom = true;
+      } catch {
+      }
+    }
+    if (!isBuiltIn && !isCustom) {
+      return {
+        exitCode: 4 /* ConfigError */,
+        protocol: this.options.protocol,
+        phases: [],
+        totalTokens: 0,
+        duration: Date.now() - startTime,
+        errors: [
+          `Unknown protocol: "${this.options.protocol}". Available: ${BUILT_IN_PROTOCOLS.join(", ")} (or define a custom protocol in .sniper/protocols/)`
+        ]
+      };
+    }
+    return {
+      exitCode: 4 /* ConfigError */,
+      protocol: this.options.protocol,
+      phases: [],
+      totalTokens: 0,
+      duration: Date.now() - startTime,
+      errors: [
+        "Headless mode is not yet implemented. Protocol validation passed, but no execution occurred. Use /sniper-flow interactively instead."
+      ]
+    };
+  }
+  formatOutput(result) {
+    switch (this.options.outputFormat) {
+      case "json":
+        return JSON.stringify(
+          {
+            protocol: result.protocol,
+            status: exitCodeToStatus(result.exitCode),
+            phases: result.phases,
+            total_tokens: result.totalTokens,
+            duration_seconds: Math.round(result.duration / 1e3),
+            errors: result.errors
+          },
+          null,
+          2
+        );
+      case "yaml":
+        return YAML9.stringify({
+          protocol: result.protocol,
+          status: exitCodeToStatus(result.exitCode),
+          phases: result.phases,
+          total_tokens: result.totalTokens,
+          duration_seconds: Math.round(result.duration / 1e3),
+          errors: result.errors
+        });
+      case "text":
+        return formatTextTable(result);
+      default:
+        return JSON.stringify(
+          {
+            protocol: result.protocol,
+            status: exitCodeToStatus(result.exitCode),
+            phases: result.phases,
+            total_tokens: result.totalTokens,
+            duration_seconds: Math.round(result.duration / 1e3),
+            errors: result.errors
+          },
+          null,
+          2
+        );
+    }
+  }
+};
+function exitCodeToStatus(code) {
+  switch (code) {
+    case 0 /* Success */:
+      return "success";
+    case 1 /* GateFail */:
+      return "gate_fail";
+    case 2 /* CostExceeded */:
+      return "cost_exceeded";
+    case 3 /* Timeout */:
+      return "timeout";
+    case 4 /* ConfigError */:
+      return "config_error";
+  }
+}
+function formatTextTable(result) {
+  const lines = [];
+  const status = exitCodeToStatus(result.exitCode);
+  lines.push(`Protocol: ${result.protocol}`);
+  lines.push(`Status:   ${status}`);
+  lines.push(`Duration: ${Math.round(result.duration / 1e3)}s`);
+  lines.push(`Tokens:   ${result.totalTokens}`);
+  if (result.phases.length > 0) {
+    lines.push("");
+    lines.push("Phase            Status      Gate             Tokens");
+    lines.push("---------------- ----------- ---------------- ------");
+    for (const phase of result.phases) {
+      const name = phase.name.padEnd(16);
+      const phaseStatus = phase.status.padEnd(11);
+      const gate = (phase.gate_result ?? "-").padEnd(16);
+      lines.push(`${name} ${phaseStatus} ${gate} ${phase.tokens}`);
+    }
+  }
+  if (result.errors.length > 0) {
+    lines.push("");
+    lines.push("Errors:");
+    for (const err of result.errors) {
+      lines.push(`  - ${err}`);
+    }
+  }
+  return lines.join("\n");
+}
+
+// src/commands/run.ts
+var runCommand = defineCommand9({
+  meta: {
+    name: "run",
+    description: "Run a SNIPER protocol in headless mode (for CI/CD)"
+  },
+  args: {
+    protocol: {
+      type: "string",
+      description: "Protocol to run (full, feature, patch, ingest, explore, refactor, hotfix)",
+      required: true
+    },
+    ci: {
+      type: "boolean",
+      description: "CI mode: sets auto-approve, json output, warn-level logging",
+      default: false
+    },
+    "auto-approve": {
+      type: "boolean",
+      description: "Auto-approve all gates",
+      default: false
+    },
+    output: {
+      type: "string",
+      description: "Output format: json, yaml, text",
+      default: "text"
+    },
+    timeout: {
+      type: "string",
+      description: "Timeout in minutes",
+      default: "60"
+    }
+  },
+  run: async ({ args }) => {
+    const cwd = process.cwd();
+    if (!await sniperConfigExists(cwd)) {
+      p9.log.error('SNIPER is not initialized. Run "sniper init" first.');
+      process.exit(4 /* ConfigError */);
+    }
+    const validFormats = ["json", "yaml", "text"];
+    const outputFormat = args.ci ? "json" : args.output ?? "text";
+    if (!validFormats.includes(outputFormat)) {
+      p9.log.error(
+        `Invalid output format: "${outputFormat}". Use: ${validFormats.join(", ")}`
+      );
+      process.exit(4 /* ConfigError */);
+    }
+    const options = {
+      protocol: args.protocol,
+      autoApproveGates: args.ci || args["auto-approve"] || false,
+      outputFormat,
+      logLevel: args.ci ? "warn" : "info",
+      timeoutMinutes: parseInt(args.timeout, 10) || 60,
+      failOnGateFailure: true
+    };
+    const runner = new HeadlessRunner(cwd, options);
+    const result = await runner.run();
+    const output = runner.formatOutput(result);
+    if (result.exitCode === 0 /* Success */) {
+      process.stdout.write(output + "\n");
+    } else {
+      if (result.errors.length > 0) {
+        for (const err of result.errors) {
+          process.stderr.write(`error: ${err}
+`);
+        }
+      }
+      process.stdout.write(output + "\n");
+    }
+    process.exit(result.exitCode);
+  }
+});
+
+// src/commands/marketplace.ts
+import { defineCommand as defineCommand10 } from "citty";
+import * as p10 from "@clack/prompts";
+
+// src/marketplace-client.ts
+import { readFile as readFile11 } from "fs/promises";
+import { join as join12 } from "path";
+function inferSniperType(sniper) {
+  if (!sniper?.type) return null;
+  const t = sniper.type;
+  if (t === "plugin" || t === "agent" || t === "mixin" || t === "pack") {
+    return t;
+  }
+  return null;
+}
+async function searchPackages(query, limit) {
+  const size = limit || 20;
+  const url = `https://registry.npmjs.org/-/v1/search?text=${encodeURIComponent(query)}+keywords:sniper&size=${size}`;
+  const resp = await fetch(url);
+  if (!resp.ok) {
+    throw new Error(`npm registry search failed: ${resp.status}`);
+  }
+  const data = await resp.json();
+  const results = await Promise.all(
+    data.objects.map((obj) => getPackageInfo(obj.package.name))
+  );
+  const packages = results.filter(
+    (info) => info !== null
+  );
+  return { packages, total: packages.length };
+}
+async function getPackageInfo(name) {
+  const url = `https://registry.npmjs.org/${encodeURIComponent(name)}`;
+  const resp = await fetch(url);
+  if (!resp.ok) {
+    if (resp.status === 404) return null;
+    throw new Error(`npm registry fetch failed: ${resp.status}`);
+  }
+  const data = await resp.json();
+  const latest = data["dist-tags"]?.latest;
+  if (!latest || !data.versions?.[latest]) return null;
+  const version2 = data.versions[latest];
+  const sniperType = inferSniperType(version2.sniper);
+  if (!sniperType) return null;
+  return {
+    name: data.name,
+    version: latest,
+    description: version2.description || "",
+    sniperType,
+    tags: version2.keywords || [],
+    author: version2.author?.name
+  };
+}
+async function validatePublishable(cwd) {
+  const errors = [];
+  let pkgJson;
+  try {
+    const raw = await readFile11(join12(cwd, "package.json"), "utf-8");
+    pkgJson = JSON.parse(raw);
+  } catch {
+    return { valid: false, errors: ["No package.json found in current directory"] };
+  }
+  if (!pkgJson.name) {
+    errors.push("package.json is missing a 'name' field");
+  } else if (!pkgJson.name.startsWith("@sniper.ai/") && !pkgJson.name.startsWith("sniper-")) {
+    errors.push(
+      `Package name "${pkgJson.name}" must start with @sniper.ai/ or sniper-`
+    );
+  }
+  if (!pkgJson.sniper?.type) {
+    errors.push("package.json is missing 'sniper.type' field");
+  }
+  if (pkgJson.sniper?.type === "plugin") {
+    try {
+      await readFile11(join12(cwd, "plugin.yaml"), "utf-8");
+    } catch {
+      errors.push("Plugins require a plugin.yaml file in the package root");
+    }
+  }
+  return { valid: errors.length === 0, errors };
+}
+
+// src/commands/marketplace.ts
+var searchSubcommand = defineCommand10({
+  meta: {
+    name: "search",
+    description: "Search the SNIPER marketplace for packages"
+  },
+  args: {
+    query: {
+      type: "positional",
+      description: "Search query",
+      required: true
+    }
+  },
+  run: async ({ args }) => {
+    const s = p10.spinner();
+    s.start("Searching marketplace...");
+    try {
+      const result = await searchPackages(args.query);
+      s.stop("Done!");
+      if (result.packages.length === 0) {
+        p10.log.info("No packages found.");
+        return;
+      }
+      p10.log.step(`Found ${result.total} result(s):`);
+      console.log(
+        `  ${"Name".padEnd(35)} ${"Version".padEnd(10)} ${"Type".padEnd(8)} Description`
+      );
+      console.log(`  ${"\u2500".repeat(35)} ${"\u2500".repeat(10)} ${"\u2500".repeat(8)} ${"\u2500".repeat(30)}`);
+      for (const pkg of result.packages) {
+        const desc = pkg.description.length > 40 ? pkg.description.slice(0, 37) + "..." : pkg.description;
+        console.log(
+          `  ${pkg.name.padEnd(35)} ${pkg.version.padEnd(10)} ${pkg.sniperType.padEnd(8)} ${desc}`
+        );
+      }
+    } catch (err) {
+      s.stop("Failed!");
+      p10.log.error(`Search failed: ${err}`);
+      process.exit(1);
+    }
+  }
+});
+var installSubcommand2 = defineCommand10({
+  meta: {
+    name: "install",
+    description: "Install a package from the SNIPER marketplace"
+  },
+  args: {
+    package: {
+      type: "positional",
+      description: "Package name to install",
+      required: true
+    }
+  },
+  run: async ({ args }) => {
+    const cwd = process.cwd();
+    if (!await sniperConfigExists(cwd)) {
+      p10.log.error('SNIPER is not initialized. Run "sniper init" first.');
+      process.exit(1);
+    }
+    const s = p10.spinner();
+    s.start(`Checking ${args.package}...`);
+    try {
+      const info = await getPackageInfo(args.package);
+      if (!info) {
+        s.stop("Failed!");
+        p10.log.error(
+          `${args.package} is not a valid SNIPER package (not found or missing sniper metadata).`
+        );
+        process.exit(1);
+      }
+      s.message(`Installing ${args.package}...`);
+      const result = await installPlugin(args.package, cwd);
+      s.stop("Done!");
+      p10.log.success(
+        `Installed ${info.sniperType}: ${result.name} v${result.version}`
+      );
+    } catch (err) {
+      s.stop("Failed!");
+      p10.log.error(`Installation failed: ${err}`);
+      process.exit(1);
+    }
+  }
+});
+var infoSubcommand = defineCommand10({
+  meta: {
+    name: "info",
+    description: "Show details about a SNIPER marketplace package"
+  },
+  args: {
+    package: {
+      type: "positional",
+      description: "Package name to inspect",
+      required: true
+    }
+  },
+  run: async ({ args }) => {
+    const s = p10.spinner();
+    s.start(`Fetching info for ${args.package}...`);
+    try {
+      const info = await getPackageInfo(args.package);
+      s.stop("Done!");
+      if (!info) {
+        p10.log.error(
+          `${args.package} not found or is not a SNIPER package.`
+        );
+        process.exit(1);
+      }
+      p10.log.step(`Package: ${info.name}`);
+      console.log(`  Version:     ${info.version}`);
+      console.log(`  Type:        ${info.sniperType}`);
+      console.log(`  Description: ${info.description || "(none)"}`);
+      console.log(`  Tags:        ${info.tags.length > 0 ? info.tags.join(", ") : "(none)"}`);
+      console.log(`  Author:      ${info.author || "(unknown)"}`);
+    } catch (err) {
+      s.stop("Failed!");
+      p10.log.error(`Fetch failed: ${err}`);
+      process.exit(1);
+    }
+  }
+});
+var publishSubcommand = defineCommand10({
+  meta: {
+    name: "publish",
+    description: "Validate and guide publishing a SNIPER package"
+  },
+  run: async () => {
+    const cwd = process.cwd();
+    const s = p10.spinner();
+    s.start("Validating package...");
+    try {
+      const result = await validatePublishable(cwd);
+      s.stop("Done!");
+      if (!result.valid) {
+        p10.log.error("Package is not publishable:");
+        for (const err of result.errors) {
+          console.log(`  - ${err}`);
+        }
+        process.exit(1);
+      }
+      p10.log.success("Package is valid and ready to publish.");
+      p10.log.info('Run "npm publish" to publish your package to the marketplace.');
+    } catch (err) {
+      s.stop("Failed!");
+      p10.log.error(`Validation failed: ${err}`);
+      process.exit(1);
+    }
+  }
+});
+var marketplaceCommand = defineCommand10({
+  meta: {
+    name: "marketplace",
+    description: "Browse and manage SNIPER marketplace packages"
+  },
+  subCommands: {
+    search: searchSubcommand,
+    install: installSubcommand2,
+    info: infoSubcommand,
+    publish: publishSubcommand
+  }
+});
+
+// src/commands/signal.ts
+import { defineCommand as defineCommand11 } from "citty";
+import * as p11 from "@clack/prompts";
+
+// src/signal-collector.ts
+import { readFile as readFile12, writeFile as writeFile6, readdir as readdir6, rm as rm2 } from "fs/promises";
+import { join as join13 } from "path";
+import { execFileSync as execFileSync3 } from "child_process";
+import YAML10 from "yaml";
+var SIGNAL_DIR = ".sniper/memory/signals";
+function getSignalDir(cwd) {
+  return join13(cwd, SIGNAL_DIR);
+}
+function signalFilename(signal) {
+  const date = new Date(signal.timestamp);
+  const dateStr = date.toISOString().slice(0, 10).replace(/-/g, "");
+  const ts = Math.floor(date.getTime() / 1e3);
+  return `${dateStr}-${signal.type}-${ts}.yaml`;
+}
+async function ingestSignal(cwd, signal) {
+  const dir = getSignalDir(cwd);
+  await ensureDir2(dir);
+  const filename = signalFilename(signal);
+  const filepath = join13(dir, filename);
+  const content = YAML10.stringify(signal, { lineWidth: 0 });
+  await writeFile6(filepath, content, "utf-8");
+  return filename;
+}
+function assertGhAvailable() {
+  try {
+    execFileSync3("gh", ["--version"], { stdio: "pipe" });
+  } catch {
+    throw new Error(
+      "GitHub CLI (gh) is not installed or not on PATH. Install it from https://cli.github.com/"
+    );
+  }
+}
+async function ingestFromPR(cwd, prNumber) {
+  assertGhAvailable();
+  const raw = execFileSync3("gh", [
+    "pr",
+    "view",
+    prNumber.toString(),
+    "--json",
+    "comments,reviews,title"
+  ], { cwd, encoding: "utf-8" });
+  const prData = JSON.parse(raw);
+  const signals = [];
+  for (const review of prData.reviews) {
+    if (!review.body) continue;
+    const signal = {
+      type: "pr_review_comment",
+      source: `pr-${prNumber}`,
+      timestamp: review.submittedAt,
+      summary: `PR #${prNumber} review (${review.state}) by ${review.author?.login ?? "unknown"}`,
+      details: review.body,
+      relevance_tags: ["pr-review", review.state.toLowerCase()]
+    };
+    const filename = await ingestSignal(cwd, signal);
+    signals.push(signal);
+  }
+  for (const comment of prData.comments) {
+    const signal = {
+      type: "pr_review_comment",
+      source: `pr-${prNumber}`,
+      timestamp: comment.createdAt,
+      summary: `PR #${prNumber} comment by ${comment.author?.login ?? "unknown"}`,
+      details: comment.body,
+      relevance_tags: ["pr-comment"]
+    };
+    await ingestSignal(cwd, signal);
+    signals.push(signal);
+  }
+  return signals;
+}
+async function listSignals(cwd, options) {
+  const dir = getSignalDir(cwd);
+  if (!await pathExists(dir)) {
+    return [];
+  }
+  const files = await readdir6(dir);
+  const yamlFiles = files.filter((f) => f.endsWith(".yaml"));
+  const signals = [];
+  for (const file of yamlFiles) {
+    const raw = await readFile12(join13(dir, file), "utf-8");
+    const signal = YAML10.parse(raw);
+    signals.push(signal);
+  }
+  let filtered = signals;
+  if (options?.type) {
+    filtered = filtered.filter((s) => s.type === options.type);
+  }
+  filtered.sort(
+    (a, b) => new Date(b.timestamp).getTime() - new Date(a.timestamp).getTime()
+  );
+  if (options?.limit) {
+    filtered = filtered.slice(0, options.limit);
+  }
+  return filtered;
+}
+async function clearSignals(cwd) {
+  const dir = getSignalDir(cwd);
+  if (!await pathExists(dir)) {
+    return 0;
+  }
+  const files = await readdir6(dir);
+  const yamlFiles = files.filter((f) => f.endsWith(".yaml") || f.endsWith(".yml"));
+  for (const file of yamlFiles) {
+    await rm2(join13(dir, file));
+  }
+  return yamlFiles.length;
+}
+
+// src/commands/signal.ts
+var SIGNAL_TYPES = [
+  { value: "ci_failure", label: "CI Failure" },
+  { value: "pr_review_comment", label: "PR Review Comment" },
+  { value: "production_error", label: "Production Error" },
+  { value: "manual", label: "Manual" }
+];
+var ingestSubcommand = defineCommand11({
+  meta: {
+    name: "ingest",
+    description: "Interactively create a new signal record"
+  },
+  run: async () => {
+    const cwd = process.cwd();
+    if (!await sniperConfigExists(cwd)) {
+      p11.log.error('SNIPER is not initialized. Run "sniper init" first.');
+      process.exit(1);
+    }
+    const type = await p11.select({
+      message: "Signal type:",
+      options: SIGNAL_TYPES.map((t) => ({ value: t.value, label: t.label }))
+    });
+    if (p11.isCancel(type)) {
+      p11.cancel("Cancelled.");
+      process.exit(0);
+    }
+    const source = await p11.text({
+      message: "Source (e.g., github-actions, pr-42, datadog):",
+      validate: (v) => v.length === 0 ? "Source is required" : void 0
+    });
+    if (p11.isCancel(source)) {
+      p11.cancel("Cancelled.");
+      process.exit(0);
+    }
+    const summary = await p11.text({
+      message: "Summary (one-line description):",
+      validate: (v) => v.length === 0 ? "Summary is required" : void 0
+    });
+    if (p11.isCancel(summary)) {
+      p11.cancel("Cancelled.");
+      process.exit(0);
+    }
+    const details = await p11.text({
+      message: "Details (optional \u2014 full error message or context):"
+    });
+    if (p11.isCancel(details)) {
+      p11.cancel("Cancelled.");
+      process.exit(0);
+    }
+    const filesInput = await p11.text({
+      message: "Affected files (optional \u2014 comma-separated paths):"
+    });
+    if (p11.isCancel(filesInput)) {
+      p11.cancel("Cancelled.");
+      process.exit(0);
+    }
+    const signal = {
+      type,
+      source,
+      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      summary
+    };
+    if (details && details.length > 0) {
+      signal.details = details;
+    }
+    if (filesInput && filesInput.length > 0) {
+      signal.affected_files = filesInput.split(",").map((f) => f.trim()).filter((f) => f.length > 0);
+    }
+    await ensureDir2(getSignalDir(cwd));
+    const filename = await ingestSignal(cwd, signal);
+    p11.log.success(`Signal captured: ${filename}`);
+  }
+});
+var ingestPrSubcommand = defineCommand11({
+  meta: {
+    name: "ingest-pr",
+    description: "Ingest signals from a GitHub PR's reviews and comments"
+  },
+  args: {
+    "pr-number": {
+      type: "positional",
+      description: "Pull request number",
+      required: true
+    }
+  },
+  run: async ({ args }) => {
+    const cwd = process.cwd();
+    if (!await sniperConfigExists(cwd)) {
+      p11.log.error('SNIPER is not initialized. Run "sniper init" first.');
+      process.exit(1);
+    }
+    const prNumber = parseInt(args["pr-number"], 10);
+    if (isNaN(prNumber)) {
+      p11.log.error("Invalid PR number.");
+      process.exit(1);
+    }
+    const s = p11.spinner();
+    s.start(`Ingesting signals from PR #${prNumber}...`);
+    try {
+      const signals = await ingestFromPR(cwd, prNumber);
+      s.stop("Done!");
+      p11.log.success(`Captured ${signals.length} signal(s) from PR #${prNumber}`);
+      for (const signal of signals) {
+        p11.log.info(`  - ${signal.summary}`);
+      }
+    } catch (err) {
+      s.stop("Failed!");
+      p11.log.error(`Failed to ingest PR signals: ${err}`);
+      process.exit(1);
+    }
+  }
+});
+var listSubcommand3 = defineCommand11({
   meta: {
-    name: "memory",
-    description: "Manage agent memory (conventions, anti-patterns, decisions)"
+    name: "list",
+    description: "List captured signals"
   },
   args: {
-    action: {
-      type: "positional",
-      description: "Action to perform: list, add, remove, promote, export, import",
-      required: false
-    },
     type: {
-      type: "positional",
-      description: "Memory type: convention, anti-pattern, decision (for add/remove/promote)",
+      type: "string",
+      description: "Filter by signal type",
       required: false
     },
-    value: {
-      type: "positional",
-      description: "Value for the action (rule text, ID, or file path)",
-      required: false
+    limit: {
+      type: "string",
+      description: "Maximum number of signals to display",
+      required: false,
+      default: "20"
     }
   },
   run: async ({ args }) => {
     const cwd = process.cwd();
     if (!await sniperConfigExists(cwd)) {
-      p7.log.error(
-        'SNIPER is not initialized in this directory. Run "sniper init" first.'
-      );
+      p11.log.error('SNIPER is not initialized. Run "sniper init" first.');
       process.exit(1);
     }
-    const memoryDir = join4(cwd, ".sniper", "memory");
-    if (!await pathExists2(memoryDir)) {
-      await ensureDir2(memoryDir);
-      await ensureDir2(join4(memoryDir, "retros"));
-      await writeFile3(
-        join4(memoryDir, "conventions.yaml"),
-        "conventions: []\n",
-        "utf-8"
-      );
-      await writeFile3(
-        join4(memoryDir, "anti-patterns.yaml"),
-        "anti_patterns: []\n",
-        "utf-8"
-      );
-      await writeFile3(
-        join4(memoryDir, "decisions.yaml"),
-        "decisions: []\n",
-        "utf-8"
-      );
-      await writeFile3(
-        join4(memoryDir, "estimates.yaml"),
-        "calibration:\n  velocity_factor: 1.0\n  common_underestimates: []\n  last_updated: null\n  sprints_analyzed: 0\n",
-        "utf-8"
-      );
-      p7.log.info("Initialized .sniper/memory/ directory");
+    const limit = parseInt(args.limit, 10) || 20;
+    const signals = await listSignals(cwd, {
+      type: args.type,
+      limit
+    });
+    if (signals.length === 0) {
+      p11.log.info("No signals found.");
+      return;
     }
-    const conventions = await readYamlArray(
-      join4(memoryDir, "conventions.yaml"),
-      "conventions"
-    );
-    const antiPatterns = await readYamlArray(
-      join4(memoryDir, "anti-patterns.yaml"),
-      "anti_patterns"
+    p11.log.step(`Signals (${signals.length}):`);
+    console.log();
+    console.log(
+      "  " + "Type".padEnd(22) + "Source".padEnd(20) + "Timestamp".padEnd(22) + "Summary"
     );
-    const decisions = await readYamlArray(
-      join4(memoryDir, "decisions.yaml"),
-      "decisions"
-    );
-    let retroCount = 0;
-    const retrosDir = join4(memoryDir, "retros");
-    if (await pathExists2(retrosDir)) {
-      const files = await readdir3(retrosDir);
-      retroCount = files.filter((f) => f.endsWith(".yaml")).length;
-    }
-    const action = args.action;
-    if (!action || action === "list") {
-      p7.intro("SNIPER Memory");
-      const confirmedConv = conventions.filter(
-        (c) => c.status !== "candidate"
-      ).length;
-      const candidateConv = conventions.filter(
-        (c) => c.status === "candidate"
-      ).length;
-      const confirmedAp = antiPatterns.filter(
-        (a) => a.status !== "candidate"
-      ).length;
-      const candidateAp = antiPatterns.filter(
-        (a) => a.status === "candidate"
-      ).length;
-      const activeDecisions = decisions.filter(
-        (d) => d.status === "active" || !d.status
-      ).length;
-      const supersededDecisions = decisions.filter(
-        (d) => d.status === "superseded"
-      ).length;
-      p7.log.info(
-        `Conventions:   ${confirmedConv} confirmed, ${candidateConv} candidates`
-      );
-      p7.log.info(
-        `Anti-Patterns: ${confirmedAp} confirmed, ${candidateAp} candidates`
+    console.log("  " + "-".repeat(90));
+    for (const signal of signals) {
+      const ts = new Date(signal.timestamp).toISOString().slice(0, 19).replace("T", " ");
+      console.log(
+        "  " + signal.type.padEnd(22) + signal.source.padEnd(20) + ts.padEnd(22) + signal.summary.slice(0, 50)
       );
-      p7.log.info(
-        `Decisions:     ${activeDecisions} active, ${supersededDecisions} superseded`
-      );
-      p7.log.info(`Retrospectives: ${retroCount}`);
-      const config = await readConfig(cwd);
-      if (config.workspace?.enabled && config.workspace.workspace_path) {
-        const wsMemory = join4(
-          cwd,
-          config.workspace.workspace_path,
-          "memory"
-        );
-        if (await pathExists2(wsMemory)) {
-          const wsConv = await readYamlArray(
-            join4(wsMemory, "conventions.yaml"),
-            "conventions"
-          );
-          const wsAp = await readYamlArray(
-            join4(wsMemory, "anti-patterns.yaml"),
-            "anti_patterns"
-          );
-          const wsDec = await readYamlArray(
-            join4(wsMemory, "decisions.yaml"),
-            "decisions"
-          );
-          p7.log.step("Workspace Memory:");
-          p7.log.info(`  Conventions:   ${wsConv.length}`);
-          p7.log.info(`  Anti-Patterns: ${wsAp.length}`);
-          p7.log.info(`  Decisions:     ${wsDec.length}`);
-        }
-      }
-      p7.outro("");
-      return;
     }
-    if (action === "add") {
-      const type = args.type;
-      const value = args.value;
-      if (!type || !value) {
-        p7.log.error(
-          'Usage: sniper memory add <convention|anti-pattern|decision> "<text>"'
-        );
-        process.exit(1);
-      }
-      const today = (/* @__PURE__ */ new Date()).toISOString().split("T")[0];
-      if (type === "convention") {
-        const id = nextId(conventions, "conv");
-        conventions.push({
-          id,
-          rule: value,
-          rationale: "",
-          source: { type: "manual", ref: "user-added", date: today },
-          applies_to: [],
-          enforcement: "both",
-          scope: "project",
-          status: "confirmed",
-          examples: { positive: "", negative: "" }
-        });
-        await writeYamlArray(
-          join4(memoryDir, "conventions.yaml"),
-          "conventions",
-          conventions
-        );
-        p7.log.success(`Added convention ${id}: ${value}`);
-      } else if (type === "anti-pattern") {
-        const id = nextId(antiPatterns, "ap");
-        antiPatterns.push({
-          id,
-          description: value,
-          why_bad: "",
-          fix_pattern: "",
-          source: { type: "manual", ref: "user-added", date: today },
-          detection_hint: "",
-          applies_to: [],
-          severity: "medium",
-          status: "confirmed"
-        });
-        await writeYamlArray(
-          join4(memoryDir, "anti-patterns.yaml"),
-          "anti_patterns",
-          antiPatterns
-        );
-        p7.log.success(`Added anti-pattern ${id}: ${value}`);
-      } else if (type === "decision") {
-        const id = nextId(decisions, "dec");
-        decisions.push({
-          id,
-          title: value,
-          context: "",
-          decision: value,
-          alternatives_considered: [],
-          source: { type: "manual", ref: "user-added", date: today },
-          applies_to: [],
-          status: "active",
-          superseded_by: null
-        });
-        await writeYamlArray(
-          join4(memoryDir, "decisions.yaml"),
-          "decisions",
-          decisions
-        );
-        p7.log.success(`Added decision ${id}: ${value}`);
-      } else {
-        p7.log.error(
-          `Unknown memory type "${type}". Use: convention, anti-pattern, decision`
-        );
-        process.exit(1);
-      }
-      return;
+  }
+});
+var clearSubcommand = defineCommand11({
+  meta: {
+    name: "clear",
+    description: "Delete all captured signals"
+  },
+  run: async () => {
+    const cwd = process.cwd();
+    if (!await sniperConfigExists(cwd)) {
+      p11.log.error('SNIPER is not initialized. Run "sniper init" first.');
+      process.exit(1);
     }
-    if (action === "remove") {
-      const id = args.type;
-      if (!id) {
-        p7.log.error("Usage: sniper memory remove <id>");
-        process.exit(1);
-      }
-      let found = false;
-      if (id.startsWith("conv-")) {
-        const idx = conventions.findIndex((c) => c.id === id);
-        if (idx >= 0) {
-          conventions.splice(idx, 1);
-          await writeYamlArray(
-            join4(memoryDir, "conventions.yaml"),
-            "conventions",
-            conventions
-          );
-          found = true;
-        }
-      } else if (id.startsWith("ap-")) {
-        const idx = antiPatterns.findIndex((a) => a.id === id);
-        if (idx >= 0) {
-          antiPatterns.splice(idx, 1);
-          await writeYamlArray(
-            join4(memoryDir, "anti-patterns.yaml"),
-            "anti_patterns",
-            antiPatterns
-          );
-          found = true;
-        }
-      } else if (id.startsWith("dec-")) {
-        const idx = decisions.findIndex((d) => d.id === id);
-        if (idx >= 0) {
-          decisions.splice(idx, 1);
-          await writeYamlArray(
-            join4(memoryDir, "decisions.yaml"),
-            "decisions",
-            decisions
-          );
-          found = true;
-        }
-      }
-      if (found) {
-        p7.log.success(`Removed ${id}`);
-      } else {
-        p7.log.error(`Entry ${id} not found in memory.`);
-        process.exit(1);
-      }
-      return;
+    const confirm6 = await p11.confirm({
+      message: "Delete all captured signals? This cannot be undone."
+    });
+    if (p11.isCancel(confirm6) || !confirm6) {
+      p11.cancel("Cancelled.");
+      process.exit(0);
     }
-    if (action === "promote") {
-      const id = args.type;
-      if (!id) {
-        p7.log.error("Usage: sniper memory promote <id>");
-        process.exit(1);
-      }
-      let found = false;
-      if (id.startsWith("conv-")) {
-        const entry = conventions.find((c) => c.id === id);
-        if (entry && entry.status === "candidate") {
-          entry.status = "confirmed";
-          await writeYamlArray(
-            join4(memoryDir, "conventions.yaml"),
-            "conventions",
-            conventions
-          );
-          found = true;
-        }
-      } else if (id.startsWith("ap-")) {
-        const entry = antiPatterns.find((a) => a.id === id);
-        if (entry && entry.status === "candidate") {
-          entry.status = "confirmed";
-          await writeYamlArray(
-            join4(memoryDir, "anti-patterns.yaml"),
-            "anti_patterns",
-            antiPatterns
-          );
-          found = true;
-        }
-      } else if (id.startsWith("dec-")) {
-        const entry = decisions.find((d) => d.id === id);
-        if (entry && entry.status === "candidate") {
-          entry.status = "active";
-          await writeYamlArray(
-            join4(memoryDir, "decisions.yaml"),
-            "decisions",
-            decisions
-          );
-          found = true;
-        }
-      }
-      if (found) {
-        p7.log.success(`Promoted ${id} to confirmed/active`);
-      } else {
-        p7.log.error(
-          `Entry ${id} not found or is not a candidate.`
-        );
-        process.exit(1);
-      }
-      return;
+    const count = await clearSignals(cwd);
+    p11.log.success(`Cleared ${count} signal(s).`);
+  }
+});
+var signalCommand = defineCommand11({
+  meta: {
+    name: "signal",
+    description: "Manage external signal learning"
+  },
+  subCommands: {
+    ingest: ingestSubcommand,
+    "ingest-pr": ingestPrSubcommand,
+    list: listSubcommand3,
+    clear: clearSubcommand
+  }
+});
+
+// src/commands/knowledge.ts
+import { defineCommand as defineCommand12 } from "citty";
+import * as p12 from "@clack/prompts";
+import { join as join14 } from "path";
+import { readFile as readFile13 } from "fs/promises";
+var KNOWLEDGE_DIR = ".sniper/knowledge";
+var INDEX_FILENAME = "knowledge-index.json";
+var indexSubcommand = defineCommand12({
+  meta: {
+    name: "index",
+    description: "Index the SNIPER knowledge base"
+  },
+  run: async () => {
+    const cwd = process.cwd();
+    if (!await sniperConfigExists(cwd)) {
+      p12.log.error('SNIPER is not initialized. Run "sniper init" first.');
+      process.exit(1);
     }
-    if (action === "export") {
-      const exportData = {
-        exported_from: (await readConfig(cwd)).project.name,
-        exported_at: (/* @__PURE__ */ new Date()).toISOString(),
-        version: "1.0",
-        conventions: conventions.map(({ id: _id, source: _src, ...rest }) => rest),
-        anti_patterns: antiPatterns.map(
-          ({ id: _id, source: _src, ...rest }) => rest
-        ),
-        decisions: decisions.map(({ id: _id, source: _src, ...rest }) => rest)
-      };
-      const exportPath = join4(cwd, "sniper-memory-export.yaml");
-      await writeFile3(
-        exportPath,
-        YAML4.stringify(exportData, { lineWidth: 0 }),
-        "utf-8"
+    const knowledgeDir = join14(cwd, KNOWLEDGE_DIR);
+    if (!await pathExists(knowledgeDir)) {
+      p12.log.error(
+        `Knowledge directory not found: ${KNOWLEDGE_DIR}
+Create it and add .md files to index.`
       );
-      p7.log.success(
-        `Exported ${conventions.length} conventions, ${antiPatterns.length} anti-patterns, ${decisions.length} decisions to sniper-memory-export.yaml`
-      );
-      return;
+      process.exit(1);
     }
-    if (action === "import") {
-      const filePath = args.type;
-      if (!filePath) {
-        p7.log.error("Usage: sniper memory import <file>");
-        process.exit(1);
-      }
-      const raw = await readFile4(join4(cwd, filePath), "utf-8");
-      const imported = YAML4.parse(raw);
-      let addedConv = 0;
-      let addedAp = 0;
-      let skipped = 0;
-      const today = (/* @__PURE__ */ new Date()).toISOString().split("T")[0];
-      if (Array.isArray(imported.conventions)) {
-        for (const conv of imported.conventions) {
-          const exists = conventions.some(
-            (c) => c.rule === conv.rule
-          );
-          if (exists) {
-            skipped++;
-            continue;
-          }
-          conventions.push({
-            ...conv,
-            id: nextId(conventions, "conv"),
-            source: { type: "imported", ref: filePath, date: today },
-            status: "candidate"
-          });
-          addedConv++;
-        }
-        await writeYamlArray(
-          join4(memoryDir, "conventions.yaml"),
-          "conventions",
-          conventions
-        );
-      }
-      if (Array.isArray(imported.anti_patterns)) {
-        for (const ap of imported.anti_patterns) {
-          const exists = antiPatterns.some(
-            (a) => a.description === ap.description
-          );
-          if (exists) {
-            skipped++;
-            continue;
-          }
-          antiPatterns.push({
-            ...ap,
-            id: nextId(antiPatterns, "ap"),
-            source: { type: "imported", ref: filePath, date: today },
-            status: "candidate"
-          });
-          addedAp++;
-        }
-        await writeYamlArray(
-          join4(memoryDir, "anti-patterns.yaml"),
-          "anti_patterns",
-          antiPatterns
-        );
-      }
-      p7.log.success(
-        `Imported ${addedConv} conventions, ${addedAp} anti-patterns (${skipped} skipped as duplicates)`
-      );
-      return;
+    const s = p12.spinner();
+    s.start("Indexing knowledge base...");
+    try {
+      const { indexKnowledgeDir, writeIndex } = await import("@sniper.ai/mcp-knowledge/indexer");
+      const index = await indexKnowledgeDir(knowledgeDir);
+      const indexPath = join14(knowledgeDir, INDEX_FILENAME);
+      await writeIndex(indexPath, index);
+      s.stop("Done!");
+      p12.log.success(`Indexed ${index.entries.length} entries`);
+      p12.log.info(`Total tokens: ${index.total_tokens.toLocaleString()}`);
+      p12.log.info(`Index written to: ${KNOWLEDGE_DIR}/${INDEX_FILENAME}`);
+    } catch (err) {
+      s.stop("Failed!");
+      p12.log.error(`Indexing failed: ${err}`);
+      process.exit(1);
     }
-    p7.log.error(
-      `Unknown action "${action}". Use: list, add, remove, promote, export, import`
-    );
-    process.exit(1);
   }
 });
-
-// src/commands/workspace.ts
-import {
-  readFile as readFile5,
-  writeFile as writeFile4,
-  readdir as readdir4,
-  stat as stat2,
-  symlink
-} from "fs/promises";
-import { join as join5, relative, resolve as resolve2 } from "path";
-import { defineCommand as defineCommand8 } from "citty";
-import * as p8 from "@clack/prompts";
-import YAML5 from "yaml";
-var initSubCommand = defineCommand8({
+var statusSubcommand2 = defineCommand12({
   meta: {
-    name: "init",
-    description: "Initialize a SNIPER workspace"
+    name: "status",
+    description: "Show knowledge base status"
   },
   run: async () => {
     const cwd = process.cwd();
-    if (await pathExists2(join5(cwd, "workspace.yaml"))) {
-      const raw = await readFile5(join5(cwd, "workspace.yaml"), "utf-8");
-      const ws = YAML5.parse(raw);
-      p8.log.warn(
-        `A workspace already exists: ${ws.name} (${ws.repositories.length} repos)`
-      );
-      p8.log.info("Use /sniper-workspace status to view details.");
-      process.exit(0);
-    }
-    p8.intro("Initialize SNIPER Workspace");
-    const name = await p8.text({
-      message: "Workspace name:",
-      placeholder: "my-saas-platform"
-    });
-    if (p8.isCancel(name)) {
-      p8.cancel("Aborted.");
-      process.exit(0);
+    if (!await sniperConfigExists(cwd)) {
+      p12.log.error('SNIPER is not initialized. Run "sniper init" first.');
+      process.exit(1);
     }
-    const description = await p8.text({
-      message: "Description:",
-      placeholder: "Multi-service SaaS platform"
-    });
-    if (p8.isCancel(description)) {
-      p8.cancel("Aborted.");
-      process.exit(0);
+    const indexPath = join14(cwd, KNOWLEDGE_DIR, INDEX_FILENAME);
+    if (!await pathExists(indexPath)) {
+      p12.log.warn(
+        'Knowledge base has not been indexed yet. Run "sniper knowledge index" first.'
+      );
+      return;
     }
-    const s = p8.spinner();
-    s.start("Scanning for SNIPER-enabled repositories...");
-    const parentDir = resolve2(cwd, "..");
-    const repos = [];
     try {
-      const siblings = await readdir4(parentDir);
-      for (const entry of siblings) {
-        const entryPath = join5(parentDir, entry);
-        const entryStat = await stat2(entryPath);
-        if (!entryStat.isDirectory()) continue;
-        if (resolve2(entryPath) === resolve2(cwd)) continue;
-        const configPath = join5(entryPath, ".sniper", "config.yaml");
-        if (await pathExists2(configPath)) {
-          try {
-            const raw = await readFile5(configPath, "utf-8");
-            const config = YAML5.parse(raw);
-            repos.push({
-              name: config.project?.name || entry,
-              path: relative(cwd, entryPath),
-              role: inferRole(config.project?.type),
-              language: config.stack?.language || "unknown",
-              sniper_enabled: true,
-              exposes: [],
-              consumes: []
-            });
-          } catch {
-          }
+      const raw = await readFile13(indexPath, "utf-8");
+      const index = JSON.parse(raw);
+      const topics = [...new Set(index.entries.map((e) => e.topic))];
+      p12.log.step("Knowledge Base Status:");
+      console.log(`  Entries:      ${index.entries.length}`);
+      console.log(`  Topics:       ${topics.length}`);
+      console.log(
+        `  Total tokens: ${index.total_tokens.toLocaleString()}`
+      );
+      console.log(`  Last indexed: ${index.indexed_at}`);
+      if (topics.length > 0) {
+        p12.log.step("Topics:");
+        for (const topic of topics.slice(0, 20)) {
+          const count = index.entries.filter((e) => e.topic === topic).length;
+          console.log(`  - ${topic} (${count} entries)`);
+        }
+        if (topics.length > 20) {
+          console.log(`  ... and ${topics.length - 20} more`);
         }
       }
-    } catch {
+    } catch (err) {
+      p12.log.error(`Failed to read index: ${err}`);
+      process.exit(1);
     }
-    s.stop(`Found ${repos.length} SNIPER-enabled repositories`);
-    if (repos.length === 0) {
-      p8.log.warn(
-        "No SNIPER-enabled repositories found in sibling directories."
-      );
-      p8.log.info(
-        'Initialize SNIPER in your repos first with "sniper init", or add repos manually later.'
+  }
+});
+var knowledgeCommand = defineCommand12({
+  meta: {
+    name: "knowledge",
+    description: "Manage SNIPER knowledge base"
+  },
+  subCommands: {
+    index: indexSubcommand,
+    status: statusSubcommand2
+  }
+});
+
+// src/commands/sphere.ts
+import { defineCommand as defineCommand13 } from "citty";
+import * as p13 from "@clack/prompts";
+
+// src/conflict-detector.ts
+import { readFile as readFile14, writeFile as writeFile7, readdir as readdir7, mkdir as mkdir6, rm as rm3 } from "fs/promises";
+import { join as join15 } from "path";
+import YAML11 from "yaml";
+var WORKSPACE_DIR2 = ".sniper-workspace";
+var LOCKS_DIR = "locks";
+function encodeLockFilename(file) {
+  return file.replace(/%/g, "%25").replace(/\//g, "%2F").replace(/\\/g, "%5C") + ".yaml";
+}
+function locksDir(workspaceRoot) {
+  return join15(workspaceRoot, WORKSPACE_DIR2, LOCKS_DIR);
+}
+async function createLock(workspaceRoot, file, project, agent, protocol, reason) {
+  const dir = locksDir(workspaceRoot);
+  await mkdir6(dir, { recursive: true });
+  const lock = {
+    file,
+    locked_by: { project, agent, protocol },
+    since: (/* @__PURE__ */ new Date()).toISOString(),
+    ...reason ? { reason } : {}
+  };
+  const lockPath = join15(dir, encodeLockFilename(file));
+  try {
+    await writeFile7(lockPath, YAML11.stringify(lock, { lineWidth: 0 }), {
+      encoding: "utf-8",
+      flag: "wx"
+    });
+  } catch (err) {
+    if (err && typeof err === "object" && "code" in err && err.code === "EEXIST") {
+      throw new Error(
+        `Lock already exists for "${file}". Another agent may be modifying this file.`
       );
-    } else {
-      for (const repo of repos) {
-        p8.log.info(`  ${repo.name} (${repo.role}, ${repo.language}) ${repo.path}`);
-      }
     }
-    const depGraph = {};
-    for (const repo of repos) {
-      depGraph[repo.name] = [];
-    }
-    const workspace = {
-      name,
-      description,
-      version: "1.0",
-      repositories: repos,
-      dependency_graph: depGraph,
-      config: {
-        contract_format: "yaml",
-        integration_validation: true,
-        shared_domain_packs: [],
-        memory: {
-          workspace_conventions: true,
-          auto_promote: false
-        }
-      },
-      state: {
-        feature_counter: 1,
-        features: []
-      }
-    };
-    await writeFile4(
-      join5(cwd, "workspace.yaml"),
-      YAML5.stringify(workspace, { lineWidth: 0 }),
-      "utf-8"
-    );
-    await ensureDir2(join5(cwd, "memory"));
-    await writeFile4(
-      join5(cwd, "memory", "conventions.yaml"),
-      "conventions: []\n",
-      "utf-8"
-    );
-    await writeFile4(
-      join5(cwd, "memory", "anti-patterns.yaml"),
-      "anti_patterns: []\n",
-      "utf-8"
-    );
-    await writeFile4(
-      join5(cwd, "memory", "decisions.yaml"),
-      "decisions: []\n",
-      "utf-8"
-    );
-    await ensureDir2(join5(cwd, "contracts"));
-    await writeFile4(join5(cwd, "contracts", ".gitkeep"), "", "utf-8");
-    await ensureDir2(join5(cwd, "features"));
-    await writeFile4(join5(cwd, "features", ".gitkeep"), "", "utf-8");
-    if (repos.length > 0) {
-      await ensureDir2(join5(cwd, "repositories"));
-      for (const repo of repos) {
-        const linkPath = join5(cwd, "repositories", repo.name);
-        const targetPath = resolve2(cwd, repo.path);
-        if (!await pathExists2(linkPath)) {
-          try {
-            await symlink(targetPath, linkPath);
-          } catch {
-          }
-        }
+    throw err;
+  }
+}
+async function releaseLock(workspaceRoot, file, owner) {
+  const lockPath = join15(locksDir(workspaceRoot), encodeLockFilename(file));
+  if (await pathExists(lockPath)) {
+    if (owner) {
+      const raw = await readFile14(lockPath, "utf-8");
+      const lock = YAML11.parse(raw);
+      if (lock?.locked_by?.agent !== owner && lock?.locked_by?.project !== owner) {
+        throw new Error(
+          `Cannot release lock for "${file}": owned by agent "${lock?.locked_by?.agent}" / project "${lock?.locked_by?.project}", not "${owner}"`
+        );
       }
     }
-    for (const repo of repos) {
-      const repoDir = resolve2(cwd, repo.path);
-      try {
-        const config = await readConfig(repoDir);
-        config.workspace = {
-          enabled: true,
-          workspace_path: relative(repoDir, cwd),
-          repo_name: repo.name
-        };
-        await writeConfig(repoDir, config);
-      } catch {
-        p8.log.warn(`Could not update config for ${repo.name}`);
-      }
+    await rm3(lockPath);
+    return true;
+  }
+  return false;
+}
+async function readLocks(workspaceRoot) {
+  const dir = locksDir(workspaceRoot);
+  if (!await pathExists(dir)) {
+    return [];
+  }
+  const files = await readdir7(dir);
+  const yamlFiles = files.filter(
+    (f) => f.endsWith(".yaml") || f.endsWith(".yml")
+  );
+  const locks = [];
+  for (const file of yamlFiles) {
+    const raw = await readFile14(join15(dir, file), "utf-8");
+    const data = YAML11.parse(raw);
+    if (data && data.file && data.locked_by) {
+      locks.push(data);
     }
-    p8.log.success("Workspace initialized!");
-    p8.log.info(`  Location: ${cwd}`);
-    p8.log.info(`  Repos: ${repos.length}`);
-    p8.log.info("");
-    p8.log.info("Next steps:");
-    p8.log.info(
-      '  /sniper-workspace feature "description"  \u2014 Plan a cross-repo feature'
-    );
-    p8.log.info(
-      "  /sniper-workspace status                 \u2014 View workspace status"
-    );
-    p8.outro("");
   }
-});
-var statusSubCommand = defineCommand8({
+  return locks;
+}
+async function checkConflicts(workspaceRoot, filesToModify, project) {
+  const locks = await readLocks(workspaceRoot);
+  const conflicts = [];
+  const normalizedFiles = filesToModify.map((f) => f.replace(/\\/g, "/"));
+  for (const lock of locks) {
+    const normalizedLockFile = lock.file.replace(/\\/g, "/");
+    if (normalizedFiles.includes(normalizedLockFile) && lock.locked_by.project !== project) {
+      conflicts.push({
+        file: lock.file,
+        held_by: lock.locked_by,
+        requested_by: {
+          project,
+          agent: "unknown",
+          protocol: "unknown"
+        }
+      });
+    }
+  }
+  return conflicts;
+}
+
+// src/commands/sphere.ts
+import { execFileSync as execFileSync4 } from "child_process";
+import { basename as basename2 } from "path";
+var WORKSPACE_ERROR = "No workspace found. Sphere 7 requires a workspace. Run `sniper workspace init` first.";
+var statusSubcommand3 = defineCommand13({
   meta: {
     name: "status",
-    description: "Show workspace status"
+    description: "Show active file locks and dependency graph summary"
   },
   run: async () => {
     const cwd = process.cwd();
-    const wsPath = join5(cwd, "workspace.yaml");
-    if (!await pathExists2(wsPath)) {
-      p8.log.error(
-        "No workspace found. Run /sniper-workspace init to create one."
-      );
+    const wsRoot = await findWorkspaceRoot(cwd);
+    if (!wsRoot) {
+      p13.log.error(WORKSPACE_ERROR);
       process.exit(1);
     }
-    const raw = await readFile5(wsPath, "utf-8");
-    const ws = YAML5.parse(raw);
-    p8.intro(`Workspace: ${ws.name}`);
-    p8.log.info(ws.description);
-    p8.log.step("Repositories:");
-    for (const repo of ws.repositories) {
-      const repoPath = resolve2(cwd, repo.path);
-      const accessible = await pathExists2(repoPath);
-      const icon = accessible ? "\u2713" : "\u2717";
-      p8.log.info(
-        `  ${icon} ${repo.name.padEnd(20)} ${repo.role.padEnd(12)} ${repo.language}`
-      );
-    }
-    const activeFeatures = ws.state.features.filter(
-      (f) => f.phase !== "complete"
-    );
-    if (activeFeatures.length > 0) {
-      p8.log.step("Active Features:");
-      for (const f of activeFeatures) {
-        p8.log.info(
-          `  ${f.id}  "${f.title}"  Phase: ${f.phase}${f.sprint_wave ? `  Wave: ${f.sprint_wave}` : ""}`
-        );
-      }
+    p13.intro("Sphere 7 \u2014 Workspace Status");
+    const locks = await readLocks(wsRoot);
+    p13.log.step(`Active locks: ${locks.length}`);
+    if (locks.length === 0) {
+      console.log("  (none)");
     } else {
-      p8.log.step("No active workspace features.");
-    }
-    const contractsDir = join5(cwd, "contracts");
-    if (await pathExists2(contractsDir)) {
-      const files = (await readdir4(contractsDir)).filter(
-        (f) => f.endsWith(".contract.yaml")
-      );
-      if (files.length > 0) {
-        p8.log.step("Contracts:");
-        for (const file of files) {
-          try {
-            const cRaw = await readFile5(join5(contractsDir, file), "utf-8");
-            const contract = YAML5.parse(cRaw);
-            const name = contract.contract?.name || file;
-            const version2 = contract.contract?.version || "?";
-            const between = contract.contract?.between?.join(" \u2194 ") || "?";
-            p8.log.info(`  ${name}  v${version2}  ${between}`);
-          } catch {
-            p8.log.info(`  ${file}  (parse error)`);
-          }
-        }
-      } else {
-        p8.log.step("No contracts defined.");
-      }
-    }
-    const memDir = join5(cwd, "memory");
-    if (await pathExists2(memDir)) {
-      const convFile = join5(memDir, "conventions.yaml");
-      const apFile = join5(memDir, "anti-patterns.yaml");
-      const decFile = join5(memDir, "decisions.yaml");
-      let convCount = 0;
-      let apCount = 0;
-      let decCount = 0;
-      if (await pathExists2(convFile)) {
-        try {
-          const parsed = YAML5.parse(await readFile5(convFile, "utf-8"));
-          convCount = Array.isArray(parsed?.conventions) ? parsed.conventions.length : 0;
-        } catch {
-        }
-      }
-      if (await pathExists2(apFile)) {
-        try {
-          const parsed = YAML5.parse(await readFile5(apFile, "utf-8"));
-          apCount = Array.isArray(parsed?.anti_patterns) ? parsed.anti_patterns.length : 0;
-        } catch {
-        }
-      }
-      if (await pathExists2(decFile)) {
-        try {
-          const parsed = YAML5.parse(await readFile5(decFile, "utf-8"));
-          decCount = Array.isArray(parsed?.decisions) ? parsed.decisions.length : 0;
-        } catch {
-        }
+      for (const lock of locks) {
+        const age = timeSince(lock.since);
+        const reason = lock.reason ? ` \u2014 ${lock.reason}` : "";
+        console.log(
+          `  ${lock.file}  locked by ${lock.locked_by.project}/${lock.locked_by.agent} (${age})${reason}`
+        );
       }
-      p8.log.step("Workspace Memory:");
-      p8.log.info(`  Conventions:   ${convCount}`);
-      p8.log.info(`  Anti-Patterns: ${apCount}`);
-      p8.log.info(`  Decisions:     ${decCount}`);
     }
-    p8.outro("");
+    p13.outro("");
   }
 });
-var addRepoSubCommand = defineCommand8({
+var lockSubcommand = defineCommand13({
   meta: {
-    name: "add-repo",
-    description: "Add a repository to the workspace"
+    name: "lock",
+    description: "Acquire an advisory lock on a file"
   },
   args: {
-    path: {
+    file: {
       type: "positional",
-      description: "Path to the repository",
+      description: "File path to lock",
       required: true
+    },
+    reason: {
+      type: "string",
+      description: "Reason for acquiring the lock",
+      required: false
     }
   },
   run: async ({ args }) => {
     const cwd = process.cwd();
-    const wsPath = join5(cwd, "workspace.yaml");
-    if (!await pathExists2(wsPath)) {
-      p8.log.error("No workspace found. Run /sniper-workspace init first.");
+    const wsRoot = await findWorkspaceRoot(cwd);
+    if (!wsRoot) {
+      p13.log.error(WORKSPACE_ERROR);
       process.exit(1);
     }
-    const repoPath = resolve2(cwd, args.path);
-    if (!await sniperConfigExists(repoPath)) {
-      p8.log.error(
-        `${repoPath} is not a SNIPER-enabled project. Run "sniper init" in that directory first.`
+    const project = basename2(cwd);
+    try {
+      await createLock(
+        wsRoot,
+        args.file,
+        project,
+        "cli",
+        "manual",
+        args.reason
       );
+      p13.log.success(`Locked: ${args.file}`);
+    } catch (err) {
+      p13.log.error(`Failed to acquire lock: ${err}`);
       process.exit(1);
     }
-    const repoConfig = await readConfig(repoPath);
-    const raw = await readFile5(wsPath, "utf-8");
-    const ws = YAML5.parse(raw);
-    const repoName = repoConfig.project.name;
-    if (ws.repositories.some((r) => r.name === repoName)) {
-      p8.log.warn(`Repository "${repoName}" is already in the workspace.`);
-      process.exit(0);
-    }
-    ws.repositories.push({
-      name: repoName,
-      path: relative(cwd, repoPath),
-      role: inferRole(repoConfig.project.type),
-      language: repoConfig.stack.language,
-      sniper_enabled: true,
-      exposes: [],
-      consumes: []
-    });
-    ws.dependency_graph[repoName] = [];
-    await writeFile4(wsPath, YAML5.stringify(ws, { lineWidth: 0 }), "utf-8");
-    repoConfig.workspace = {
-      enabled: true,
-      workspace_path: relative(repoPath, cwd),
-      repo_name: repoName
-    };
-    await writeConfig(repoPath, repoConfig);
-    p8.log.success(
-      `Added ${repoName} (${repoConfig.project.type}, ${repoConfig.stack.language})`
-    );
   }
 });
-var removeRepoSubCommand = defineCommand8({
+var unlockSubcommand = defineCommand13({
   meta: {
-    name: "remove-repo",
-    description: "Remove a repository from the workspace"
+    name: "unlock",
+    description: "Release an advisory lock on a file"
   },
   args: {
-    name: {
+    file: {
       type: "positional",
-      description: "Repository name",
+      description: "File path to unlock",
       required: true
     }
   },
   run: async ({ args }) => {
     const cwd = process.cwd();
-    const wsPath = join5(cwd, "workspace.yaml");
-    if (!await pathExists2(wsPath)) {
-      p8.log.error("No workspace found.");
-      process.exit(1);
-    }
-    const raw = await readFile5(wsPath, "utf-8");
-    const ws = YAML5.parse(raw);
-    const repoName = args.name;
-    const idx = ws.repositories.findIndex((r) => r.name === repoName);
-    if (idx < 0) {
-      p8.log.error(`Repository "${repoName}" not found in workspace.`);
+    const wsRoot = await findWorkspaceRoot(cwd);
+    if (!wsRoot) {
+      p13.log.error(WORKSPACE_ERROR);
       process.exit(1);
     }
-    const repo = ws.repositories[idx];
-    ws.repositories.splice(idx, 1);
-    delete ws.dependency_graph[repoName];
-    for (const deps of Object.values(ws.dependency_graph)) {
-      const depIdx = deps.indexOf(repoName);
-      if (depIdx >= 0) deps.splice(depIdx, 1);
-    }
-    await writeFile4(wsPath, YAML5.stringify(ws, { lineWidth: 0 }), "utf-8");
-    const repoPath = resolve2(cwd, repo.path);
-    try {
-      const repoConfig = await readConfig(repoPath);
-      repoConfig.workspace = {
-        enabled: false,
-        workspace_path: null,
-        repo_name: null
-      };
-      await writeConfig(repoPath, repoConfig);
-    } catch {
+    const released = await releaseLock(wsRoot, args.file);
+    if (released) {
+      p13.log.success(`Unlocked: ${args.file}`);
+    } else {
+      p13.log.warning(`No lock found for: ${args.file}`);
     }
-    p8.log.success(`Removed ${repoName} from workspace.`);
   }
 });
-var validateSubCommand = defineCommand8({
+var conflictsSubcommand = defineCommand13({
   meta: {
-    name: "validate",
-    description: "Validate interface contracts against implementations"
+    name: "conflicts",
+    description: "Detect file lock conflicts with current changes"
   },
   run: async () => {
     const cwd = process.cwd();
-    const wsPath = join5(cwd, "workspace.yaml");
-    if (!await pathExists2(wsPath)) {
-      p8.log.error("No workspace found.");
+    const wsRoot = await findWorkspaceRoot(cwd);
+    if (!wsRoot) {
+      p13.log.error(WORKSPACE_ERROR);
       process.exit(1);
     }
-    const contractsDir = join5(cwd, "contracts");
-    if (!await pathExists2(contractsDir)) {
-      p8.log.error("No contracts/ directory found.");
+    p13.intro("Sphere 7 \u2014 Conflict Detection");
+    let changedFiles;
+    try {
+      const output = execFileSync4("git", ["diff", "--name-only"], {
+        cwd,
+        encoding: "utf-8"
+      });
+      changedFiles = output.split("\n").map((f) => f.trim()).filter(Boolean);
+    } catch {
+      p13.log.error("Failed to get changed files from git.");
       process.exit(1);
     }
-    const files = (await readdir4(contractsDir)).filter(
-      (f) => f.endsWith(".contract.yaml")
-    );
-    if (files.length === 0) {
-      p8.log.info("No contracts found. Create them with /sniper-workspace feature.");
-      process.exit(0);
+    if (changedFiles.length === 0) {
+      p13.log.info("No changed files detected.");
+      p13.outro("");
+      return;
     }
-    p8.intro("Contract Validation");
-    for (const file of files) {
-      try {
-        const raw = await readFile5(join5(contractsDir, file), "utf-8");
-        const contract = YAML5.parse(raw);
-        const name = contract.contract?.name || file;
-        const version2 = contract.contract?.version || "?";
-        const endpoints = contract.endpoints?.length || 0;
-        const types = contract.shared_types?.length || 0;
-        const events = contract.events?.length || 0;
-        p8.log.info(
-          `${name} v${version2}: ${endpoints} endpoints, ${types} types, ${events} events`
-        );
-        p8.log.info(
-          "  (Structural validation requires running /sniper-workspace validate as a slash command)"
+    p13.log.step(`Changed files: ${changedFiles.length}`);
+    const project = basename2(cwd);
+    const conflicts = await checkConflicts(wsRoot, changedFiles, project);
+    if (conflicts.length === 0) {
+      p13.log.success("No conflicts detected.");
+    } else {
+      p13.log.warning(`${conflicts.length} conflict(s) detected:`);
+      for (const conflict of conflicts) {
+        console.log(
+          `  ${conflict.file}  held by ${conflict.held_by.project}/${conflict.held_by.agent} (protocol: ${conflict.held_by.protocol})`
         );
-      } catch {
-        p8.log.warn(`  ${file}: parse error`);
       }
     }
-    p8.log.info(
-      "\nFull validation (endpoint/type/event checking) runs via the /sniper-workspace validate slash command."
-    );
-    p8.outro("");
+    p13.outro("");
   }
 });
-function inferRole(projectType) {
-  switch (projectType) {
-    case "saas":
-    case "web":
-    case "mobile":
-      return "frontend";
-    case "api":
-      return "backend";
-    case "library":
-      return "library";
-    case "cli":
-    case "monorepo":
-      return "service";
-    default:
-      return "service";
-  }
-}
-var workspaceCommand = defineCommand8({
+var sphereCommand = defineCommand13({
   meta: {
-    name: "workspace",
-    description: "Manage SNIPER workspaces for multi-project orchestration"
+    name: "sphere",
+    description: "Sphere 7 \u2014 Cross-human workspace coordination"
   },
   subCommands: {
-    init: initSubCommand,
-    status: statusSubCommand,
-    "add-repo": addRepoSubCommand,
-    "remove-repo": removeRepoSubCommand,
-    validate: validateSubCommand
+    status: statusSubcommand3,
+    lock: lockSubcommand,
+    unlock: unlockSubcommand,
+    conflicts: conflictsSubcommand
   }
 });
+function timeSince(isoDate) {
+  const ms = Date.now() - new Date(isoDate).getTime();
+  const seconds = Math.floor(ms / 1e3);
+  if (seconds < 60) return `${seconds}s ago`;
+  const minutes = Math.floor(seconds / 60);
+  if (minutes < 60) return `${minutes}m ago`;
+  const hours = Math.floor(minutes / 60);
+  if (hours < 24) return `${hours}h ago`;
+  const days = Math.floor(hours / 24);
+  return `${days}d ago`;
+}
 
 // src/index.ts
 var require2 = createRequire2(import.meta.url);
 var { version } = require2("../package.json");
-var main = defineCommand9({
+var main = defineCommand14({
   meta: {
     name: "sniper",
     version,
-    description: "SNIPER \u2014 Spawn, Navigate, Implement, Parallelize, Evaluate, Release"
+    description: "SNIPER v3 \u2014 AI-Powered Project Lifecycle Framework"
   },
   subCommands: {
     init: initCommand,
     status: statusCommand,
-    "add-pack": addPackCommand,
-    "remove-pack": removePackCommand,
-    "list-packs": listPacksCommand,
-    update: updateCommand,
-    memory: memoryCommand,
-    workspace: workspaceCommand
+    migrate: migrateCommand,
+    plugin: pluginCommand,
+    protocol: protocolCommand,
+    dashboard: dashboardCommand,
+    workspace: workspaceCommand,
+    revert: revertCommand,
+    run: runCommand,
+    marketplace: marketplaceCommand,
+    signal: signalCommand,
+    knowledge: knowledgeCommand,
+    sphere: sphereCommand
   }
 });
 runMain(main);