navori 0.1.0

package/dist/index.js

@@ -0,0 +1,3944 @@
+#!/usr/bin/env node
+
+// src/index.ts
+import { defineCommand as defineCommand12, runMain } from "citty";
+import { readFileSync as readFileSync15 } from "fs";
+import { dirname as dirname7, resolve as resolve16 } from "path";
+import { fileURLToPath as fileURLToPath2 } from "url";
+
+// src/commands/init.ts
+import { defineCommand as defineCommand2 } from "citty";
+import * as p2 from "@clack/prompts";
+import { resolve as resolve7 } from "path";
+import { existsSync as existsSync10 } from "fs";
+import { spawnSync as spawnSync2 } from "child_process";
+
+// src/lib/config.ts
+import { readFileSync } from "fs";
+import "zod";
+
+// src/lib/atomic.ts
+import { openSync, fsyncSync, closeSync, writeSync, renameSync, mkdtempSync, rmSync } from "fs";
+import { dirname, basename, join } from "path";
+import { tmpdir } from "os";
+import { randomBytes } from "crypto";
+function writeFileAtomic(destPath, content) {
+  const dir = dirname(destPath);
+  const base = basename(destPath);
+  const tmpName = `.${base}.navori.tmp.${randomBytes(6).toString("hex")}`;
+  const tmpPath = join(dir, tmpName);
+  try {
+    const fd = openSync(tmpPath, "w", 420);
+    try {
+      writeSync(fd, content);
+      fsyncSync(fd);
+    } finally {
+      closeSync(fd);
+    }
+    renameSync(tmpPath, destPath);
+  } catch (err) {
+    try {
+      rmSync(tmpPath, { force: true });
+    } catch {
+    }
+    throw friendlyFsError(err, destPath);
+  }
+}
+function friendlyFsError(err, target) {
+  if (!(err instanceof Error)) return new Error(String(err));
+  const code = err.code;
+  switch (code) {
+    case "EACCES":
+      return new Error(`Cannot write ${target}: permission denied. Check that you own the file and the parent directory is writable.`);
+    case "EROFS":
+      return new Error(`Cannot write ${target}: filesystem is read-only.`);
+    case "EISDIR":
+      return new Error(`Cannot write ${target}: a directory exists at that path. Remove it or choose another location.`);
+    case "ENOSPC":
+      return new Error(`Cannot write ${target}: no space left on device.`);
+    case "ENOENT":
+      return new Error(`Cannot write ${target}: a directory in the path does not exist.`);
+    case "ENAMETOOLONG":
+      return new Error(`Cannot write ${target}: path is too long for this filesystem.`);
+    default:
+      return err;
+  }
+}
+
+// src/lib/schema.ts
+import { z } from "zod";
+var ENGINES = ["claude", "agents-md", "cursor", "copilot"];
+var MODELS = ["opus", "sonnet", "haiku"];
+var QualityGateSchema = z.object({
+  fast: z.string().min(1),
+  full: z.string().min(1)
+});
+var MonorepoWorkspaceSchema = z.object({
+  name: z.string().min(1),
+  path: z.string().min(1),
+  preset: z.string().optional(),
+  qualityGate: QualityGateSchema.optional()
+});
+var MonorepoSchema = z.object({
+  enabled: z.boolean(),
+  tool: z.enum(["pnpm", "turbo", "nx", "rush", "lerna", "npm"]).optional(),
+  workspaces: z.array(MonorepoWorkspaceSchema).default([])
+});
+var SddSchema = z.object({
+  enabled: z.boolean().default(true),
+  specsDir: z.string().default("specs"),
+  applyWhen: z.array(z.string()).default([]),
+  doesNotApplyTo: z.array(z.string()).default([])
+});
+var HarnessSchema = z.object({
+  leader: z.boolean().default(true),
+  implementer: z.boolean().default(true),
+  reviewer: z.boolean().default(true),
+  researcher: z.boolean().default(true),
+  ticketAudit: z.boolean().default(true),
+  commitPrPilot: z.boolean().default(true),
+  explorer: z.boolean().default(true)
+});
+var ModelsSchema = z.object({
+  leader: z.enum(MODELS).optional(),
+  implementer: z.enum(MODELS).optional(),
+  reviewer: z.enum(MODELS).optional(),
+  researcher: z.enum(MODELS).optional(),
+  ticketAudit: z.enum(MODELS).optional(),
+  commitPrPilot: z.enum(MODELS).optional(),
+  explorer: z.enum(MODELS).optional()
+});
+var PluginEntrySchema = z.object({
+  enabled: z.boolean()
+});
+var AGENT_ROLES_FOR_SCHEMA = [
+  "leader",
+  "implementer",
+  "reviewer",
+  "researcher",
+  "ticket-audit",
+  "commit-pr-pilot",
+  "explorer"
+];
+var AgentAssignmentsSchema = z.record(z.string(), z.enum(AGENT_ROLES_FOR_SCHEMA));
+var SkillsSchema = z.object({
+  auto: z.array(z.string()).default([]),
+  optIn: z.array(z.string()).default([])
+});
+var ProgressSchema = z.object({
+  dir: z.string().default("progress"),
+  currentFile: z.string().default("current.md"),
+  historyFile: z.string().default("history.md"),
+  checkpointsDir: z.string().default("progress/checkpoints"),
+  archiveAfterDays: z.number().int().positive().default(30)
+});
+var NavoriConfigSchema = z.object({
+  $schema: z.string().optional(),
+  name: z.string().regex(/^[a-z0-9][a-z0-9-]*$/, "name must be kebab-case"),
+  version: z.string().default("1.0.0"),
+  workspace: z.string().optional(),
+  engines: z.array(z.enum(ENGINES)).min(1),
+  preset: z.string().min(1),
+  language: z.enum(["es", "en"]).default("es"),
+  branchBase: z.string().default("main"),
+  commits: z.enum(["conventional", "conventional-es", "free"]).default("conventional-es"),
+  qualityGate: QualityGateSchema.optional(),
+  sdd: SddSchema.optional(),
+  harness: HarnessSchema.optional(),
+  models: ModelsSchema.optional(),
+  plugins: z.record(z.string(), PluginEntrySchema).optional(),
+  /** Override of which agent owns which skill/managed-block id. Plugins
+   * declare their own recommendedAgent; entries here override that. */
+  agentAssignments: AgentAssignmentsSchema.optional(),
+  skills: SkillsSchema.optional(),
+  progress: ProgressSchema.optional(),
+  monorepo: MonorepoSchema.optional()
+}).passthrough();
+
+// src/lib/config.ts
+var SCHEMA_URL = "https://navori.dev/schema/navori.config.v1.json";
+function writeConfig(path, input) {
+  const validated = NavoriConfigSchema.parse({ $schema: SCHEMA_URL, ...input });
+  writeFileAtomic(path, JSON.stringify(validated, null, 2) + "\n");
+}
+var ConfigError = class extends Error {
+  issues;
+  constructor(message, issues) {
+    super(message);
+    this.name = "ConfigError";
+    this.issues = issues;
+  }
+};
+function readConfig(path) {
+  let raw;
+  try {
+    raw = readFileSync(path, "utf-8").replace(/^/, "");
+  } catch (err) {
+    throw new ConfigError(`Cannot read ${path}: ${err.message}`);
+  }
+  let parsed;
+  try {
+    parsed = JSON.parse(raw);
+  } catch (err) {
+    throw new ConfigError(`Invalid JSON in ${path}: ${err.message}`);
+  }
+  const result = NavoriConfigSchema.safeParse(parsed);
+  if (!result.success) {
+    throw new ConfigError(
+      `Validation failed for ${path}`,
+      result.error.issues
+    );
+  }
+  return result.data;
+}
+
+// src/lib/detect.ts
+import { existsSync as existsSync2, readFileSync as readFileSync2 } from "fs";
+import { join as join3, basename as basename2 } from "path";
+import { spawnSync } from "child_process";
+
+// src/lib/claude-infra.ts
+import { existsSync, readdirSync, statSync } from "fs";
+import { join as join2 } from "path";
+function safeReaddir(path) {
+  try {
+    return readdirSync(path);
+  } catch {
+    return [];
+  }
+}
+function listMarkdownFiles(dir) {
+  return safeReaddir(dir).filter((f) => f.endsWith(".md"));
+}
+function listSkillDirs(dir) {
+  const result = [];
+  for (const entry of safeReaddir(dir)) {
+    const full = join2(dir, entry);
+    try {
+      if (statSync(full).isDirectory()) {
+        if (existsSync(join2(full, "SKILL.md"))) result.push(entry);
+      } else if (entry.endsWith(".md")) {
+        result.push(entry);
+      }
+    } catch {
+    }
+  }
+  return result;
+}
+function countFilesIn(dir) {
+  let count = 0;
+  for (const entry of safeReaddir(dir)) {
+    try {
+      if (statSync(join2(dir, entry)).isFile()) count++;
+    } catch {
+    }
+  }
+  return count;
+}
+function countSubdirs(dir) {
+  let count = 0;
+  for (const entry of safeReaddir(dir)) {
+    try {
+      if (statSync(join2(dir, entry)).isDirectory()) count++;
+    } catch {
+    }
+  }
+  return count;
+}
+function detectClaudeInfra(cwd) {
+  const claudeDir = join2(cwd, ".claude");
+  const agentsDir = join2(claudeDir, "agents");
+  const skillsDir = join2(claudeDir, "skills");
+  const agentFiles = listMarkdownFiles(agentsDir);
+  const skillFiles = listSkillDirs(skillsDir);
+  const hasSettings = existsSync(join2(claudeDir, "settings.json"));
+  const hasLocalSettings = existsSync(join2(claudeDir, "settings.local.json"));
+  const hasClaudeMd = existsSync(join2(cwd, "CLAUDE.md"));
+  const hasAgentsMd = existsSync(join2(cwd, "AGENTS.md"));
+  const hasCheckpointsMd = existsSync(join2(cwd, "CHECKPOINTS.md"));
+  const hasFeatureList = existsSync(join2(cwd, "feature_list.json"));
+  const hasNavoriConfig = existsSync(join2(cwd, "navori.config.json"));
+  const progressFiles = existsSync(join2(cwd, "progress")) ? countFilesIn(join2(cwd, "progress")) : 0;
+  const specsDirs = existsSync(join2(cwd, "specs")) ? countSubdirs(join2(cwd, "specs")) : 0;
+  const present = agentFiles.length > 0 || skillFiles.length > 0 || hasSettings || hasLocalSettings || hasClaudeMd || hasAgentsMd || hasCheckpointsMd || hasFeatureList || progressFiles > 0 || specsDirs > 0;
+  return {
+    present,
+    agentFiles,
+    skillFiles,
+    hasSettings,
+    hasLocalSettings,
+    hasClaudeMd,
+    hasAgentsMd,
+    hasCheckpointsMd,
+    hasFeatureList,
+    progressFiles,
+    specsDirs,
+    hasNavoriConfig
+  };
+}
+
+// src/lib/detect.ts
+function detectProject(cwd) {
+  const pkg = readPackageJson(cwd);
+  const pyproject = readPyproject(cwd);
+  const cargo = readCargoToml(cwd);
+  const fromPackageJson = typeof pkg?.name === "string" ? pkg.name : null;
+  const fromPyproject = typeof pyproject?.name === "string" ? pyproject.name : null;
+  const fromCargo = typeof cargo?.name === "string" ? cargo.name : null;
+  const fromGit = detectGitRepoName(cwd);
+  const fromBasename = basename2(cwd);
+  const nameSource = fromPackageJson ? "package.json" : fromPyproject ? "pyproject.toml" : fromCargo ? "Cargo.toml" : fromGit ? "git remote" : "directory name";
+  const name = normalizeName(
+    fromPackageJson ?? fromPyproject ?? fromCargo ?? fromGit ?? fromBasename
+  );
+  const branchBase = detectBranchBase(cwd);
+  const existingEngines = detectExistingEngines(cwd);
+  const packageManager = detectPackageManager(cwd);
+  const monorepo = detectMonorepo(cwd);
+  const stack = detectStack(cwd, pkg, pyproject, cargo);
+  const suggestedPreset = suggestPreset(stack, monorepo);
+  const qualityGate = guessQualityGate(pkg, packageManager, stack);
+  const claudeInfra = detectClaudeInfra(cwd);
+  return {
+    name,
+    branchBase,
+    existingEngines,
+    packageManager,
+    monorepo,
+    stack,
+    suggestedPreset,
+    qualityGate,
+    claudeInfra,
+    sources: {
+      name: name ? nameSource : null,
+      branchBase: branchBase ? "git" : null,
+      packageManager: packageManager ? detectPackageManagerSource(cwd) : null
+    }
+  };
+}
+function normalizeName(raw) {
+  if (typeof raw !== "string" || !raw) return null;
+  const cleaned = raw.trim().toLowerCase().replace(/^@[^/]+\//, "").replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "");
+  if (!cleaned) return null;
+  return /^[a-z0-9]/.test(cleaned) ? cleaned : null;
+}
+function readPackageJson(cwd) {
+  const path = join3(cwd, "package.json");
+  if (!existsSync2(path)) return null;
+  try {
+    const raw = readFileSync2(path, "utf-8").replace(/^/, "");
+    return JSON.parse(raw);
+  } catch {
+    return null;
+  }
+}
+function readPyproject(cwd) {
+  const path = join3(cwd, "pyproject.toml");
+  if (!existsSync2(path)) return null;
+  try {
+    const content = readFileSync2(path, "utf-8");
+    const nameMatch = content.match(/^\s*name\s*=\s*"([^"]+)"/m);
+    const deps = [];
+    const depBlock = content.match(/\[(?:tool\.poetry\.)?dependencies\]([\s\S]*?)(?:\n\[|$)/);
+    if (depBlock?.[1]) {
+      for (const line of depBlock[1].split("\n")) {
+        const m = line.match(/^\s*([a-zA-Z0-9_\-.]+)\s*=/);
+        if (m?.[1] && m[1] !== "python") deps.push(m[1].toLowerCase());
+      }
+    }
+    const projectDeps = content.match(/dependencies\s*=\s*\[([\s\S]*?)\]/);
+    if (projectDeps?.[1]) {
+      const items = projectDeps[1].match(/"([^"]+)"/g) ?? [];
+      for (const item of items) {
+        const pkgName = item.slice(1, -1).split(/[<>=~!]/)[0]?.trim().toLowerCase();
+        if (pkgName) deps.push(pkgName);
+      }
+    }
+    return { name: nameMatch?.[1] ?? null, deps };
+  } catch {
+    return null;
+  }
+}
+function readCargoToml(cwd) {
+  const path = join3(cwd, "Cargo.toml");
+  if (!existsSync2(path)) return null;
+  try {
+    const content = readFileSync2(path, "utf-8");
+    const match = content.match(/^\s*name\s*=\s*"([^"]+)"/m);
+    return { name: match?.[1] ?? null };
+  } catch {
+    return null;
+  }
+}
+function detectGitRepoName(cwd) {
+  const url = gitConfigGet(cwd, "remote.origin.url");
+  if (!url) return null;
+  const match = url.trim().match(/[/:]([^/:]+?)(?:\.git)?$/);
+  return match?.[1] ?? null;
+}
+function gitConfigGet(cwd, key) {
+  const result = spawnSync("git", ["-C", cwd, "config", "--get", key], {
+    encoding: "utf-8",
+    stdio: ["ignore", "pipe", "ignore"]
+  });
+  if (result.status !== 0) return null;
+  const out = result.stdout.trim();
+  return out.length > 0 ? out : null;
+}
+function gitRevParse(cwd, args) {
+  const result = spawnSync("git", ["-C", cwd, ...args], {
+    encoding: "utf-8",
+    stdio: ["ignore", "pipe", "ignore"]
+  });
+  if (result.status !== 0) return null;
+  const out = result.stdout.trim();
+  return out.length > 0 ? out : null;
+}
+function detectBranchBase(cwd) {
+  const originHead = gitRevParse(cwd, [
+    "symbolic-ref",
+    "--short",
+    "refs/remotes/origin/HEAD"
+  ]);
+  if (originHead) return originHead.replace(/^origin\//, "");
+  for (const candidate of ["main", "master", "develop", "dev"]) {
+    const found = gitRevParse(cwd, ["rev-parse", "--verify", "--quiet", candidate]);
+    if (found) return candidate;
+  }
+  return null;
+}
+function detectExistingEngines(cwd) {
+  const found = [];
+  if (existsSync2(join3(cwd, ".claude"))) found.push("claude");
+  if (existsSync2(join3(cwd, "AGENTS.md"))) found.push("agents-md");
+  if (existsSync2(join3(cwd, ".cursor"))) found.push("cursor");
+  if (existsSync2(join3(cwd, ".github", "copilot-instructions.md"))) found.push("copilot");
+  return found;
+}
+function detectPackageManager(cwd) {
+  const pkg = readPackageJson(cwd);
+  if (pkg?.packageManager) {
+    const tool = pkg.packageManager.split("@")[0];
+    if (tool === "pnpm" || tool === "npm" || tool === "yarn" || tool === "bun") return tool;
+  }
+  if (existsSync2(join3(cwd, "pnpm-lock.yaml"))) return "pnpm";
+  if (existsSync2(join3(cwd, "bun.lockb")) || existsSync2(join3(cwd, "bun.lock"))) return "bun";
+  if (existsSync2(join3(cwd, "yarn.lock"))) return "yarn";
+  if (existsSync2(join3(cwd, "package-lock.json"))) return "npm";
+  return null;
+}
+function detectPackageManagerSource(cwd) {
+  const pkg = readPackageJson(cwd);
+  if (pkg?.packageManager) return "package.json";
+  if (existsSync2(join3(cwd, "pnpm-lock.yaml"))) return "pnpm-lock.yaml";
+  if (existsSync2(join3(cwd, "bun.lockb")) || existsSync2(join3(cwd, "bun.lock"))) return "bun.lock";
+  if (existsSync2(join3(cwd, "yarn.lock"))) return "yarn.lock";
+  if (existsSync2(join3(cwd, "package-lock.json"))) return "package-lock.json";
+  return "unknown";
+}
+function detectMonorepo(cwd) {
+  if (existsSync2(join3(cwd, "pnpm-workspace.yaml"))) {
+    if (existsSync2(join3(cwd, "turbo.json"))) {
+      return { tool: "turbo", source: "turbo.json + pnpm-workspace.yaml" };
+    }
+    return { tool: "pnpm", source: "pnpm-workspace.yaml" };
+  }
+  if (existsSync2(join3(cwd, "turbo.json"))) {
+    return { tool: "turbo", source: "turbo.json" };
+  }
+  if (existsSync2(join3(cwd, "nx.json"))) {
+    return { tool: "nx", source: "nx.json" };
+  }
+  if (existsSync2(join3(cwd, "rush.json"))) {
+    return { tool: "rush", source: "rush.json" };
+  }
+  if (existsSync2(join3(cwd, "lerna.json"))) {
+    return { tool: "lerna", source: "lerna.json" };
+  }
+  const pkg = readPackageJson(cwd);
+  if (pkg?.workspaces) {
+    return { tool: "npm", source: "package.json workspaces" };
+  }
+  return null;
+}
+function collectNodeDeps(pkg) {
+  if (!pkg) return [];
+  return [
+    ...Object.keys(pkg.dependencies ?? {}),
+    ...Object.keys(pkg.devDependencies ?? {}),
+    ...Object.keys(pkg.peerDependencies ?? {})
+  ];
+}
+function pick(deps, ...candidates) {
+  for (const c of candidates) {
+    if (deps.has(c)) return c;
+  }
+  return null;
+}
+function detectStack(cwd, pkg, pyproject, cargo) {
+  if (pyproject) {
+    const deps = new Set(pyproject.deps);
+    return {
+      language: "python",
+      framework: pick(deps, "fastapi", "django", "flask", "starlette") ?? null,
+      ui: null,
+      forms: pick(deps, "pydantic") ?? null,
+      state: null,
+      test: pick(deps, "pytest") ?? null,
+      deps: Array.from(deps)
+    };
+  }
+  if (cargo) {
+    return {
+      language: "rust",
+      framework: null,
+      ui: null,
+      forms: null,
+      state: null,
+      test: null,
+      deps: []
+    };
+  }
+  const nodeDeps = new Set(collectNodeDeps(pkg));
+  if (nodeDeps.size === 0 && !pkg) {
+    return {
+      language: "unknown",
+      framework: null,
+      ui: null,
+      forms: null,
+      state: null,
+      test: null,
+      deps: []
+    };
+  }
+  const hasTs = nodeDeps.has("typescript") || existsSync2(join3(cwd, "tsconfig.json"));
+  const framework = (
+    // Application frameworks (they own the project)
+    pick(nodeDeps, "next") ?? pick(nodeDeps, "@nestjs/core") ?? pick(nodeDeps, "@medusajs/medusa") ?? pick(nodeDeps, "@keystone-6/core") ?? pick(nodeDeps, "expo") ?? pick(nodeDeps, "react-native") ?? pick(nodeDeps, "remix") ?? // Meta-frameworks on top of build tools — check before vite/react
+    pick(nodeDeps, "astro") ?? pick(nodeDeps, "@sveltejs/kit") ?? pick(nodeDeps, "@builder.io/qwik") ?? pick(nodeDeps, "solid-js") ?? pick(nodeDeps, "@tauri-apps/api") ?? pick(nodeDeps, "electron") ?? pick(nodeDeps, "svelte") ?? pick(nodeDeps, "vue") ?? // Build tools / generic frontend
+    pick(nodeDeps, "vite") ?? pick(nodeDeps, "react") ?? // Backend frameworks
+    pick(nodeDeps, "@angular/core") ?? pick(nodeDeps, "fastify") ?? pick(nodeDeps, "hono") ?? pick(nodeDeps, "elysia") ?? pick(nodeDeps, "express") ?? null
+  );
+  const ui = pick(nodeDeps, "@mantine/core") ?? pick(nodeDeps, "@mui/material") ?? pick(nodeDeps, "tailwindcss") ?? pick(nodeDeps, "tamagui") ?? pick(nodeDeps, "@radix-ui/themes") ?? null;
+  const forms = pick(nodeDeps, "formik") ?? pick(nodeDeps, "react-hook-form") ?? pick(nodeDeps, "@mantine/form") ?? pick(nodeDeps, "vee-validate") ?? null;
+  const state = pick(nodeDeps, "@reduxjs/toolkit") ?? pick(nodeDeps, "redux") ?? pick(nodeDeps, "zustand") ?? pick(nodeDeps, "jotai") ?? pick(nodeDeps, "valtio") ?? pick(nodeDeps, "@tanstack/react-query") ?? pick(nodeDeps, "@apollo/client") ?? null;
+  const test = pick(nodeDeps, "vitest") ?? pick(nodeDeps, "jest") ?? pick(nodeDeps, "@playwright/test") ?? pick(nodeDeps, "cypress") ?? null;
+  return {
+    language: hasTs ? "ts" : pkg ? "js" : "unknown",
+    framework,
+    ui,
+    forms,
+    state,
+    test,
+    deps: Array.from(nodeDeps)
+  };
+}
+function suggestPreset(stack, monorepo) {
+  if (monorepo) {
+    if (monorepo.tool === "turbo") return "monorepo-turbopnpm";
+    if (monorepo.tool === "pnpm") return "monorepo-pnpm";
+    if (monorepo.tool === "npm" || monorepo.tool === "lerna") return "monorepo-npm";
+  }
+  if (stack.language === "python") {
+    if (stack.framework === "fastapi") return "fastapi-python";
+    if (stack.framework === "django") return "django-python";
+    return "python";
+  }
+  if (stack.language === "rust") return "rust";
+  const fw = stack.framework;
+  const ui = stack.ui;
+  const state = stack.state;
+  if (fw === "@medusajs/medusa") return "medusa-v2";
+  if (fw === "@keystone-6/core") return "bun-keystone";
+  if (fw === "next") {
+    if (state === "@apollo/client") return "nextjs-apollo";
+    return "nextjs";
+  }
+  if (fw === "@nestjs/core") return "nestjs";
+  if (fw === "expo" || fw === "react-native") return "react-native-expo";
+  if (fw === "astro") return "astro";
+  if (fw === "@sveltejs/kit" || fw === "svelte") return "sveltekit";
+  if (fw === "@builder.io/qwik") return "qwik";
+  if (fw === "solid-js") return "solid";
+  if (fw === "@tauri-apps/api") return "tauri";
+  if (fw === "electron") return "electron";
+  if (fw === "vue") return "vue";
+  if (fw === "@angular/core") return "angular";
+  if (fw === "vite") {
+    if (ui === "@mantine/core") return "vite-react-ts-mantine";
+    return "vite-react-ts";
+  }
+  if (fw === "react") return "react";
+  if (fw === "remix") return "remix";
+  if (fw === "fastify") return "fastify";
+  if (fw === "hono") return "hono";
+  if (fw === "elysia") return "elysia";
+  if (fw === "express") return "express-microservice";
+  return "custom";
+}
+function guessQualityGate(pkg, pm, stack) {
+  if (!pkg) {
+    if (stack.language === "python") {
+      const full2 = stack.test === "pytest" ? "ruff check . && pytest" : "ruff check .";
+      return { fast: "ruff check .", full: full2 };
+    }
+    return null;
+  }
+  const runner = pm ?? "npm";
+  const scripts = pkg.scripts ?? {};
+  const has = (name) => typeof scripts[name] === "string";
+  if (has("validate")) {
+    return { fast: `${runner} run typecheck`, full: `${runner} run validate` };
+  }
+  if (has("check:all")) {
+    return { fast: `${runner} run typecheck`, full: `${runner} run check:all` };
+  }
+  const fastParts = [];
+  if (has("typecheck")) fastParts.push(`${runner} run typecheck`);
+  else if (has("type-check")) fastParts.push(`${runner} run type-check`);
+  else if (has("check")) fastParts.push(`${runner} run check`);
+  else if (has("compile")) fastParts.push(`${runner} run compile`);
+  const fullParts = [...fastParts];
+  if (has("lint")) fullParts.push(`${runner} run lint`);
+  if (has("test:unit")) fullParts.push(`${runner} run test:unit`);
+  else if (has("test")) fullParts.push(`${runner} run test`);
+  if (fastParts.length === 0 && fullParts.length === 0) return null;
+  const fast = fastParts.join(" && ") || `${runner} run lint`;
+  const full = fullParts.join(" && ") || fast;
+  return { fast, full };
+}
+
+// src/lib/plugins.ts
+import { readFileSync as readFileSync4, existsSync as existsSync4 } from "fs";
+import { resolve as resolve2, sep } from "path";
+import { z as z3 } from "zod";
+
+// src/lib/bundled-assets.ts
+import { fileURLToPath } from "url";
+import { dirname as dirname2, resolve, join as join4 } from "path";
+import { existsSync as existsSync3, readFileSync as readFileSync3, readdirSync as readdirSync2, statSync as statSync2 } from "fs";
+var HERE = dirname2(fileURLToPath(import.meta.url));
+var BUNDLED_ASSETS = resolve(HERE, "assets");
+var DEV_PACKAGES = resolve(HERE, "..", "..", "..");
+function isBundled() {
+  return existsSync3(resolve(BUNDLED_ASSETS, "core", "package.json"));
+}
+function getCoreRoot() {
+  if (isBundled()) return resolve(BUNDLED_ASSETS, "core");
+  return resolve(DEV_PACKAGES, "core");
+}
+function getPluginAssetsRoot() {
+  if (isBundled()) return resolve(BUNDLED_ASSETS, "plugins");
+  return resolve(DEV_PACKAGES, "plugins");
+}
+function getPluginPath(pluginId) {
+  return resolve(getPluginAssetsRoot(), pluginId);
+}
+function readBundledCoreVersion() {
+  try {
+    const pkg = JSON.parse(readFileSync3(resolve(getCoreRoot(), "package.json"), "utf-8"));
+    return pkg.version ?? "0.0.0";
+  } catch {
+    return "0.0.0";
+  }
+}
+function bundledPluginManifestPath(pluginId) {
+  return resolve(getPluginPath(pluginId), "plugin.json");
+}
+function listBundledPluginIds() {
+  const root = getPluginAssetsRoot();
+  if (!existsSync3(root)) return [];
+  try {
+    return readdirSync2(root).filter((entry) => {
+      try {
+        return statSync2(join4(root, entry)).isDirectory();
+      } catch {
+        return false;
+      }
+    });
+  } catch {
+    return [];
+  }
+}
+
+// src/lib/plugins.ts
+var AGENT_ROLES = [
+  "leader",
+  "implementer",
+  "reviewer",
+  "researcher",
+  "ticket-audit",
+  "commit-pr-pilot",
+  "explorer"
+];
+var ManagedEntrySchema = z3.object({
+  id: z3.string().min(1),
+  file: z3.string().min(1),
+  /** Agent that the plugin recommends for this skill/protocol. */
+  recommendedAgent: z3.enum(AGENT_ROLES).optional()
+});
+var ExternalToolSchema = z3.object({
+  name: z3.string().min(1),
+  /** Binary name to look up in PATH. Safer than checkCommand because it
+   * never spawns a shell — we walk PATH directories manually. */
+  checkBinary: z3.string().regex(/^[a-zA-Z0-9_\-.]+$/, "binary name must be alphanumeric").optional(),
+  install: z3.record(z3.string(), z3.string()).optional(),
+  postInstall: z3.string().optional()
+});
+var PluginManifestSchema = z3.object({
+  id: z3.string().regex(/^[a-z0-9][a-z0-9-]*$/, "plugin id must be kebab-case"),
+  name: z3.string(),
+  description: z3.string(),
+  version: z3.string(),
+  managed: z3.array(ManagedEntrySchema).default([]),
+  externalTool: ExternalToolSchema.optional()
+});
+var KNOWN_PLUGINS = {
+  engram: "@navori/plugin-engram",
+  acli: "@navori/plugin-acli",
+  gh: "@navori/plugin-gh",
+  jscpd: "@navori/plugin-jscpd",
+  semgrep: "@navori/plugin-semgrep",
+  cognitive: "@navori/plugin-cognitive"
+};
+var PluginNotFoundError = class extends Error {
+  pluginId;
+  constructor(pluginId) {
+    super(`Unknown plugin: '${pluginId}'`);
+    this.name = "PluginNotFoundError";
+    this.pluginId = pluginId;
+  }
+};
+var PluginManifestError = class extends Error {
+  issues;
+  constructor(message, issues) {
+    super(message);
+    this.name = "PluginManifestError";
+    this.issues = issues;
+  }
+};
+function listKnownPluginIds() {
+  const bundled = listBundledPluginIds();
+  return bundled.length > 0 ? bundled : Object.keys(KNOWN_PLUGINS);
+}
+function loadPlugin(pluginId) {
+  if (!KNOWN_PLUGINS[pluginId] && !listBundledPluginIds().includes(pluginId)) {
+    throw new PluginNotFoundError(pluginId);
+  }
+  const packageRoot = getPluginPath(pluginId);
+  const manifestPath = bundledPluginManifestPath(pluginId);
+  if (!existsSync4(manifestPath)) {
+    throw new PluginManifestError(`plugin.json not found at ${manifestPath}`);
+  }
+  let parsed;
+  try {
+    parsed = JSON.parse(readFileSync4(manifestPath, "utf-8"));
+  } catch (err) {
+    throw new PluginManifestError(`Invalid JSON in ${manifestPath}: ${err.message}`);
+  }
+  const result = PluginManifestSchema.safeParse(parsed);
+  if (!result.success) {
+    throw new PluginManifestError(`Invalid plugin manifest in ${manifestPath}`, result.error.issues);
+  }
+  const manifest = result.data;
+  const rootPrefix = packageRoot.endsWith(sep) ? packageRoot : packageRoot + sep;
+  const managedAssets = manifest.managed.map((entry) => {
+    const absPath = resolve2(packageRoot, entry.file);
+    if (absPath !== packageRoot && !absPath.startsWith(rootPrefix)) {
+      throw new PluginManifestError(
+        `Plugin '${pluginId}' declared managed.file '${entry.file}' that resolves outside the package root.`
+      );
+    }
+    return { id: entry.id, absPath };
+  });
+  return { manifest, packageRoot, managedAssets };
+}
+
+// src/lib/migrate.ts
+import { mkdirSync, existsSync as existsSync5, copyFileSync, readdirSync as readdirSync3, statSync as statSync3, rmSync as rmSync2 } from "fs";
+import { join as join5, resolve as resolve3, dirname as dirname3 } from "path";
+
+// src/lib/home.ts
+import { homedir } from "os";
+import { isAbsolute } from "path";
+function safeHomedir() {
+  const home = homedir();
+  if (!home || !isAbsolute(home)) {
+    throw new Error(
+      "Could not determine home directory: HOME env var is empty or not absolute. Set HOME explicitly (e.g. 'HOME=/home/runner') before running navori."
+    );
+  }
+  return home;
+}
+
+// src/lib/migrate.ts
+function migrationsRootLazy() {
+  return join5(safeHomedir(), ".navori", "migrations");
+}
+function timestamp() {
+  const d = /* @__PURE__ */ new Date();
+  const pad = (n) => String(n).padStart(2, "0");
+  return [
+    d.getFullYear(),
+    "-",
+    pad(d.getMonth() + 1),
+    "-",
+    pad(d.getDate()),
+    "T",
+    pad(d.getHours()),
+    "-",
+    pad(d.getMinutes()),
+    "-",
+    pad(d.getSeconds())
+  ].join("");
+}
+function copyRecursive(src, dest) {
+  const stat = statSync3(src);
+  if (stat.isDirectory()) {
+    mkdirSync(dest, { recursive: true });
+    for (const entry of readdirSync3(src)) {
+      copyRecursive(join5(src, entry), join5(dest, entry));
+    }
+  } else if (stat.isFile()) {
+    mkdirSync(dirname3(dest), { recursive: true });
+    copyFileSync(src, dest);
+  }
+}
+function createMigrationBackup(repoRoot, repoName) {
+  const dir = join5(migrationsRootLazy(), timestamp(), repoName);
+  mkdirSync(dir, { recursive: true });
+  const candidates = [
+    ".claude",
+    "CLAUDE.md",
+    "AGENTS.md",
+    "CHECKPOINTS.md",
+    "feature_list.json",
+    "progress",
+    "specs"
+  ];
+  const moved = [];
+  for (const rel of candidates) {
+    const src = resolve3(repoRoot, rel);
+    if (!existsSync5(src)) continue;
+    const dest = join5(dir, rel);
+    copyRecursive(src, dest);
+    moved.push(rel);
+  }
+  return { path: dir, movedPaths: moved };
+}
+function removeOriginals(repoRoot, paths) {
+  for (const rel of paths) {
+    const target = resolve3(repoRoot, rel);
+    if (!existsSync5(target)) continue;
+    rmSync2(target, { recursive: true, force: true });
+  }
+}
+function migrationsRoot() {
+  return migrationsRootLazy();
+}
+
+// src/lib/workspace.ts
+import { existsSync as existsSync6, readFileSync as readFileSync5, readdirSync as readdirSync4, mkdirSync as mkdirSync2, statSync as statSync4, copyFileSync as copyFileSync2, rmSync as rmSync3 } from "fs";
+import { join as join6 } from "path";
+import { z as z4 } from "zod";
+function workspacesRootLazy() {
+  return join6(safeHomedir(), ".navori", "workspaces");
+}
+var MANIFEST_NAME = "workspace.json";
+var RepoEntrySchema = z4.object({
+  name: z4.string().regex(/^[a-z0-9][a-z0-9-]*$/, "repo name must be kebab-case"),
+  path: z4.string().min(1),
+  stack: z4.string().optional(),
+  description: z4.string().optional(),
+  branchBase: z4.string().optional()
+});
+var WorkspaceDefaultsSchema = z4.object({
+  branchBase: z4.string().optional(),
+  commits: z4.enum(["conventional", "conventional-es", "free"]).optional(),
+  language: z4.enum(["es", "en"]).optional(),
+  engines: z4.array(z4.string()).optional(),
+  plugins: z4.record(z4.string(), z4.object({ enabled: z4.boolean() })).optional()
+});
+var WorkspaceConfigSchema = z4.object({
+  $schema: z4.string().optional(),
+  name: z4.string().regex(/^[a-z0-9][a-z0-9-]*$/, "workspace name must be kebab-case"),
+  description: z4.string().optional(),
+  /** Folder for cross-repo tickets (relative to workspace dir).
+   * Restricted to a simple relative segment to prevent path traversal
+   * (e.g. "../etc/passwd") and to avoid silent failure of absolute
+   * paths under path.join. */
+  ticketsDir: z4.string().regex(
+    /^[a-zA-Z0-9][a-zA-Z0-9_\-./]*$/,
+    "ticketsDir must be a relative path (alphanumeric, '-', '_', '.', '/'). No leading '/' or '..'."
+  ).refine((s) => !s.split("/").includes(".."), {
+    message: "ticketsDir must not contain '..' segments"
+  }).default("tickets"),
+  defaults: WorkspaceDefaultsSchema.default({}),
+  repos: z4.array(RepoEntrySchema).default([])
+});
+var WorkspaceError = class extends Error {
+  issues;
+  constructor(message, issues) {
+    super(message);
+    this.name = "WorkspaceError";
+    this.issues = issues;
+  }
+};
+function workspaceDirectory(name) {
+  return join6(workspacesRootLazy(), name);
+}
+function workspacePath(name) {
+  return join6(workspaceDirectory(name), MANIFEST_NAME);
+}
+function legacyWorkspacePath(name) {
+  return join6(workspacesRootLazy(), `${name}.json`);
+}
+function ensureWorkspacesRoot() {
+  mkdirSync2(workspacesRootLazy(), { recursive: true });
+}
+function migrateLegacyLayoutIfNeeded(name) {
+  const legacy = legacyWorkspacePath(name);
+  const current = workspacePath(name);
+  if (!existsSync6(legacy) || existsSync6(current)) return;
+  const dir = workspaceDirectory(name);
+  mkdirSync2(dir, { recursive: true });
+  copyFileSync2(legacy, current);
+  try {
+    rmSync3(legacy, { force: true });
+  } catch {
+  }
+}
+function listWorkspaces() {
+  if (!existsSync6(workspacesRootLazy())) return [];
+  for (const entry of readdirSync4(workspacesRootLazy())) {
+    if (entry.endsWith(".json")) {
+      const name = entry.replace(/\.json$/, "");
+      migrateLegacyLayoutIfNeeded(name);
+    }
+  }
+  const names = [];
+  for (const entry of readdirSync4(workspacesRootLazy())) {
+    const full = join6(workspacesRootLazy(), entry);
+    try {
+      if (!statSync4(full).isDirectory()) continue;
+    } catch {
+      continue;
+    }
+    if (existsSync6(join6(full, MANIFEST_NAME))) names.push(entry);
+  }
+  return names.sort();
+}
+function loadWorkspace(name) {
+  migrateLegacyLayoutIfNeeded(name);
+  const path = workspacePath(name);
+  if (!existsSync6(path)) return null;
+  let raw;
+  try {
+    raw = readFileSync5(path, "utf-8").replace(/^/, "");
+  } catch (err) {
+    throw new WorkspaceError(`Cannot read workspace '${name}': ${err.message}`);
+  }
+  let parsed;
+  try {
+    parsed = JSON.parse(raw);
+  } catch (err) {
+    throw new WorkspaceError(`Invalid JSON in workspace '${name}': ${err.message}`);
+  }
+  const result = WorkspaceConfigSchema.safeParse(parsed);
+  if (!result.success) {
+    throw new WorkspaceError(`Validation failed for workspace '${name}'`, result.error.issues);
+  }
+  return result.data;
+}
+function writeWorkspace(workspace) {
+  ensureWorkspacesRoot();
+  const dir = workspaceDirectory(workspace.name);
+  mkdirSync2(dir, { recursive: true });
+  mkdirSync2(join6(dir, workspace.ticketsDir), { recursive: true });
+  const path = workspacePath(workspace.name);
+  const validated = WorkspaceConfigSchema.parse({
+    $schema: "https://navori.dev/schema/navori.workspace.v1.json",
+    ...workspace
+  });
+  writeFileAtomic(path, JSON.stringify(validated, null, 2) + "\n");
+  return path;
+}
+
+// src/commands/render.ts
+import { defineCommand } from "citty";
+import * as p from "@clack/prompts";
+import { readFileSync as readFileSync7, existsSync as existsSync9 } from "fs";
+import { resolve as resolve6 } from "path";
+
+// src/lib/render-plan.ts
+import { readFileSync as readFileSync6, existsSync as existsSync7 } from "fs";
+import { resolve as resolve4 } from "path";
+
+// src/lib/marker.ts
+import { createHash } from "crypto";
+var MARKER_OPEN_PREFIX = "<!-- navori:managed";
+var MARKER_CLOSE_PREFIX = "<!-- /navori:managed";
+var MARKER_SUFFIX = "-->";
+function normalize(content) {
+  return content.replace(/\r\n?/g, "\n").replace(/\s+$/, "");
+}
+function hashContent(content) {
+  return createHash("sha1").update(normalize(content), "utf-8").digest("hex").slice(0, 8);
+}
+function openMarker(id, hash, meta = {}) {
+  const parts = [`${MARKER_OPEN_PREFIX} id="${id}"`, `hash="${hash}"`];
+  if (meta.version) parts.push(`version="${meta.version}"`);
+  if (meta.source) parts.push(`source="${meta.source}"`);
+  return parts.join(" ") + ` ${MARKER_SUFFIX}`;
+}
+function closeMarker(id) {
+  return `${MARKER_CLOSE_PREFIX} id="${id}" ${MARKER_SUFFIX}`;
+}
+function extractAttr(open, name) {
+  const m = open.match(new RegExp(`${name}="([^"]+)"`));
+  return m?.[1] ?? null;
+}
+function findMarker(existing, id) {
+  const openRegex = new RegExp(
+    `${escapeRegex(MARKER_OPEN_PREFIX)}\\s+id="${escapeRegex(id)}"[^>]*${escapeRegex(MARKER_SUFFIX)}`
+  );
+  const openMatch = openRegex.exec(existing);
+  if (!openMatch) return null;
+  const close = closeMarker(id);
+  const closeStart = existing.indexOf(close, openMatch.index + openMatch[0].length);
+  if (closeStart < 0) return null;
+  const openEnd = openMatch.index + openMatch[0].length;
+  const contentRaw = existing.slice(openEnd, closeStart);
+  const content = normalize(contentRaw).replace(/^\n/, "");
+  return {
+    openStart: openMatch.index,
+    openEnd,
+    closeStart,
+    closeEnd: closeStart + close.length,
+    existingHash: extractAttr(openMatch[0], "hash"),
+    existingVersion: extractAttr(openMatch[0], "version"),
+    existingSource: extractAttr(openMatch[0], "source"),
+    content
+  };
+}
+function escapeRegex(s) {
+  return s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+function stripOrphanMarkers(existing, id) {
+  const close = closeMarker(id);
+  const openRegex = new RegExp(
+    `${escapeRegex(MARKER_OPEN_PREFIX)}\\s+id="${escapeRegex(id)}"[^>]*${escapeRegex(MARKER_SUFFIX)}`,
+    "g"
+  );
+  const opens = [];
+  for (const m of existing.matchAll(openRegex)) {
+    if (m.index !== void 0) opens.push(m.index);
+  }
+  const closes = [];
+  let from = 0;
+  for (; ; ) {
+    const idx = existing.indexOf(close, from);
+    if (idx < 0) break;
+    closes.push(idx);
+    from = idx + close.length;
+  }
+  let cleaned = existing;
+  let pairedOpens = 0;
+  let pairedCloses = 0;
+  let oi = 0;
+  let ci = 0;
+  while (oi < opens.length && ci < closes.length) {
+    if (closes[ci] > opens[oi]) {
+      pairedOpens++;
+      pairedCloses++;
+      oi++;
+      ci++;
+    } else {
+      ci++;
+    }
+  }
+  const orphanOpens = opens.length - pairedOpens;
+  const orphanCloses = closes.length - pairedCloses;
+  if (orphanOpens === 0 && orphanCloses === 0) return existing;
+  const allCloses = [...closes].reverse();
+  for (let i = 0; i < orphanCloses; i++) {
+    const idx = allCloses[i];
+    cleaned = cleaned.slice(0, idx) + cleaned.slice(idx + close.length);
+  }
+  const openMatchesAfter = [...cleaned.matchAll(openRegex)].map((m) => m.index ?? -1).filter((i) => i >= 0);
+  const opensToStrip = openMatchesAfter.slice(-orphanOpens);
+  for (let i = opensToStrip.length - 1; i >= 0; i--) {
+    const idx = opensToStrip[i];
+    openRegex.lastIndex = 0;
+    const matchHere = openRegex.exec(cleaned.slice(idx));
+    const len = matchHere?.[0]?.length ?? 0;
+    if (len > 0) cleaned = cleaned.slice(0, idx) + cleaned.slice(idx + len);
+  }
+  return cleaned.replace(/\n{3,}/g, "\n\n");
+}
+function injectManagedSection(existing, id, newContent, meta = {}) {
+  existing = stripOrphanMarkers(existing, id);
+  const newHash = hashContent(newContent);
+  const match = findMarker(existing, id);
+  const canonicalContent = normalize(newContent);
+  if (!match) {
+    const sep2 = existing.length === 0 || existing.endsWith("\n\n") ? "" : existing.endsWith("\n") ? "\n" : "\n\n";
+    const block2 = `${openMarker(id, newHash, meta)}
+${canonicalContent}
+${closeMarker(id)}
+`;
+    return {
+      output: existing + sep2 + block2,
+      status: "created",
+      details: {
+        existingHash: null,
+        actualHash: newHash,
+        newHash,
+        existingVersion: null,
+        existingSource: null
+      }
+    };
+  }
+  const actualHash = hashContent(match.content);
+  const expectedHash = match.existingHash;
+  const userModified = expectedHash !== null && expectedHash !== actualHash;
+  const versionDrift = match.existingVersion !== null && meta.version !== void 0 && match.existingVersion !== meta.version;
+  const details = {
+    existingHash: expectedHash,
+    actualHash,
+    newHash,
+    existingVersion: match.existingVersion,
+    existingSource: match.existingSource,
+    versionDrift
+  };
+  if (canonicalContent === match.content) {
+    const sameMeta = expectedHash === newHash && match.existingVersion === (meta.version ?? null) && match.existingSource === (meta.source ?? null);
+    if (sameMeta) {
+      return { output: existing, status: "unchanged", details };
+    }
+    const replaced2 = existing.slice(0, match.openStart) + openMarker(id, newHash, meta) + existing.slice(match.openEnd, match.closeEnd);
+    return { output: replaced2, status: "updated", details };
+  }
+  if (userModified) {
+    return { output: existing, status: "user-modified-skipped", details };
+  }
+  const block = `${openMarker(id, newHash, meta)}
+${canonicalContent}
+${closeMarker(id)}`;
+  const replaced = existing.slice(0, match.openStart) + block + existing.slice(match.closeEnd);
+  return { output: replaced, status: "updated", details };
+}
+function removeManagedSection(existing, id) {
+  const match = findMarker(existing, id);
+  if (!match) return existing;
+  let endCut = match.closeEnd;
+  if (existing[endCut] === "\n") endCut++;
+  return existing.slice(0, match.openStart) + existing.slice(endCut);
+}
+function extractManagedContent(existing, id) {
+  const match = findMarker(existing, id);
+  return match ? match.content : null;
+}
+function resolveCondition(config, path) {
+  const segments = path.split(".");
+  let cursor = config;
+  for (const seg of segments) {
+    if (cursor === null || cursor === void 0 || typeof cursor !== "object") {
+      return false;
+    }
+    cursor = cursor[seg];
+  }
+  return Boolean(cursor);
+}
+
+// src/lib/render-plan.ts
+var CORE_SOURCE_ID = "@navori/core";
+var CORE_MANAGED_ASSETS = [
+  { id: "idioma-rol", relPath: "core-assets/managed/idioma-rol.md", availableLanguages: ["es"] },
+  { id: "formato-respuesta", relPath: "core-assets/managed/formato-respuesta.md", availableLanguages: ["es"] },
+  { id: "tipado-fuerte", relPath: "core-assets/managed/tipado-fuerte.md", availableLanguages: ["es"] },
+  { id: "cierre-sesion", relPath: "core-assets/managed/cierre-sesion.md", availableLanguages: ["es"] }
+];
+var CORE_VERSION = readBundledCoreVersion();
+function resolveAssetPath(asset, language = "es") {
+  const root = getCoreRoot();
+  if (language === "es") {
+    return { path: resolve4(root, asset.relPath), fallback: false };
+  }
+  const langPath = asset.relPath.replace(/^core-assets\/managed\//, `core-assets/managed/${language}/`);
+  const abs = resolve4(root, langPath);
+  if (existsSync7(abs)) return { path: abs, fallback: false };
+  return { path: resolve4(root, asset.relPath), fallback: true };
+}
+function interpolateTemplate(content, config) {
+  const configRecord = config;
+  return content.replace(/\{\{\s*([a-zA-Z0-9_.]+)\s*\}\}/g, (match, path) => {
+    const segments = path.split(".");
+    let cursor = configRecord;
+    for (const seg of segments) {
+      if (cursor === null || cursor === void 0 || typeof cursor !== "object") {
+        cursor = void 0;
+        break;
+      }
+      cursor = cursor[seg];
+    }
+    if (cursor === void 0 || cursor === null) {
+      return `<not configured: ${path}>`;
+    }
+    if (typeof cursor === "string" || typeof cursor === "number" || typeof cursor === "boolean") {
+      return String(cursor);
+    }
+    return match;
+  });
+}
+function computeRenderPlan(existing, config, options = {}) {
+  const skipIds = options.skipIds ?? /* @__PURE__ */ new Set();
+  let working = existing;
+  const entries = [];
+  const languageFallbacks = [];
+  const updatesAvailable = [];
+  const configRecord = config;
+  const language = config.language;
+  for (const asset of CORE_MANAGED_ASSETS) {
+    if (skipIds.has(asset.id)) {
+      continue;
+    }
+    if (asset.condition) {
+      const truthy = resolveCondition(configRecord, asset.condition);
+      if (!truthy) {
+        const before = working;
+        working = removeManagedSection(working, asset.id);
+        entries.push({
+          asset,
+          source: "core",
+          status: before === working ? "unchanged" : "removed-condition-false",
+          newContent: null
+        });
+        continue;
+      }
+    }
+    const resolved = resolveAssetPath(asset, language);
+    if (resolved.fallback) languageFallbacks.push(asset.id);
+    const rawContent = readFileSync6(resolved.path, "utf-8");
+    const content = interpolateTemplate(rawContent, config);
+    const result = injectManagedSection(working, asset.id, content, {
+      source: CORE_SOURCE_ID,
+      version: CORE_VERSION
+    });
+    if (result.details?.versionDrift && result.details.existingVersion) {
+      updatesAvailable.push({
+        id: asset.id,
+        source: CORE_SOURCE_ID,
+        fromVersion: result.details.existingVersion,
+        toVersion: CORE_VERSION
+      });
+    }
+    entries.push({
+      asset,
+      source: "core",
+      status: result.status,
+      details: result.details,
+      newContent: content
+    });
+    working = result.output;
+  }
+  const missing = [];
+  const declaredEntries = Object.entries(config.plugins ?? {});
+  for (const [declaredId, settings] of declaredEntries) {
+    let plugin;
+    try {
+      plugin = loadPlugin(declaredId);
+    } catch (err) {
+      if (err instanceof PluginNotFoundError) {
+        missing.push({ id: declaredId, reason: "unknown plugin id" });
+      } else if (err instanceof PluginManifestError) {
+        missing.push({ id: declaredId, reason: err.message });
+      } else {
+        throw err;
+      }
+      continue;
+    }
+    const enabled = settings.enabled === true;
+    if (enabled) {
+      const pluginSource = `@navori/plugin-${plugin.manifest.id}`;
+      for (const entry of plugin.managedAssets) {
+        if (skipIds.has(entry.id)) continue;
+        const rawContent = readFileSync6(entry.absPath, "utf-8");
+        const content = interpolateTemplate(rawContent, config);
+        const result = injectManagedSection(working, entry.id, content, {
+          source: pluginSource,
+          version: plugin.manifest.version
+        });
+        if (result.details?.versionDrift && result.details.existingVersion) {
+          updatesAvailable.push({
+            id: entry.id,
+            source: pluginSource,
+            fromVersion: result.details.existingVersion,
+            toVersion: plugin.manifest.version
+          });
+        }
+        entries.push({
+          asset: { id: entry.id, relPath: entry.absPath },
+          source: plugin.manifest.id,
+          status: result.status,
+          details: result.details,
+          newContent: content
+        });
+        working = result.output;
+      }
+    } else {
+      for (const entry of plugin.managedAssets) {
+        if (skipIds.has(entry.id)) continue;
+        const before = working;
+        working = removeManagedSection(working, entry.id);
+        entries.push({
+          asset: { id: entry.id, relPath: entry.absPath },
+          source: plugin.manifest.id,
+          status: before === working ? "unchanged" : "removed-condition-false",
+          newContent: null
+        });
+      }
+    }
+  }
+  return {
+    existing,
+    next: working,
+    changed: working !== existing,
+    entries,
+    missingPlugins: missing,
+    languageFallbacks,
+    updatesAvailable
+  };
+}
+function applyPlanWithSkips(existing, config, skipIds) {
+  return computeRenderPlan(existing, config, { skipIds }).next;
+}
+
+// src/lib/backup.ts
+import { mkdirSync as mkdirSync3, copyFileSync as copyFileSync3, existsSync as existsSync8, readdirSync as readdirSync5, rmSync as rmSync4, statSync as statSync5 } from "fs";
+import { dirname as dirname4, join as join7, relative, resolve as resolve5 } from "path";
+function backupRootLazy() {
+  return join7(safeHomedir(), ".navori", "backups");
+}
+var DEFAULT_RETENTION_DAYS = 30;
+function timestamp2() {
+  const d = /* @__PURE__ */ new Date();
+  const pad = (n) => String(n).padStart(2, "0");
+  return [
+    d.getFullYear(),
+    "-",
+    pad(d.getMonth() + 1),
+    "-",
+    pad(d.getDate()),
+    "T",
+    pad(d.getHours()),
+    "-",
+    pad(d.getMinutes()),
+    "-",
+    pad(d.getSeconds())
+  ].join("");
+}
+function createBackup(repoRoot, files) {
+  const dir = join7(backupRootLazy(), timestamp2());
+  mkdirSync3(dir, { recursive: true });
+  const copied = [];
+  for (const file of files) {
+    const abs = resolve5(repoRoot, file);
+    if (!existsSync8(abs)) continue;
+    const rel = relative(repoRoot, abs);
+    const dest = join7(dir, rel);
+    mkdirSync3(dirname4(dest), { recursive: true });
+    copyFileSync3(abs, dest);
+    copied.push(rel);
+  }
+  return { path: dir, files: copied };
+}
+function purgeOldBackups(retentionDays = DEFAULT_RETENTION_DAYS) {
+  const root = backupRootLazy();
+  if (!existsSync8(root)) return [];
+  const cutoff = Date.now() - retentionDays * 24 * 60 * 60 * 1e3;
+  const pruned = [];
+  for (const entry of readdirSync5(root)) {
+    const full = join7(root, entry);
+    const stat = statSync5(full);
+    if (!stat.isDirectory()) continue;
+    if (stat.mtimeMs < cutoff) {
+      rmSync4(full, { recursive: true, force: true });
+      pruned.push(full);
+    }
+  }
+  return pruned;
+}
+function backupRoot() {
+  return backupRootLazy();
+}
+
+// src/lib/style.ts
+import pc from "picocolors";
+var color = pc;
+var sym = {
+  created: "+",
+  updated: "~",
+  unchanged: "\xB7",
+  conflict: "!",
+  removed: "-",
+  update: "\u21E1",
+  bullet: "\xB7",
+  ok: "\u2713",
+  fail: "\u2717",
+  empty: "\u25CB",
+  arrow: "\u2192"
+};
+function renderStatusSymbol(status) {
+  switch (status) {
+    case "created":
+      return color.green(sym.created);
+    case "updated":
+      return color.yellow(sym.updated);
+    case "unchanged":
+      return color.dim(sym.unchanged);
+    case "user-modified-skipped":
+      return color.red(sym.conflict);
+    case "removed-condition-false":
+      return color.magenta(sym.removed);
+  }
+}
+function renderStatusLabel(status) {
+  switch (status) {
+    case "created":
+      return color.green(status);
+    case "updated":
+      return color.yellow(status);
+    case "unchanged":
+      return color.dim(status);
+    case "user-modified-skipped":
+      return color.red(status);
+    case "removed-condition-false":
+      return color.magenta(status);
+  }
+}
+function dim(s) {
+  return color.dim(s);
+}
+function accent(s) {
+  return color.cyan(s);
+}
+function brand(suffix) {
+  const head = color.bold(color.cyan("navori"));
+  return suffix ? `${head} ${color.dim(suffix)}` : head;
+}
+function check(ok) {
+  return ok ? color.green(sym.ok) : color.dim(sym.empty);
+}
+function kv(rows, opts = {}) {
+  const indent = opts.indent ?? "  ";
+  const width = rows.reduce((m, [k]) => Math.max(m, k.length), 0);
+  return rows.map(([k, v]) => `${indent}${color.dim(k.padEnd(width))} ${color.dim(":")} ${v}`).join("\n");
+}
+
+// src/commands/render.ts
+function runRender(cwd, dryRun = false) {
+  const configPath = `${cwd}/navori.config.json`;
+  const claudeMdPath = `${cwd}/CLAUDE.md`;
+  if (!existsSync9(configPath)) {
+    return {
+      ok: false,
+      reason: `No navori.config.json at ${configPath}`,
+      filePath: claudeMdPath,
+      entries: [],
+      written: false,
+      languageFallbacks: [],
+      updatesAvailable: [],
+      backupPath: null
+    };
+  }
+  const config = readConfig(configPath);
+  const existing = existsSync9(claudeMdPath) ? readFileSync7(claudeMdPath, "utf-8") : "";
+  const plan = computeRenderPlan(existing, config);
+  let backupPath = null;
+  if (plan.changed && !dryRun) {
+    if (existsSync9(claudeMdPath)) {
+      const handle = createBackup(cwd, ["CLAUDE.md"]);
+      backupPath = handle.path;
+      purgeOldBackups();
+    }
+    writeFileAtomic(claudeMdPath, plan.next);
+  }
+  return {
+    ok: true,
+    filePath: claudeMdPath,
+    entries: plan.entries,
+    written: plan.changed && !dryRun,
+    languageFallbacks: plan.languageFallbacks,
+    updatesAvailable: plan.updatesAvailable,
+    backupPath
+  };
+}
+var renderCommand = defineCommand({
+  meta: {
+    name: "render",
+    description: "Render managed Core blocks into CLAUDE.md based on navori.config.json"
+  },
+  args: {
+    cwd: { type: "string", description: "Directory to render into (default: cwd)" },
+    "dry-run": { type: "boolean", description: "Show what would change without writing" }
+  },
+  async run({ args }) {
+    const cwd = resolve6(args.cwd ?? process.cwd());
+    p.intro(brand("render"));
+    if (!existsSync9(cwd)) {
+      p.cancel(`Directory not found: ${cwd}`);
+      process.exit(1);
+    }
+    const result = runRender(cwd, Boolean(args["dry-run"]));
+    if (!result.ok) {
+      p.cancel(`${result.reason}. Run 'navori init' first.`);
+      process.exit(1);
+    }
+    reportPlan(result.filePath, result.entries, result.written, Boolean(args["dry-run"]));
+    if (result.languageFallbacks.length > 0) {
+      p.log.warn(
+        `Language fallback to Spanish for: ${result.languageFallbacks.join(", ")} (English version not available yet)`
+      );
+    }
+    if (result.backupPath) {
+      p.log.message(`${dim("Backup:")} ${result.backupPath}`);
+    }
+    const summary = summarize(result.entries);
+    if (args["dry-run"]) {
+      p.outro(`${dim("Dry-run complete")} ${summary}`);
+    } else if (result.written) {
+      p.outro(`${color.green("Done")} ${summary}`);
+    } else {
+      p.outro(`${dim("Up to date")} ${summary}`);
+    }
+  }
+});
+function summarize(entries) {
+  const counts = entries.reduce((acc, e) => {
+    acc[e.status] = (acc[e.status] ?? 0) + 1;
+    return acc;
+  }, {});
+  const parts = [];
+  if (counts.created) parts.push(color.green(`${counts.created} created`));
+  if (counts.updated) parts.push(color.yellow(`${counts.updated} updated`));
+  if (counts["user-modified-skipped"]) parts.push(color.red(`${counts["user-modified-skipped"]} conflict`));
+  if (counts["removed-condition-false"]) parts.push(color.magenta(`${counts["removed-condition-false"]} removed`));
+  if (counts.unchanged) parts.push(dim(`${counts.unchanged} unchanged`));
+  return parts.length > 0 ? `${dim("\u2014")} ${parts.join(dim(", "))}` : "";
+}
+function reportPlan(file, entries, changed, dryRun) {
+  const lines = [file];
+  for (const e of entries) {
+    const sym3 = renderStatusSymbol(e.status);
+    const label = renderStatusLabel(e.status);
+    lines.push(`  ${sym3} ${e.asset.id}  ${dim("(")}${label}${dim(")")}`);
+  }
+  if (changed && !dryRun) lines.push(`  ${dim("\u2192 written")}`);
+  else if (dryRun) lines.push(`  ${dim("\u2192 dry-run, no write")}`);
+  else lines.push(`  ${dim("\u2192 no changes")}`);
+  p.log.message(lines.join("\n"));
+}
+
+// src/commands/init-format.ts
+function formatInfraSummary(infra) {
+  const rows = [];
+  if (infra.agentFiles.length > 0) {
+    rows.push([".claude/agents/", `${infra.agentFiles.join(", ")} ${dim(`(${infra.agentFiles.length})`)}`]);
+  }
+  if (infra.skillFiles.length > 0) {
+    const preview = infra.skillFiles.slice(0, 3).join(", ");
+    const more = infra.skillFiles.length > 3 ? dim(` (+${infra.skillFiles.length - 3} more)`) : "";
+    rows.push([".claude/skills/", `${preview}${more} ${dim(`(${infra.skillFiles.length})`)}`]);
+  }
+  if (infra.hasSettings) rows.push([".claude/settings.json", dim("present")]);
+  if (infra.hasLocalSettings) rows.push([".claude/settings.local.json", dim("present (gitignored)")]);
+  if (infra.hasClaudeMd) rows.push(["CLAUDE.md", dim("present")]);
+  if (infra.hasAgentsMd) rows.push(["AGENTS.md", dim("present")]);
+  if (infra.hasCheckpointsMd) rows.push(["CHECKPOINTS.md", dim("present")]);
+  if (infra.hasFeatureList) rows.push(["feature_list.json", dim("present")]);
+  if (infra.progressFiles > 0) rows.push(["progress/", dim(`${infra.progressFiles} file(s)`)]);
+  if (infra.specsDirs > 0) rows.push(["specs/", dim(`${infra.specsDirs} feature(s)`)]);
+  return kv(rows);
+}
+function formatDetectionSummary(d) {
+  const rows = [];
+  rows.push([
+    "name",
+    d.name ? `${color.cyan(d.name)}  ${dim(`(from ${d.sources.name})`)}` : dim("(not detected \u2014 will ask)")
+  ]);
+  rows.push([
+    "branchBase",
+    d.branchBase ? `${d.branchBase}  ${dim(`(from ${d.sources.branchBase})`)}` : `main  ${dim("(default \u2014 no git detected)")}`
+  ]);
+  rows.push([
+    "engines",
+    d.existingEngines.length > 0 ? `${d.existingEngines.join(", ")}  ${dim("(found in repo)")}` : `claude  ${dim("(default \u2014 nothing detected)")}`
+  ]);
+  if (d.stack.language !== "unknown") rows.push(["stack lang", d.stack.language]);
+  if (d.stack.framework) rows.push(["framework", d.stack.framework]);
+  if (d.stack.ui) rows.push(["ui", d.stack.ui]);
+  if (d.stack.forms) rows.push(["forms", d.stack.forms]);
+  if (d.stack.state) rows.push(["state", d.stack.state]);
+  if (d.stack.test) rows.push(["test", d.stack.test]);
+  if (d.packageManager) {
+    rows.push(["packageManager", `${d.packageManager}  ${dim(`(from ${d.sources.packageManager})`)}`]);
+  }
+  if (d.monorepo) {
+    rows.push(["monorepo", `${d.monorepo.tool}  ${dim(`(from ${d.monorepo.source})`)}`]);
+  }
+  rows.push(["preset", `${d.suggestedPreset}  ${dim("(suggested)")}`]);
+  rows.push(["asset lang", `es  ${dim("(default \u2014 change in wizard if you need 'en' fallback)")}`]);
+  if (d.qualityGate) {
+    rows.push(["qualityGate", `${d.qualityGate.full}  ${dim("(from package.json scripts)")}`]);
+  }
+  return kv(rows);
+}
+function formatWorkspaceSummary(ws) {
+  const d = ws.defaults;
+  const rows = [];
+  if (d.branchBase) rows.push(["branchBase", d.branchBase]);
+  if (d.commits) rows.push(["commits", d.commits]);
+  if (d.language) rows.push(["language", d.language]);
+  if (d.engines && d.engines.length > 0) rows.push(["engines", d.engines.join(", ")]);
+  if (d.plugins && Object.keys(d.plugins).length > 0) {
+    const enabled = Object.entries(d.plugins).filter(([, v]) => v.enabled).map(([k]) => k);
+    rows.push(["plugins", enabled.join(", ") || dim("(none enabled)")]);
+  }
+  if (rows.length === 0) {
+    return `  ${dim("(workspace has no defaults configured)")}`;
+  }
+  return kv(rows);
+}
+
+// src/commands/init.ts
+var ENGINE_OPTIONS = [
+  { value: "claude", label: "Claude Code (.claude/)" },
+  { value: "agents-md", label: "AGENTS.md (universal \u2014 Cursor / Codex / Gemini read it)" },
+  { value: "cursor", label: "Cursor (.cursor/rules/)" },
+  { value: "copilot", label: "Copilot (.github/copilot-instructions.md)" }
+];
+var initCommand = defineCommand2({
+  meta: {
+    name: "init",
+    description: "Adopt navori in the current repo (auto-detects stack, presets, quality gate)"
+  },
+  args: {
+    yes: {
+      type: "boolean",
+      description: "Accept all detected values + render automatically without prompting"
+    },
+    cwd: {
+      type: "string",
+      description: "Directory to initialize (default: current working directory)"
+    },
+    render: {
+      type: "boolean",
+      default: true,
+      description: "Render CLAUDE.md after writing config. Disable with --no-render."
+    },
+    workspace: {
+      type: "string",
+      description: "Workspace to inherit defaults from (must exist via 'workspace init')"
+    },
+    recommended: {
+      type: "boolean",
+      description: "Opinionated mode: --yes + auto-enable recommended plugins (engram, +gh if GitHub repo)"
+    }
+  },
+  async run({ args }) {
+    const cwd = resolve7(args.cwd ?? process.cwd());
+    const configPath = `${cwd}/navori.config.json`;
+    const autoYes = Boolean(args.yes || args.recommended);
+    p2.intro(brand("init"));
+    if (!existsSync10(cwd)) {
+      p2.cancel(`Directory not found: ${cwd}`);
+      process.exit(1);
+    }
+    if (existsSync10(configPath)) {
+      p2.cancel(`navori.config.json already exists at ${configPath}.`);
+      process.exit(1);
+    }
+    const detected = detectProject(cwd);
+    const mode = await chooseAdoptionMode(cwd, detected.claudeInfra, detected.name, {
+      yes: autoYes
+    });
+    if (mode === null) return cancel3();
+    let workspaceConfig = null;
+    if (args.workspace) {
+      try {
+        workspaceConfig = loadWorkspace(args.workspace);
+      } catch (err) {
+        if (err instanceof WorkspaceError) {
+          p2.cancel(err.message);
+          process.exit(1);
+        }
+        throw err;
+      }
+      if (!workspaceConfig) {
+        p2.cancel(
+          `Workspace '${args.workspace}' not found. Create it with 'navori workspace init ${args.workspace}'.`
+        );
+        process.exit(1);
+      }
+      p2.note(formatWorkspaceSummary(workspaceConfig), `Workspace defaults \xB7 ${workspaceConfig.name}`);
+    }
+    p2.note(formatDetectionSummary(detected), "Detected from this repo");
+    const wsDefaults = workspaceConfig?.defaults;
+    const defaultEngines = wsDefaults?.engines ?? (detected.existingEngines.length > 0 ? detected.existingEngines : ["claude"]);
+    const defaultBranchBase = wsDefaults?.branchBase ?? detected.branchBase ?? "main";
+    const defaultLanguage = wsDefaults?.language ?? "es";
+    const defaultCommits = wsDefaults?.commits;
+    if (autoYes) {
+      if (!detected.name) {
+        p2.cancel("Could not detect project name. Run without --yes/--recommended to provide one.");
+        process.exit(1);
+      }
+      const wsPlugins2 = wsDefaults?.plugins ?? {};
+      const recommendedPlugins = args.recommended ? buildRecommendedPlugins(cwd) : {};
+      const mergedPlugins2 = { ...wsPlugins2, ...recommendedPlugins };
+      if (args.recommended && Object.keys(recommendedPlugins).length > 0) {
+        p2.log.info(
+          `Recommended plugins enabled: ${Object.keys(recommendedPlugins).join(", ")}`
+        );
+      }
+      writeConfig(configPath, {
+        name: detected.name,
+        ...args.workspace ? { workspace: args.workspace } : {},
+        engines: defaultEngines,
+        preset: detected.suggestedPreset,
+        language: defaultLanguage,
+        branchBase: defaultBranchBase,
+        ...defaultCommits ? { commits: defaultCommits } : {},
+        ...detected.qualityGate ? { qualityGate: detected.qualityGate } : {},
+        ...Object.keys(mergedPlugins2).length > 0 ? { plugins: mergedPlugins2 } : {}
+      });
+      p2.log.success(`Wrote ${configPath}`);
+      if (mode === "coexist") {
+        p2.outro("Done \u2014 existing files not touched. Run 'navori render' when ready.");
+        return;
+      }
+      if (args.render !== false) renderInline(cwd);
+      p2.outro("Done");
+      return;
+    }
+    const accept = await p2.confirm({
+      message: detected.name ? `Use these values?` : `Project name could not be detected. Adjust?`,
+      initialValue: Boolean(detected.name)
+    });
+    if (p2.isCancel(accept)) return cancel3();
+    let name = detected.name;
+    let engines = defaultEngines;
+    let branchBase = defaultBranchBase;
+    let workspace = args.workspace;
+    let preset = detected.suggestedPreset;
+    let qualityGate = detected.qualityGate;
+    let language = defaultLanguage;
+    if (!accept || !detected.name) {
+      const toAdjust = await p2.multiselect({
+        message: "What do you want to change?",
+        options: [
+          { value: "name", label: `Project name${detected.name ? ` (${detected.name})` : " (not detected)"}` },
+          { value: "language", label: `Language (${defaultLanguage} \u2014 default)` },
+          { value: "workspace", label: "Workspace" },
+          { value: "engines", label: `Engines (${defaultEngines.join(", ")})` },
+          { value: "preset", label: `Preset (${preset})` },
+          { value: "branchBase", label: `Base branch (${defaultBranchBase})` },
+          { value: "qualityGate", label: qualityGate ? `Quality gate (${qualityGate.full})` : "Quality gate (not detected)" }
+        ],
+        required: !detected.name,
+        initialValues: detected.name ? [] : ["name"]
+      });
+      if (p2.isCancel(toAdjust)) return cancel3();
+      const adjustments = toAdjust;
+      if (adjustments.includes("name") || !name) {
+        const value = await p2.text({
+          message: "Project name (kebab-case)",
+          placeholder: detected.name ?? "my-project",
+          defaultValue: detected.name ?? "",
+          validate(v) {
+            if (!/^[a-z0-9][a-z0-9-]*$/.test(v)) return "Must be kebab-case (lowercase, hyphens)";
+            return void 0;
+          }
+        });
+        if (p2.isCancel(value)) return cancel3();
+        name = value;
+      }
+      if (adjustments.includes("language")) {
+        const value = await p2.select({
+          message: "Language for managed Core assets",
+          options: [
+            { value: "es", label: "Espa\xF1ol (default \u2014 full coverage)" },
+            { value: "en", label: "English (limited \u2014 falls back to es if asset not localized)" }
+          ],
+          initialValue: defaultLanguage
+        });
+        if (p2.isCancel(value)) return cancel3();
+        language = value;
+      }
+      if (adjustments.includes("workspace")) {
+        const value = await p2.text({
+          message: "Workspace (optional, e.g. bonum, navori)",
+          placeholder: "leave empty for none"
+        });
+        if (p2.isCancel(value)) return cancel3();
+        const trimmed = value.trim();
+        if (trimmed) workspace = trimmed;
+      }
+      if (adjustments.includes("engines")) {
+        const value = await p2.multiselect({
+          message: "Engines to target",
+          options: ENGINE_OPTIONS,
+          required: true,
+          initialValues: defaultEngines
+        });
+        if (p2.isCancel(value)) return cancel3();
+        engines = value;
+      }
+      if (adjustments.includes("preset")) {
+        const value = await p2.text({
+          message: "Stack preset (free text for v1)",
+          placeholder: preset,
+          defaultValue: preset
+        });
+        if (p2.isCancel(value)) return cancel3();
+        preset = value;
+      }
+      if (adjustments.includes("branchBase")) {
+        const value = await p2.text({
+          message: "Base branch",
+          placeholder: defaultBranchBase,
+          defaultValue: defaultBranchBase
+        });
+        if (p2.isCancel(value)) return cancel3();
+        branchBase = value;
+      }
+      if (adjustments.includes("qualityGate")) {
+        const fastVal = await p2.text({
+          message: "Quality gate (fast \u2014 runs on Stop hook)",
+          placeholder: qualityGate?.fast ?? "pnpm tsc --noEmit",
+          defaultValue: qualityGate?.fast ?? ""
+        });
+        if (p2.isCancel(fastVal)) return cancel3();
+        const fullVal = await p2.text({
+          message: "Quality gate (full \u2014 runs before close session)",
+          placeholder: qualityGate?.full ?? fastVal,
+          defaultValue: qualityGate?.full ?? fastVal
+        });
+        if (p2.isCancel(fullVal)) return cancel3();
+        if (fastVal.trim() && fullVal.trim()) {
+          qualityGate = { fast: fastVal.trim(), full: fullVal.trim() };
+        }
+      }
+    }
+    if (!name) {
+      p2.cancel("Project name is required");
+      process.exit(1);
+    }
+    const pluginsToEnable = await pickPlugins();
+    if (pluginsToEnable === null) return cancel3();
+    const pluginsConfig = pluginsToEnable.reduce(
+      (acc, id) => {
+        acc[id] = { enabled: true };
+        return acc;
+      },
+      {}
+    );
+    const agentAssignments = await pickAgentAssignments(pluginsToEnable);
+    if (agentAssignments === null) return cancel3();
+    const wsPlugins = wsDefaults?.plugins ?? {};
+    const mergedPlugins = { ...wsPlugins, ...pluginsConfig };
+    writeConfig(configPath, {
+      name,
+      ...workspace ? { workspace } : {},
+      engines,
+      preset,
+      language,
+      branchBase,
+      ...defaultCommits ? { commits: defaultCommits } : {},
+      ...qualityGate ? { qualityGate } : {},
+      ...Object.keys(mergedPlugins).length > 0 ? { plugins: mergedPlugins } : {},
+      ...Object.keys(agentAssignments).length > 0 ? { agentAssignments } : {}
+    });
+    p2.log.success(`Wrote ${configPath}`);
+    if (mode === "coexist") {
+      p2.outro("Done \u2014 existing files not touched. Run 'navori render' when ready.");
+      return;
+    }
+    if (args.render === false) {
+      p2.outro("Done (skipped render)");
+      return;
+    }
+    const shouldRender = await p2.confirm({
+      message: "Render CLAUDE.md now?",
+      initialValue: true
+    });
+    if (p2.isCancel(shouldRender) || !shouldRender) {
+      p2.outro("Done (run 'navori render' when ready)");
+      return;
+    }
+    renderInline(cwd);
+    p2.outro("Your harness is ready");
+  }
+});
+async function chooseAdoptionMode(cwd, infra, projectName, args) {
+  if (!infra.present) return "fresh";
+  if (args.yes) {
+    p2.log.warn("Existing Claude infrastructure detected \u2014 using 'coexist' mode (safe)");
+    return "coexist";
+  }
+  p2.log.warn("Existing Claude infrastructure detected:");
+  p2.note(formatInfraSummary(infra), "Files found");
+  const choice = await p2.select({
+    message: "How do you want to adopt navori?",
+    options: [
+      {
+        value: "coexist",
+        label: "Coexist (recommended)",
+        hint: "add what's missing, never modify existing files"
+      },
+      {
+        value: "replace",
+        label: "Replace",
+        hint: "backup everything to ~/.navori/migrations/<ts>/ and start fresh"
+      }
+    ],
+    initialValue: "coexist"
+  });
+  if (p2.isCancel(choice)) return null;
+  if (choice === "replace") {
+    const confirm10 = await p2.confirm({
+      message: `This will move .claude/, CLAUDE.md, AGENTS.md, CHECKPOINTS.md, feature_list.json, progress/, specs/ to ~/.navori/migrations/. Continue?`,
+      initialValue: false
+    });
+    if (p2.isCancel(confirm10) || !confirm10) return null;
+    const backup = createMigrationBackup(cwd, projectName ?? "unknown");
+    p2.log.success(`Backed up ${backup.movedPaths.length} item(s) to ${backup.path}`);
+    removeOriginals(cwd, backup.movedPaths);
+    p2.log.info(`Removed originals from ${cwd}`);
+    return "replace";
+  }
+  return "coexist";
+}
+async function pickPlugins() {
+  const ids = listKnownPluginIds();
+  if (ids.length === 0) return [];
+  const options = ids.map((id) => {
+    const plugin = (() => {
+      try {
+        return loadPlugin(id);
+      } catch {
+        return null;
+      }
+    })();
+    return {
+      value: id,
+      label: plugin ? `${plugin.manifest.name} (${id})` : id,
+      hint: plugin?.manifest.description
+    };
+  });
+  const selected = await p2.multiselect({
+    message: "Plugins to enable",
+    options,
+    required: false,
+    initialValues: []
+  });
+  if (p2.isCancel(selected)) return null;
+  return selected;
+}
+async function pickAgentAssignments(enabledPlugins) {
+  if (enabledPlugins.length === 0) return {};
+  const recommendations = [];
+  for (const pluginId of enabledPlugins) {
+    let plugin;
+    try {
+      plugin = loadPlugin(pluginId);
+    } catch {
+      continue;
+    }
+    for (const entry of plugin.manifest.managed) {
+      if (entry.recommendedAgent) {
+        recommendations.push({
+          id: entry.id,
+          pluginId,
+          recommendedAgent: entry.recommendedAgent
+        });
+      }
+    }
+  }
+  if (recommendations.length === 0) return {};
+  const summary = recommendations.map((r) => `  \xB7 ${r.id} (${r.pluginId})  \u2192  ${r.recommendedAgent}`).join("\n");
+  p2.log.message(`Recommended skill \u2192 agent assignments:
+${summary}`);
+  const accept = await p2.confirm({
+    message: "Use these assignments?",
+    initialValue: true
+  });
+  if (p2.isCancel(accept)) return null;
+  if (accept) return {};
+  const overrides = {};
+  const agentOptions = [
+    { value: "leader", label: "leader (orquestador)" },
+    { value: "implementer", label: "implementer (escribe c\xF3digo)" },
+    { value: "reviewer", label: "reviewer (revisa diff)" },
+    { value: "researcher", label: "researcher (lee, no escribe)" },
+    { value: "ticket-audit", label: "ticket-audit (an\xE1lisis profundo)" },
+    { value: "commit-pr-pilot", label: "commit-pr-pilot (commits + PRs)" },
+    { value: "explorer", label: "explorer (exploraci\xF3n inicial)" }
+  ];
+  for (const rec of recommendations) {
+    const choice = await p2.select({
+      message: `Agent for '${rec.id}' (${rec.pluginId})`,
+      options: agentOptions,
+      initialValue: rec.recommendedAgent
+    });
+    if (p2.isCancel(choice)) return null;
+    if (choice !== rec.recommendedAgent) {
+      overrides[rec.id] = choice;
+    }
+  }
+  return overrides;
+}
+function buildRecommendedPlugins(cwd) {
+  const result = {
+    engram: { enabled: true }
+  };
+  if (isGitHubRepo(cwd)) {
+    result.gh = { enabled: true };
+  }
+  return result;
+}
+function isGitHubRepo(cwd) {
+  const r = spawnSync2("git", ["-C", cwd, "config", "--get", "remote.origin.url"], {
+    encoding: "utf-8",
+    stdio: ["ignore", "pipe", "ignore"]
+  });
+  if (r.status !== 0) return false;
+  return /github\.com/i.test(r.stdout);
+}
+function renderInline(cwd) {
+  const result = runRender(cwd, false);
+  if (!result.ok) {
+    p2.log.error(result.reason ?? "Render failed");
+    return;
+  }
+  const counts = result.entries.reduce((acc, e) => {
+    acc[e.status] = (acc[e.status] ?? 0) + 1;
+    return acc;
+  }, {});
+  const parts = [];
+  if (counts.created) parts.push(color.green(`${counts.created} created`));
+  if (counts.updated) parts.push(color.yellow(`${counts.updated} updated`));
+  if (counts["user-modified-skipped"]) parts.push(color.red(`${counts["user-modified-skipped"]} conflict`));
+  if (counts["removed-condition-false"]) parts.push(color.magenta(`${counts["removed-condition-false"]} removed`));
+  if (counts.unchanged) parts.push(dim(`${counts.unchanged} unchanged`));
+  const summary = parts.length > 0 ? ` ${dim("\u2014")} ${parts.join(dim(", "))}` : "";
+  if (result.written) {
+    p2.log.success(`Rendered ${result.filePath}${summary}`);
+  } else {
+    p2.log.info(`No render needed${summary}`);
+  }
+}
+function cancel3() {
+  p2.cancel("Cancelled");
+  process.exit(0);
+}
+
+// src/commands/doctor.ts
+import { defineCommand as defineCommand3 } from "citty";
+import * as p3 from "@clack/prompts";
+import { existsSync as existsSync11, readFileSync as readFileSync8 } from "fs";
+import { resolve as resolve8 } from "path";
+function listMarkers(filePath) {
+  if (!existsSync11(filePath)) return [];
+  const content = readFileSync8(filePath, "utf-8");
+  const re = /<!-- navori:managed [^>]*-->/g;
+  const result = [];
+  for (const match of content.matchAll(re)) {
+    const tag = match[0];
+    if (tag.startsWith("<!-- /navori:managed")) continue;
+    const id = tag.match(/id="([^"]+)"/)?.[1] ?? "?";
+    const hash = tag.match(/hash="([^"]+)"/)?.[1] ?? null;
+    const version = tag.match(/version="([^"]+)"/)?.[1] ?? null;
+    const source = tag.match(/source="([^"]+)"/)?.[1] ?? null;
+    result.push({ id, hash, version, source });
+  }
+  return result;
+}
+var doctorCommand = defineCommand3({
+  meta: {
+    name: "doctor",
+    description: "Inspect navori.config.json and report resolved state + managed blocks"
+  },
+  args: {
+    cwd: { type: "string", description: "Directory to inspect (default: cwd)" },
+    json: { type: "boolean", description: "Output as JSON (pipeable)" }
+  },
+  async run({ args }) {
+    const cwd = resolve8(args.cwd ?? process.cwd());
+    const configPath = `${cwd}/navori.config.json`;
+    const claudeMdPath = `${cwd}/CLAUDE.md`;
+    if (!args.json) p3.intro(brand("doctor"));
+    if (!existsSync11(cwd)) {
+      if (args.json) {
+        console.log(JSON.stringify({ ok: false, error: "directory-missing", cwd }));
+      } else {
+        p3.cancel(`Directory not found: ${cwd}`);
+      }
+      process.exit(1);
+    }
+    if (!existsSync11(configPath)) {
+      if (args.json) {
+        console.log(JSON.stringify({ ok: false, error: "config-missing", configPath }));
+      } else {
+        p3.cancel(`No navori.config.json at ${configPath}. Run 'navori init' first.`);
+      }
+      process.exit(1);
+    }
+    let config;
+    try {
+      config = readConfig(configPath);
+    } catch (err) {
+      if (err instanceof ConfigError) {
+        if (args.json) {
+          console.log(JSON.stringify({ ok: false, error: "config-invalid", message: err.message, issues: err.issues }));
+        } else {
+          p3.cancel(err.message);
+          if (err.issues) {
+            for (const issue of err.issues) {
+              console.error(`  - ${issue.path.join(".") || "(root)"}: ${issue.message}`);
+            }
+          }
+        }
+        process.exit(1);
+      }
+      throw err;
+    }
+    const markers = listMarkers(claudeMdPath);
+    const missingPlugins = collectMissingPlugins(config);
+    const report = {
+      ok: missingPlugins.length === 0,
+      configPath,
+      config,
+      checks: {
+        claudeMdExists: existsSync11(claudeMdPath),
+        agentsMdExists: existsSync11(`${cwd}/AGENTS.md`),
+        claudeDirExists: existsSync11(`${cwd}/.claude`),
+        progressDirExists: existsSync11(`${cwd}/${config.progress?.dir ?? "progress"}`)
+      },
+      managedBlocks: markers,
+      missingPlugins
+    };
+    if (args.json) {
+      console.log(JSON.stringify(report, null, 2));
+      return;
+    }
+    p3.note(
+      kv([
+        ["name", accent(config.name)],
+        ["version", config.version],
+        ["workspace", config.workspace ?? dim("(none)")],
+        ["engines", config.engines.join(", ")],
+        ["preset", config.preset],
+        ["language", config.language],
+        ["branchBase", config.branchBase],
+        ["commits", config.commits]
+      ]),
+      `Config \xB7 ${dim(configPath)}`
+    );
+    p3.note(
+      [
+        `  ${check(report.checks.claudeMdExists)} CLAUDE.md`,
+        `  ${check(report.checks.agentsMdExists)} AGENTS.md`,
+        `  ${check(report.checks.claudeDirExists)} .claude/`,
+        `  ${check(report.checks.progressDirExists)} ${config.progress?.dir ?? "progress"}/`
+      ].join("\n"),
+      "Filesystem checks"
+    );
+    if (markers.length > 0) {
+      const lines = markers.map((m) => {
+        const ver = m.version ? dim(` v${m.version}`) : dim(" (no version)");
+        const src = m.source ?? dim("(unknown source)");
+        return `  ${color.cyan(sym.bullet)} ${accent(m.id)}  ${dim("\u2190")}  ${src}${ver}`;
+      });
+      p3.note(lines.join("\n"), `Managed blocks in CLAUDE.md \xB7 ${markers.length}`);
+    }
+    const assignments = collectAssignments(config);
+    if (assignments.length > 0) {
+      const lines = assignments.map((a) => {
+        const override = a.override ? `  ${dim("(overridden)")}` : "";
+        return `  ${color.cyan(sym.bullet)} ${accent(a.id)}  ${dim("\u2192")}  ${a.agent}${override}`;
+      });
+      p3.note(lines.join("\n"), `Skill \u2192 agent assignments \xB7 ${assignments.length}`);
+    }
+    if (missingPlugins.length > 0) {
+      const lines = missingPlugins.map((m) => `  ${color.red(sym.fail)} ${m.id}  ${dim(`\u2014 ${m.reason}`)}`);
+      p3.log.warn(`Plugins declared in config but not loadable (${missingPlugins.length}):
+${lines.join("\n")}`);
+    }
+    p3.outro(missingPlugins.length > 0 ? color.red("Issues found") : color.green("OK"));
+  }
+});
+function collectMissingPlugins(config) {
+  const missing = [];
+  for (const [id, settings] of Object.entries(config.plugins ?? {})) {
+    if (settings.enabled !== true) continue;
+    try {
+      loadPlugin(id);
+    } catch (err) {
+      if (err instanceof PluginNotFoundError) {
+        missing.push({ id, reason: "unknown plugin id" });
+      } else if (err instanceof PluginManifestError) {
+        missing.push({ id, reason: err.message });
+      } else {
+        missing.push({ id, reason: err.message });
+      }
+    }
+  }
+  return missing;
+}
+function collectAssignments(config) {
+  const overrides = config.agentAssignments ?? {};
+  const out = [];
+  for (const [pluginId, settings] of Object.entries(config.plugins ?? {})) {
+    if (settings.enabled !== true) continue;
+    let plugin;
+    try {
+      plugin = loadPlugin(pluginId);
+    } catch {
+      continue;
+    }
+    for (const entry of plugin.manifest.managed) {
+      const overrideValue = overrides[entry.id];
+      if (overrideValue) {
+        out.push({ id: entry.id, agent: overrideValue, override: true });
+      } else if (entry.recommendedAgent) {
+        out.push({ id: entry.id, agent: entry.recommendedAgent, override: false });
+      }
+    }
+  }
+  return out;
+}
+
+// src/commands/sync.ts
+import { defineCommand as defineCommand4 } from "citty";
+import * as p4 from "@clack/prompts";
+import { existsSync as existsSync12, readFileSync as readFileSync9 } from "fs";
+import { resolve as resolve9 } from "path";
+
+// src/lib/diff.ts
+function formatLineDiff(current, proposed, options = {}) {
+  const a = (current ?? "").split("\n");
+  const b = (proposed ?? "").split("\n");
+  const max = Math.max(a.length, b.length);
+  const lines = [];
+  for (let i = 0; i < max; i++) {
+    const ai = a[i] ?? "";
+    const bi = b[i] ?? "";
+    if (ai === bi) {
+      lines.push(color.dim(`   ${ai}`));
+    } else {
+      if (i < a.length) lines.push(color.red(`- ${ai}`));
+      if (i < b.length) lines.push(color.green(`+ ${bi}`));
+    }
+  }
+  return lines.join("\n");
+}
+
+// src/commands/sync.ts
+var syncCommand = defineCommand4({
+  meta: {
+    name: "sync",
+    description: "Pull updates from managed Core into local files (with backups and conflict prompts)"
+  },
+  args: {
+    cwd: { type: "string", description: "Directory to sync (default: cwd)" },
+    "dry-run": { type: "boolean", description: "Show plan, do not write" },
+    apply: { type: "boolean", description: "Apply changes (skip interactive prompt)" },
+    yes: { type: "boolean", description: "Auto-confirm. Implies --apply. Fails with exit 1 if conflicts exist." },
+    backup: {
+      type: "boolean",
+      default: true,
+      description: "Backup CLAUDE.md before writing. Disable with --no-backup (not recommended)."
+    }
+  },
+  async run({ args }) {
+    const cwd = resolve9(args.cwd ?? process.cwd());
+    const configPath = `${cwd}/navori.config.json`;
+    const claudeMdPath = `${cwd}/CLAUDE.md`;
+    p4.intro(brand("sync"));
+    if (!existsSync12(cwd)) {
+      p4.cancel(`Directory not found: ${cwd}`);
+      process.exit(1);
+    }
+    if (!existsSync12(configPath)) {
+      p4.cancel(`No navori.config.json at ${configPath}. Run 'navori init' first.`);
+      process.exit(1);
+    }
+    const config = readConfig(configPath);
+    const existing = existsSync12(claudeMdPath) ? readFileSync9(claudeMdPath, "utf-8") : "";
+    const plan = computeRenderPlan(existing, config);
+    reportPlan2(plan.entries);
+    if (plan.updatesAvailable.length > 0) {
+      const lines = plan.updatesAvailable.map(
+        (u) => `  ${color.cyan(sym.update)} ${u.id}  ${dim(`(${u.source}  ${u.fromVersion} \u2192 ${u.toVersion})`)}`
+      );
+      p4.log.info(`Updates available (${plan.updatesAvailable.length}):
+${lines.join("\n")}`);
+    }
+    const conflicts = plan.entries.filter((e) => e.status === "user-modified-skipped");
+    const hasOtherChanges = plan.changed;
+    if (!hasOtherChanges && conflicts.length === 0) {
+      p4.outro("Up to date \u2014 no changes");
+      return;
+    }
+    if (args["dry-run"]) {
+      if (conflicts.length > 0) renderConflictDiffs(existing, conflicts);
+      const summary = [
+        conflicts.length > 0 ? `${conflicts.length} conflict(s)` : null,
+        hasOtherChanges ? "other changes pending" : null
+      ].filter(Boolean).join(", ");
+      p4.outro(`Dry-run complete${summary ? ` \u2014 ${summary}` : ""}`);
+      return;
+    }
+    const autoApply = Boolean(args.yes || args.apply);
+    if (args.yes && conflicts.length > 0) {
+      p4.cancel(`${conflicts.length} conflict(s) detected with --yes. Resolve interactively or use --apply alone.`);
+      process.exit(1);
+    }
+    let applyConflicts = false;
+    if (!autoApply) {
+      if (conflicts.length > 0) {
+        renderConflictDiffs(existing, conflicts);
+        const choice = await p4.select({
+          message: `Found ${conflicts.length} conflict(s). What do you want to do?`,
+          options: [
+            { value: "skip-conflicts", label: "Apply non-conflict changes, keep my edits in conflicts" },
+            { value: "apply-all", label: "Apply ALL changes (overwrite my edits in conflicts)" },
+            { value: "abort", label: "Abort \u2014 write nothing" }
+          ]
+        });
+        if (p4.isCancel(choice) || choice === "abort") {
+          p4.cancel("Aborted");
+          process.exit(0);
+        }
+        applyConflicts = choice === "apply-all";
+      } else {
+        const ok = await p4.confirm({
+          message: "Apply changes?",
+          initialValue: true
+        });
+        if (p4.isCancel(ok) || !ok) {
+          p4.cancel("Aborted");
+          process.exit(0);
+        }
+      }
+    }
+    const skipIds = !applyConflicts ? new Set(conflicts.map((c) => c.asset.id)) : /* @__PURE__ */ new Set();
+    const finalContent = applyPlanWithSkips(existing, config, skipIds);
+    if (finalContent === existing) {
+      p4.outro("Nothing to apply after conflict resolution");
+      return;
+    }
+    let backupPath = null;
+    const wantsBackup = args.backup !== false;
+    if (wantsBackup) {
+      const handle = createBackup(cwd, ["CLAUDE.md"]);
+      backupPath = handle.path;
+      const purged = purgeOldBackups();
+      if (purged.length > 0) {
+        p4.log.info(`Purged ${purged.length} backup(s) older than 30 days`);
+      }
+    } else {
+      p4.log.warn("Backup omitted (--no-backup). No automatic undo for this sync.");
+    }
+    writeFileAtomic(claudeMdPath, finalContent);
+    p4.log.success(`Wrote ${claudeMdPath}`);
+    if (backupPath) p4.log.message(`${dim("Backup:")} ${backupPath}`);
+    p4.outro(`${color.green("Done")} ${summarize2(plan.entries, conflicts.length, applyConflicts)}`);
+  }
+});
+function summarize2(entries, conflictCount, appliedConflicts) {
+  const counts = entries.reduce((acc, e) => {
+    acc[e.status] = (acc[e.status] ?? 0) + 1;
+    return acc;
+  }, {});
+  const parts = [];
+  if (counts.created) parts.push(color.green(`${counts.created} created`));
+  if (counts.updated) parts.push(color.yellow(`${counts.updated} updated`));
+  if (conflictCount > 0) {
+    parts.push(
+      appliedConflicts ? color.red(`${conflictCount} conflict overwritten`) : color.red(`${conflictCount} conflict kept`)
+    );
+  }
+  if (counts["removed-condition-false"]) parts.push(color.magenta(`${counts["removed-condition-false"]} removed`));
+  if (counts.unchanged) parts.push(dim(`${counts.unchanged} unchanged`));
+  return parts.length > 0 ? `${dim("\u2014")} ${parts.join(dim(", "))}` : "";
+}
+function reportPlan2(entries) {
+  const lines = [];
+  for (const e of entries) {
+    const symStr = renderStatusSymbol(e.status);
+    const label = renderStatusLabel(e.status);
+    const cond = e.asset.condition ? dim(` [cond: ${e.asset.condition}]`) : "";
+    lines.push(`  ${symStr} ${e.asset.id}  ${dim("(")}${label}${dim(")")}${cond}`);
+  }
+  p4.log.message(["Plan:", ...lines].join("\n"));
+}
+function renderConflictDiffs(existing, conflicts) {
+  for (const c of conflicts) {
+    const current = extractManagedContent(existing, c.asset.id);
+    const diff = formatLineDiff(current, c.newContent);
+    p4.log.warn(`Conflict in '${c.asset.id}':
+${diff}`);
+  }
+}
+
+// src/commands/add.ts
+import { defineCommand as defineCommand5 } from "citty";
+import * as p5 from "@clack/prompts";
+import { existsSync as existsSync14, readFileSync as readFileSync10 } from "fs";
+import { resolve as resolve10 } from "path";
+import { spawnSync as spawnSync3 } from "child_process";
+
+// src/lib/which.ts
+import { existsSync as existsSync13, statSync as statSync6 } from "fs";
+import { join as join8 } from "path";
+function hasBinary(name) {
+  const pathEnv = process.env.PATH ?? "";
+  const sep2 = process.platform === "win32" ? ";" : ":";
+  const dirs = pathEnv.split(sep2).filter(Boolean);
+  const exts = process.platform === "win32" ? (process.env.PATHEXT ?? ".COM;.EXE;.BAT;.CMD").split(";") : [""];
+  for (const dir of dirs) {
+    for (const ext of exts) {
+      const candidate = join8(dir, name + ext);
+      if (existsSync13(candidate)) {
+        try {
+          if (statSync6(candidate).isFile()) return true;
+        } catch {
+        }
+      }
+    }
+  }
+  return false;
+}
+
+// src/commands/add.ts
+function currentPlatform() {
+  if (process.platform === "darwin") return "darwin";
+  if (process.platform === "linux") return "linux";
+  return "win32";
+}
+var INSTALL_TIMEOUT_MS = 5 * 60 * 1e3;
+function runShellCommand(cmd) {
+  const result = spawnSync3(cmd, {
+    shell: true,
+    stdio: "inherit",
+    timeout: INSTALL_TIMEOUT_MS
+  });
+  if (result.error && result.error.code === "ETIMEDOUT") {
+    throw new Error(
+      `Install command timed out after ${INSTALL_TIMEOUT_MS / 1e3}s. It may be waiting for interactive input (run from a TTY) or hung. Install the tool manually and re-run navori with --skip-install.`
+    );
+  }
+  if (result.signal) {
+    throw new Error(`Command killed by signal ${result.signal}`);
+  }
+  if (result.status !== 0) {
+    throw new Error(`Command exited with status ${result.status}`);
+  }
+}
+var addCommand = defineCommand5({
+  meta: {
+    name: "add",
+    description: "Register a plugin in navori.config.json and optionally install its external tool"
+  },
+  args: {
+    plugin: {
+      type: "positional",
+      description: "Plugin id to add (e.g. engram)",
+      required: true
+    },
+    cwd: {
+      type: "string",
+      description: "Directory containing navori.config.json (default: cwd)"
+    },
+    yes: {
+      type: "boolean",
+      description: "Skip prompts, install external tool if needed"
+    },
+    "skip-install": {
+      type: "boolean",
+      description: "Do not install external tool (register plugin only)"
+    }
+  },
+  async run({ args }) {
+    const cwd = resolve10(args.cwd ?? process.cwd());
+    const configPath = `${cwd}/navori.config.json`;
+    p5.intro(brand(`add ${accent(args.plugin)}`));
+    if (!existsSync14(cwd)) {
+      p5.cancel(`Directory not found: ${cwd}`);
+      process.exit(1);
+    }
+    if (!existsSync14(configPath)) {
+      p5.cancel(`No navori.config.json at ${configPath}. Run 'navori init' first.`);
+      process.exit(1);
+    }
+    let plugin;
+    try {
+      plugin = loadPlugin(args.plugin);
+    } catch (err) {
+      if (err instanceof PluginNotFoundError) {
+        p5.cancel(`Unknown plugin '${args.plugin}'. Known: ${listKnownPluginIds().join(", ") || "(none)"}`);
+        process.exit(1);
+      }
+      if (err instanceof PluginManifestError) {
+        p5.cancel(err.message);
+        process.exit(1);
+      }
+      throw err;
+    }
+    p5.log.info(`${plugin.manifest.name} v${plugin.manifest.version}`);
+    p5.log.message(plugin.manifest.description);
+    const config = readConfig(configPath);
+    const already = config.plugins?.[plugin.manifest.id]?.enabled === true;
+    if (already) {
+      p5.log.warn(`'${plugin.manifest.id}' is already enabled in this config`);
+    } else {
+      const updatedPlugins = {
+        ...config.plugins ?? {},
+        [plugin.manifest.id]: { enabled: true }
+      };
+      const raw = JSON.parse(readFileSync10(configPath, "utf-8"));
+      writeConfig(configPath, { ...raw, plugins: updatedPlugins });
+      p5.log.success(`Added '${plugin.manifest.id}' to ${configPath}`);
+    }
+    const tool = plugin.manifest.externalTool;
+    if (!tool) {
+      p5.outro("Done \u2014 run 'navori render' to apply");
+      return;
+    }
+    const installed = tool.checkBinary ? hasBinary(tool.checkBinary) : true;
+    if (installed) {
+      p5.log.success(`External tool '${tool.name}' is already installed`);
+      p5.outro("Done \u2014 run 'navori render' to apply");
+      return;
+    }
+    if (args["skip-install"]) {
+      p5.log.warn(`External tool '${tool.name}' is not installed. Skip-install requested.`);
+      p5.outro("Done \u2014 install manually later");
+      return;
+    }
+    const platform = currentPlatform();
+    const installCmd = tool.install?.[platform];
+    if (!installCmd) {
+      p5.log.warn(`No install command for platform '${platform}'. Install '${tool.name}' manually.`);
+      p5.outro("Done");
+      return;
+    }
+    const shouldInstall = args.yes ? true : await p5.confirm({
+      message: `Install '${tool.name}'? Will run: ${installCmd}`,
+      initialValue: false
+    });
+    if (p5.isCancel(shouldInstall) || !shouldInstall) {
+      p5.log.warn(`External tool '${tool.name}' not installed. Hooks will skip silently.`);
+      p5.outro("Done");
+      return;
+    }
+    const spin = p5.spinner();
+    try {
+      spin.start(`Installing ${accent(tool.name)} \u2014 ${dim(installCmd)}`);
+      runShellCommand(installCmd);
+      if (tool.postInstall) {
+        spin.message(`Post-install \u2014 ${dim(tool.postInstall)}`);
+        runShellCommand(tool.postInstall);
+      }
+      spin.stop(`${color.green("\u2713")} Installed ${accent(tool.name)}`);
+    } catch (err) {
+      spin.stop(`${color.red("\u2717")} Install failed: ${err.message}`, 1);
+      p5.outro(dim("Plugin registered but external tool install failed. Install manually."));
+      return;
+    }
+    p5.outro(`${color.green("Done")} ${dim("\u2014 run 'navori render' to apply")}`);
+  }
+});
+
+// src/commands/workspace.ts
+import { defineCommand as defineCommand6 } from "citty";
+import * as p6 from "@clack/prompts";
+import { existsSync as existsSync15 } from "fs";
+var initSubCommand = defineCommand6({
+  meta: {
+    name: "init",
+    description: "Create a new workspace at ~/.navori/workspaces/<name>.json"
+  },
+  args: {
+    name: { type: "positional", description: "Workspace name (kebab-case)", required: true },
+    description: { type: "string", description: "Workspace description" },
+    yes: { type: "boolean", description: "Accept defaults without prompting" }
+  },
+  async run({ args }) {
+    const name = args.name;
+    if (!/^[a-z0-9][a-z0-9-]*$/.test(name)) {
+      console.error(`Workspace name must be kebab-case: ${name}`);
+      process.exit(1);
+    }
+    const path = workspacePath(name);
+    if (existsSync15(path)) {
+      console.error(`Workspace '${name}' already exists at ${path}`);
+      process.exit(1);
+    }
+    p6.intro(brand(`workspace init ${accent(name)}`));
+    let description = args.description ?? "";
+    if (!args.yes && !description) {
+      const value = await p6.text({
+        message: "Workspace description (optional)",
+        placeholder: "e.g. Bonum coaching platform \u2014 multi-repo"
+      });
+      if (p6.isCancel(value)) {
+        p6.cancel("Cancelled");
+        process.exit(0);
+      }
+      description = value.trim();
+    }
+    const workspace = {
+      name,
+      ...description ? { description } : {},
+      ticketsDir: "tickets",
+      defaults: {},
+      repos: []
+    };
+    const written = writeWorkspace(workspace);
+    p6.log.success(`Wrote ${written}`);
+    p6.log.message(`Tickets directory: ${workspaceDirectory(name)}/tickets/`);
+    p6.outro(`Run 'navori workspace show ${name}' to inspect, or add it to a repo with 'navori init --workspace ${name}'.`);
+  }
+});
+var lsSubCommand = defineCommand6({
+  meta: {
+    name: "ls",
+    description: "List all known workspaces"
+  },
+  args: {
+    json: { type: "boolean", description: "Output as JSON" }
+  },
+  run({ args }) {
+    const names = listWorkspaces();
+    if (args.json) {
+      console.log(JSON.stringify(names, null, 2));
+      return;
+    }
+    p6.intro(brand("workspace ls"));
+    if (names.length === 0) {
+      p6.log.info("No workspaces found. Create one with 'navori workspace init <name>'.");
+      p6.outro(dim("Done"));
+      return;
+    }
+    const lines = [];
+    for (const name of names) {
+      try {
+        const ws = loadWorkspace(name);
+        if (!ws) continue;
+        const desc = ws.description ? dim(` \u2014 ${ws.description}`) : "";
+        const count = ws.repos.length;
+        const repoLabel = `${count} repo${count === 1 ? "" : "s"}`;
+        lines.push(`  ${color.cyan(sym.bullet)} ${accent(name)}${desc}  ${dim(`(${repoLabel})`)}`);
+      } catch {
+        lines.push(`  ${color.red(sym.fail)} ${name}  ${dim("(invalid manifest)")}`);
+      }
+    }
+    p6.log.message(lines.join("\n"));
+    p6.outro(dim(`${names.length} workspace${names.length === 1 ? "" : "s"}`));
+  }
+});
+var showSubCommand = defineCommand6({
+  meta: {
+    name: "show",
+    description: "Show details of a workspace"
+  },
+  args: {
+    name: { type: "positional", description: "Workspace name", required: true },
+    json: { type: "boolean", description: "Output as JSON" }
+  },
+  run({ args }) {
+    const name = args.name;
+    let workspace;
+    try {
+      workspace = loadWorkspace(name);
+    } catch (err) {
+      if (err instanceof WorkspaceError) {
+        console.error(err.message);
+        for (const issue of err.issues ?? []) {
+          console.error(`  - ${issue.path.join(".") || "(root)"}: ${issue.message}`);
+        }
+        process.exit(1);
+      }
+      throw err;
+    }
+    if (!workspace) {
+      process.stderr.write(
+        `Workspace '${name}' not found at ${workspacePath(name)}.
+Create it with: navori workspace init ${name}
+Or list known workspaces: navori workspace ls
+`
+      );
+      process.exit(1);
+    }
+    if (args.json) {
+      console.log(JSON.stringify(workspace, null, 2));
+      return;
+    }
+    p6.intro(brand(`workspace show ${accent(workspace.name)}`));
+    const rows = [];
+    if (workspace.description) rows.push(["description", workspace.description]);
+    rows.push(["path", workspacePath(name)]);
+    rows.push(["directory", workspaceDirectory(name)]);
+    rows.push(["ticketsDir", workspace.ticketsDir]);
+    rows.push(["defaults", JSON.stringify(workspace.defaults)]);
+    rows.push(["repos", String(workspace.repos.length)]);
+    p6.log.message(kv(rows));
+    if (workspace.repos.length > 0) {
+      const repoLines = workspace.repos.map((repo) => {
+        const stack = repo.stack ? dim(` [${repo.stack}]`) : "";
+        const desc = repo.description ? dim(` \u2014 ${repo.description}`) : "";
+        return `    ${color.cyan(sym.bullet)} ${accent(repo.name)}${stack}  ${dim(repo.path)}${desc}`;
+      });
+      p6.log.message(`Repos:
+${repoLines.join("\n")}`);
+    }
+    p6.outro(dim("Done"));
+  }
+});
+var renameSubCommand = defineCommand6({
+  meta: {
+    name: "rename",
+    description: "Rename a workspace (preserves tickets, repos, defaults)"
+  },
+  args: {
+    from: { type: "positional", description: "Current workspace name", required: true },
+    to: { type: "positional", description: "New workspace name (kebab-case)", required: true },
+    yes: { type: "boolean", description: "Skip confirmation" }
+  },
+  async run({ args }) {
+    const from = args.from;
+    const to = args.to;
+    if (!/^[a-z0-9][a-z0-9-]*$/.test(to)) {
+      console.error(`Workspace name must be kebab-case: ${to}`);
+      process.exit(1);
+    }
+    if (from === to) {
+      console.error("Source and destination names are the same");
+      process.exit(1);
+    }
+    const ws = loadWorkspace(from);
+    if (!ws) {
+      console.error(`Workspace '${from}' not found`);
+      process.exit(1);
+    }
+    if (loadWorkspace(to)) {
+      console.error(`Workspace '${to}' already exists. Choose a different name or delete it first.`);
+      process.exit(1);
+    }
+    p6.intro(brand(`workspace rename ${accent(from)} ${dim("\u2192")} ${accent(to)}`));
+    p6.log.message(
+      `Will rename the workspace directory and update the manifest's 'name' field. ${ws.repos.length} repo registration(s) and any tickets will be preserved.`
+    );
+    p6.log.warn(
+      `Repos that have 'workspace: ${from}' in their navori.config.json must be updated manually: cd to each repo and run 'navori configure workspace ${to}'.`
+    );
+    if (!args.yes) {
+      const ok = await p6.confirm({
+        message: `Rename workspace '${from}' to '${to}'?`,
+        initialValue: false
+      });
+      if (p6.isCancel(ok) || !ok) {
+        p6.cancel("Aborted");
+        return;
+      }
+    }
+    const { renameSync: renameSync3 } = await import("fs");
+    const oldDir = workspaceDirectory(from);
+    const newDir = workspaceDirectory(to);
+    renameSync3(oldDir, newDir);
+    const renamed = { ...ws, name: to };
+    writeWorkspace(renamed);
+    p6.outro(`Renamed. New path: ${newDir}`);
+  }
+});
+var deleteSubCommand = defineCommand6({
+  meta: {
+    name: "delete",
+    description: "Delete a workspace (move to ~/.navori/.trash for safety)"
+  },
+  args: {
+    name: { type: "positional", description: "Workspace name", required: true },
+    yes: { type: "boolean", description: "Skip confirmation" }
+  },
+  async run({ args }) {
+    const name = args.name;
+    const ws = loadWorkspace(name);
+    if (!ws) {
+      console.error(`Workspace '${name}' not found`);
+      process.exit(1);
+    }
+    const dir = workspaceDirectory(name);
+    p6.intro(brand(`workspace delete ${accent(name)}`));
+    p6.log.warn(
+      `Will move ${dir} to ~/.navori/.trash/. Includes ${ws.repos.length} repo registration(s) and any tickets in that workspace.`
+    );
+    if (!args.yes) {
+      const ok = await p6.confirm({
+        message: `Delete workspace '${name}'?`,
+        initialValue: false
+      });
+      if (p6.isCancel(ok) || !ok) {
+        p6.cancel("Aborted");
+        return;
+      }
+    }
+    const { renameSync: renameSync3, existsSync: existsSync21, mkdirSync: mkdirSync7 } = await import("fs");
+    const { join: joinPath } = await import("path");
+    const { homedir: homedir2 } = await import("os");
+    const trashRoot = joinPath(homedir2(), ".navori", ".trash");
+    mkdirSync7(trashRoot, { recursive: true });
+    const ts = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-");
+    const dest = joinPath(trashRoot, `${name}-${ts}`);
+    if (existsSync21(dir)) renameSync3(dir, dest);
+    p6.outro(`Moved to ${dest}. Restore manually if needed.`);
+  }
+});
+var addRepoSubCommand = defineCommand6({
+  meta: {
+    name: "add-repo",
+    description: "Register a repo inside a workspace"
+  },
+  args: {
+    workspace: { type: "positional", description: "Workspace name", required: true },
+    name: { type: "string", description: "Repo name (kebab-case)", required: true },
+    path: { type: "string", description: "Absolute path to the repo", required: true },
+    stack: { type: "string", description: "Stack tag (optional)" },
+    description: { type: "string", description: "Repo description (optional)" }
+  },
+  run({ args }) {
+    const ws = loadWorkspace(args.workspace);
+    if (!ws) {
+      console.error(`Workspace '${args.workspace}' not found`);
+      process.exit(1);
+    }
+    if (ws.repos.some((r) => r.name === args.name)) {
+      console.error(`Repo '${args.name}' already registered in workspace '${ws.name}'`);
+      process.exit(1);
+    }
+    ws.repos.push({
+      name: args.name,
+      path: args.path,
+      ...args.stack ? { stack: args.stack } : {},
+      ...args.description ? { description: args.description } : {}
+    });
+    const written = writeWorkspace(ws);
+    p6.intro(brand(`workspace add-repo ${accent(ws.name)}`));
+    p6.log.success(`Registered '${accent(args.name)}' (${dim(written)})`);
+    p6.outro(dim("Done"));
+  }
+});
+var workspaceCommand = defineCommand6({
+  meta: {
+    name: "workspace",
+    description: "Manage navori workspaces (cross-repo config + tickets)"
+  },
+  subCommands: {
+    init: initSubCommand,
+    ls: lsSubCommand,
+    show: showSubCommand,
+    "add-repo": addRepoSubCommand,
+    rename: renameSubCommand,
+    delete: deleteSubCommand
+  }
+});
+
+// src/commands/ticket.ts
+import { defineCommand as defineCommand7 } from "citty";
+import * as p7 from "@clack/prompts";
+import { readFileSync as readFileSync12 } from "fs";
+
+// src/lib/tickets.ts
+import { existsSync as existsSync16, readFileSync as readFileSync11, readdirSync as readdirSync6, statSync as statSync7, mkdirSync as mkdirSync4, renameSync as renameSync2, rmSync as rmSync5 } from "fs";
+import { join as join9, resolve as resolve11 } from "path";
+var TicketError = class extends Error {
+};
+function ticketsDir(workspaceName) {
+  const ws = loadWorkspace(workspaceName);
+  if (!ws) throw new TicketError(`Workspace '${workspaceName}' not found`);
+  return join9(workspaceDirectory(workspaceName), ws.ticketsDir);
+}
+function readTitle(path) {
+  try {
+    const content = readFileSync11(path, "utf-8").split("\n");
+    for (const line of content) {
+      const trimmed = line.trim();
+      if (!trimmed) continue;
+      return trimmed.replace(/^#+\s+/, "");
+    }
+    return "(empty)";
+  } catch {
+    return "(unreadable)";
+  }
+}
+function listTickets(workspaceName) {
+  const dir = ticketsDir(workspaceName);
+  if (!existsSync16(dir)) return [];
+  const out = [];
+  const collect = (folder, state) => {
+    if (!existsSync16(folder)) return;
+    for (const entry of readdirSync6(folder)) {
+      if (!entry.endsWith(".md")) continue;
+      const full = join9(folder, entry);
+      try {
+        if (!statSync7(full).isFile()) continue;
+      } catch {
+        continue;
+      }
+      out.push({
+        id: entry.replace(/\.md$/, ""),
+        path: full,
+        title: readTitle(full),
+        state
+      });
+    }
+  };
+  collect(dir, "active");
+  collect(join9(dir, "_archive"), "archive");
+  return out;
+}
+function findTicket(workspaceName, id) {
+  const all = listTickets(workspaceName);
+  return all.find((t) => t.id === id) ?? null;
+}
+function defaultTemplate(id, title) {
+  return [
+    `# ${title}`,
+    "",
+    `**ID**: ${id}`,
+    "",
+    "## Goal",
+    "<one-liner of what this ticket achieves>",
+    "",
+    "## Repos affected",
+    "- ",
+    "",
+    "## Scope",
+    "- ",
+    "",
+    "## Notes",
+    "- ",
+    "",
+    "## Links",
+    "- ",
+    ""
+  ].join("\n");
+}
+function archiveTicket(workspaceName, id) {
+  const summary = findTicket(workspaceName, id);
+  if (!summary) throw new TicketError(`Ticket '${id}' not found in workspace '${workspaceName}'`);
+  if (summary.state === "archive") return summary;
+  const dir = ticketsDir(workspaceName);
+  const archiveDir = join9(dir, "_archive");
+  mkdirSync4(archiveDir, { recursive: true });
+  const dest = join9(archiveDir, `${id}.md`);
+  renameSync2(summary.path, dest);
+  return { id, path: dest, title: summary.title, state: "archive" };
+}
+function deleteTicket(workspaceName, id) {
+  const summary = findTicket(workspaceName, id);
+  if (!summary) throw new TicketError(`Ticket '${id}' not found in workspace '${workspaceName}'`);
+  rmSync5(summary.path, { force: true });
+}
+function createTicket(workspaceName, id, title) {
+  if (!/^[A-Za-z0-9][A-Za-z0-9-_]*$/.test(id)) {
+    throw new TicketError(`Invalid ticket id '${id}'. Use letters, digits, hyphens, underscores.`);
+  }
+  const dir = ticketsDir(workspaceName);
+  if (!existsSync16(dir)) throw new TicketError(`Tickets directory does not exist: ${dir}`);
+  const path = join9(dir, `${id}.md`);
+  if (existsSync16(path)) throw new TicketError(`Ticket '${id}' already exists at ${path}`);
+  const finalTitle = title?.trim() || id;
+  writeFileAtomic(path, defaultTemplate(id, finalTitle));
+  return {
+    id,
+    path,
+    title: finalTitle,
+    state: "active"
+  };
+}
+function findReferencingRepos(repoPaths, ticketId) {
+  const result = [];
+  const idPattern = new RegExp(`\\b${ticketId}\\b`);
+  for (const repoPath of repoPaths) {
+    const abs = resolve11(repoPath);
+    const current = join9(abs, "progress", "current.md");
+    if (!existsSync16(current)) continue;
+    try {
+      const content = readFileSync11(current, "utf-8");
+      const matches = [];
+      for (const line of content.split("\n")) {
+        if (idPattern.test(line)) matches.push(line.trim());
+      }
+      if (matches.length > 0) {
+        result.push({ path: abs, matches });
+      }
+    } catch {
+    }
+  }
+  return result;
+}
+
+// src/commands/ticket.ts
+function handleTicketError(err) {
+  if (err instanceof TicketError) {
+    console.error(err.message);
+    process.exit(1);
+  }
+  throw err;
+}
+var listSubCommand = defineCommand7({
+  meta: {
+    name: "list",
+    description: "List tickets in a workspace"
+  },
+  args: {
+    workspace: { type: "positional", description: "Workspace name", required: true },
+    archive: { type: "boolean", description: "Include archived tickets" },
+    json: { type: "boolean", description: "Output as JSON" }
+  },
+  run({ args }) {
+    let tickets;
+    try {
+      tickets = listTickets(args.workspace);
+    } catch (err) {
+      handleTicketError(err);
+    }
+    const filtered = args.archive ? tickets : tickets.filter((t) => t.state === "active");
+    if (args.json) {
+      console.log(JSON.stringify(filtered, null, 2));
+      return;
+    }
+    p7.intro(brand(`ticket list ${accent(args.workspace)}`));
+    if (filtered.length === 0) {
+      p7.log.info(`No tickets. Create one with 'navori ticket new ${args.workspace} <id>'.`);
+      p7.outro(dim("Done"));
+      return;
+    }
+    const lines = filtered.map((t) => {
+      const badge = t.state === "archive" ? color.magenta(" [archive]") : "";
+      return `  ${color.cyan(sym.bullet)} ${accent(t.id)}${badge}  ${t.title}`;
+    });
+    p7.log.message(lines.join("\n"));
+    p7.outro(dim(`${filtered.length} ticket${filtered.length === 1 ? "" : "s"}`));
+  }
+});
+var showSubCommand2 = defineCommand7({
+  meta: {
+    name: "show",
+    description: "Show a ticket and which repos reference it"
+  },
+  args: {
+    workspace: { type: "positional", description: "Workspace name", required: true },
+    id: { type: "positional", description: "Ticket id", required: true },
+    json: { type: "boolean", description: "Output as JSON" }
+  },
+  run({ args }) {
+    let ticket;
+    try {
+      ticket = findTicket(args.workspace, args.id);
+    } catch (err) {
+      handleTicketError(err);
+    }
+    if (!ticket) {
+      process.stderr.write(
+        `Ticket '${args.id}' not found in workspace '${args.workspace}'.
+Create it with: navori ticket new ${args.workspace} ${args.id}
+`
+      );
+      process.exit(1);
+    }
+    const ws = loadWorkspace(args.workspace);
+    const repoPaths = (ws?.repos ?? []).map((r) => r.path);
+    const referencing = findReferencingRepos(repoPaths, args.id);
+    if (args.json) {
+      const content = readFileSync12(ticket.path, "utf-8");
+      console.log(JSON.stringify({ ticket, referencing, content }, null, 2));
+      return;
+    }
+    p7.intro(brand(`ticket show ${accent(ticket.id)}`));
+    p7.log.message(
+      kv([
+        ["title", ticket.title],
+        ["state", ticket.state],
+        ["path", ticket.path]
+      ])
+    );
+    p7.note(readFileSync12(ticket.path, "utf-8"), "Content");
+    if (referencing.length === 0) {
+      p7.log.message(dim("Referenced in: (no repo's progress/current.md mentions this ticket)"));
+    } else {
+      const refLines = referencing.flatMap((ref) => [
+        `  ${color.cyan(sym.bullet)} ${ref.path}`,
+        ...ref.matches.map((match) => `      ${dim(">")} ${dim(match)}`)
+      ]);
+      p7.log.message(`Referenced in:
+${refLines.join("\n")}`);
+    }
+    p7.outro(dim("Done"));
+  }
+});
+var newSubCommand = defineCommand7({
+  meta: {
+    name: "new",
+    description: "Create a new ticket in a workspace"
+  },
+  args: {
+    workspace: { type: "positional", description: "Workspace name", required: true },
+    id: { type: "positional", description: "Ticket id (e.g. BNM-123)", required: true },
+    title: { type: "string", description: "Ticket title (default: id)" }
+  },
+  async run({ args }) {
+    p7.intro(brand(`ticket new ${accent(args.id)}`));
+    const id = args.id;
+    if (!/^[A-Za-z0-9][A-Za-z0-9-_]*$/.test(id)) {
+      p7.cancel(`Invalid ticket id '${id}'. Use letters, digits, hyphens, underscores (must start alphanumeric).`);
+      process.exit(1);
+    }
+    let title = args.title;
+    if (!title) {
+      const value = await p7.text({
+        message: "Ticket title",
+        placeholder: id,
+        defaultValue: id
+      });
+      if (p7.isCancel(value)) {
+        p7.cancel("Cancelled");
+        process.exit(0);
+      }
+      title = value;
+    }
+    let ticket;
+    try {
+      ticket = createTicket(args.workspace, args.id, title);
+    } catch (err) {
+      if (err instanceof TicketError) {
+        p7.cancel(err.message);
+        process.exit(1);
+      }
+      throw err;
+    }
+    p7.log.success(`Wrote ${ticket.path}`);
+    p7.outro(`Reference it from a repo's progress/current.md with:
+  ticket: ${args.id}`);
+  }
+});
+var archiveSubCommand = defineCommand7({
+  meta: {
+    name: "archive",
+    description: "Move a ticket to the _archive folder (reversible)"
+  },
+  args: {
+    workspace: { type: "positional", description: "Workspace name", required: true },
+    id: { type: "positional", description: "Ticket id", required: true }
+  },
+  run({ args }) {
+    try {
+      const result = archiveTicket(args.workspace, args.id);
+      p7.intro(brand(`ticket archive ${accent(args.id)}`));
+      p7.log.success(`Archived \u2192 ${dim(result.path)}`);
+      p7.outro(dim("Done"));
+    } catch (err) {
+      if (err instanceof TicketError) {
+        console.error(err.message);
+        process.exit(1);
+      }
+      throw err;
+    }
+  }
+});
+var deleteSubCommand2 = defineCommand7({
+  meta: {
+    name: "delete",
+    description: "Delete a ticket permanently"
+  },
+  args: {
+    workspace: { type: "positional", description: "Workspace name", required: true },
+    id: { type: "positional", description: "Ticket id", required: true },
+    yes: { type: "boolean", description: "Skip confirmation" }
+  },
+  async run({ args }) {
+    p7.intro(brand(`ticket delete ${accent(args.id)}`));
+    if (!args.yes) {
+      const ok = await p7.confirm({
+        message: `Permanently delete ticket '${args.id}' from workspace '${args.workspace}'?`,
+        initialValue: false
+      });
+      if (p7.isCancel(ok) || !ok) {
+        p7.cancel("Aborted");
+        return;
+      }
+    }
+    try {
+      deleteTicket(args.workspace, args.id);
+      p7.outro("Deleted");
+    } catch (err) {
+      if (err instanceof TicketError) {
+        p7.cancel(err.message);
+        process.exit(1);
+      }
+      throw err;
+    }
+  }
+});
+var ticketCommand = defineCommand7({
+  meta: {
+    name: "ticket",
+    description: "Manage tickets-as-files inside a workspace"
+  },
+  subCommands: {
+    list: listSubCommand,
+    show: showSubCommand2,
+    new: newSubCommand,
+    archive: archiveSubCommand,
+    delete: deleteSubCommand2
+  }
+});
+
+// src/commands/configure.ts
+import { defineCommand as defineCommand8 } from "citty";
+import * as p8 from "@clack/prompts";
+import { existsSync as existsSync17, readFileSync as readFileSync13 } from "fs";
+import { resolve as resolve12 } from "path";
+var ENGINE_OPTIONS2 = [
+  { value: "claude", label: "Claude Code (.claude/)" },
+  { value: "agents-md", label: "AGENTS.md (universal \u2014 Cursor / Codex / Gemini read it)" },
+  { value: "cursor", label: "Cursor (.cursor/rules/)" },
+  { value: "copilot", label: "Copilot (.github/copilot-instructions.md)" }
+];
+function fail(msg) {
+  process.stderr.write(`navori: ${msg}
+`);
+  process.exit(1);
+}
+function loadOrExit(cwd) {
+  if (!existsSync17(cwd)) fail(`Directory not found: ${cwd}`);
+  const configPath = resolve12(cwd, "navori.config.json");
+  if (!existsSync17(configPath)) fail(`No navori.config.json at ${configPath}. Run 'navori init' first.`);
+  const config = readConfig(configPath);
+  const raw = JSON.parse(readFileSync13(configPath, "utf-8"));
+  return { config, path: configPath, raw };
+}
+function persist(path, raw) {
+  const next = { ...raw };
+  delete next.$schema;
+  writeConfig(path, next);
+}
+var pluginsSubCommand = defineCommand8({
+  meta: {
+    name: "plugins",
+    description: "Enable or disable plugins for this repo"
+  },
+  args: {
+    cwd: { type: "string", description: "Directory (default: cwd)" }
+  },
+  async run({ args }) {
+    const cwd = resolve12(args.cwd ?? process.cwd());
+    const { config, path, raw } = loadOrExit(cwd);
+    p8.intro(brand("configure plugins"));
+    const allIds = listKnownPluginIds();
+    const current = config.plugins ?? {};
+    const enabledNow = new Set(
+      Object.entries(current).filter(([, v]) => v.enabled).map(([k]) => k)
+    );
+    const options = allIds.map((id) => {
+      let plugin;
+      try {
+        plugin = loadPlugin(id);
+      } catch {
+        return null;
+      }
+      return {
+        value: id,
+        label: `${plugin.manifest.name} (${id})`,
+        hint: plugin.manifest.description
+      };
+    }).filter((o) => o !== null);
+    const selected = await p8.multiselect({
+      message: "Plugins enabled in this repo",
+      options,
+      required: false,
+      initialValues: [...enabledNow]
+    });
+    if (p8.isCancel(selected)) {
+      p8.cancel("Cancelled");
+      return;
+    }
+    const selectedSet = new Set(selected);
+    const newPlugins = {};
+    for (const id of selectedSet) newPlugins[id] = { enabled: true };
+    raw.plugins = newPlugins;
+    persist(path, raw);
+    const added = [...selectedSet].filter((id) => !enabledNow.has(id));
+    const removed = [...enabledNow].filter((id) => !selectedSet.has(id));
+    if (added.length > 0) p8.log.success(`Enabled: ${added.join(", ")}`);
+    if (removed.length > 0) p8.log.warn(`Disabled: ${removed.join(", ")}`);
+    if (added.length === 0 && removed.length === 0) p8.log.info("No changes");
+    p8.outro("Run 'navori render' or 'navori sync' to apply.");
+  }
+});
+var qualityGateSubCommand = defineCommand8({
+  meta: {
+    name: "quality-gate",
+    description: "Set or update the quality gate commands (fast + full)"
+  },
+  args: {
+    cwd: { type: "string", description: "Directory (default: cwd)" },
+    fast: { type: "string", description: "Non-interactive: fast gate command" },
+    full: { type: "string", description: "Non-interactive: full gate command" }
+  },
+  async run({ args }) {
+    const cwd = resolve12(args.cwd ?? process.cwd());
+    const { config, path, raw } = loadOrExit(cwd);
+    p8.intro(brand("configure quality-gate"));
+    let fast = args.fast;
+    let full = args.full;
+    if (!fast || !full) {
+      const fastVal = await p8.text({
+        message: "Fast gate command (runs on Stop hook)",
+        placeholder: config.qualityGate?.fast ?? "pnpm tsc --noEmit",
+        defaultValue: config.qualityGate?.fast ?? ""
+      });
+      if (p8.isCancel(fastVal)) {
+        p8.cancel("Cancelled");
+        return;
+      }
+      fast = fastVal.trim();
+      const fullVal = await p8.text({
+        message: "Full gate command (runs before close session)",
+        placeholder: config.qualityGate?.full ?? fast,
+        defaultValue: config.qualityGate?.full ?? fast
+      });
+      if (p8.isCancel(fullVal)) {
+        p8.cancel("Cancelled");
+        return;
+      }
+      full = fullVal.trim();
+    }
+    if (!fast || !full) {
+      p8.cancel("Both fast and full commands are required");
+      return;
+    }
+    raw.qualityGate = { fast, full };
+    persist(path, raw);
+    p8.log.success(`qualityGate updated`);
+    p8.outro("Done");
+  }
+});
+var languageSubCommand = defineCommand8({
+  meta: {
+    name: "language",
+    description: "Switch the language of managed Core assets (es / en)"
+  },
+  args: {
+    cwd: { type: "string", description: "Directory (default: cwd)" },
+    value: { type: "positional", description: "es | en", required: false }
+  },
+  async run({ args }) {
+    const cwd = resolve12(args.cwd ?? process.cwd());
+    const { config, path, raw } = loadOrExit(cwd);
+    p8.intro(brand("configure language"));
+    let value = args.value;
+    if (!value) {
+      const choice = await p8.select({
+        message: "Language for managed Core assets",
+        options: [
+          { value: "es", label: "Espa\xF1ol (default \u2014 full coverage)" },
+          { value: "en", label: "English (limited \u2014 falls back to es)" }
+        ],
+        initialValue: config.language
+      });
+      if (p8.isCancel(choice)) {
+        p8.cancel("Cancelled");
+        return;
+      }
+      value = choice;
+    }
+    if (value !== "es" && value !== "en") {
+      p8.cancel(`Invalid language '${value}'. Must be 'es' or 'en'.`);
+      return;
+    }
+    raw.language = value;
+    persist(path, raw);
+    p8.log.success(`language \u2192 ${value}`);
+    p8.outro("Run 'navori render' to re-render managed blocks in the new language.");
+  }
+});
+var enginesSubCommand = defineCommand8({
+  meta: {
+    name: "engines",
+    description: "Add or remove target engines (claude / agents-md / cursor / copilot)"
+  },
+  args: {
+    cwd: { type: "string", description: "Directory (default: cwd)" }
+  },
+  async run({ args }) {
+    const cwd = resolve12(args.cwd ?? process.cwd());
+    const { config, path, raw } = loadOrExit(cwd);
+    p8.intro(brand("configure engines"));
+    const selected = await p8.multiselect({
+      message: "Engines to target",
+      options: ENGINE_OPTIONS2,
+      required: true,
+      initialValues: config.engines
+    });
+    if (p8.isCancel(selected)) {
+      p8.cancel("Cancelled");
+      return;
+    }
+    raw.engines = selected;
+    persist(path, raw);
+    p8.log.success(`engines \u2192 ${selected.join(", ")}`);
+    p8.outro("Done");
+  }
+});
+var workspaceSubCommand = defineCommand8({
+  meta: {
+    name: "workspace",
+    description: "Associate this repo with a workspace (or remove the association)"
+  },
+  args: {
+    cwd: { type: "string", description: "Directory (default: cwd)" },
+    value: { type: "positional", description: "Workspace name (empty to remove)", required: false },
+    yes: { type: "boolean", description: "Skip confirmation when removing" }
+  },
+  async run({ args }) {
+    const cwd = resolve12(args.cwd ?? process.cwd());
+    const { path, raw } = loadOrExit(cwd);
+    const value = args.value?.trim();
+    p8.intro(brand("configure workspace"));
+    if (!value) {
+      const currentWorkspace = raw.workspace;
+      if (!currentWorkspace) {
+        p8.outro("No workspace associated. Nothing to remove.");
+        return;
+      }
+      if (!args.yes) {
+        const ok = await p8.confirm({
+          message: `Remove workspace association '${currentWorkspace}'? Plugins inherited from the workspace defaults will no longer be applied on next render.`,
+          initialValue: false
+        });
+        if (p8.isCancel(ok) || !ok) {
+          p8.cancel("Aborted");
+          return;
+        }
+      }
+      delete raw.workspace;
+      persist(path, raw);
+      p8.log.success("Workspace association removed");
+      p8.outro("Run 'navori render' to apply.");
+      return;
+    }
+    raw.workspace = value;
+    persist(path, raw);
+    p8.log.success(`workspace \u2192 ${value}`);
+    p8.outro("Run 'navori render' to apply.");
+  }
+});
+var configureCommand = defineCommand8({
+  meta: {
+    name: "configure",
+    description: "Modify navori.config.json sections after init"
+  },
+  subCommands: {
+    plugins: pluginsSubCommand,
+    "quality-gate": qualityGateSubCommand,
+    language: languageSubCommand,
+    engines: enginesSubCommand,
+    workspace: workspaceSubCommand
+  }
+});
+
+// src/commands/update.ts
+import { defineCommand as defineCommand9 } from "citty";
+import * as p9 from "@clack/prompts";
+import { existsSync as existsSync18, readFileSync as readFileSync14 } from "fs";
+import { resolve as resolve13 } from "path";
+function diffConfig(current, detected) {
+  const out = [];
+  if (current.preset !== detected.suggestedPreset && detected.suggestedPreset !== "custom") {
+    out.push({ field: "preset", before: current.preset, after: detected.suggestedPreset });
+  }
+  if (detected.qualityGate) {
+    const beforeFast = current.qualityGate?.fast ?? "(none)";
+    const beforeFull = current.qualityGate?.full ?? "(none)";
+    if (beforeFast !== detected.qualityGate.fast) {
+      out.push({ field: "qualityGate.fast", before: beforeFast, after: detected.qualityGate.fast });
+    }
+    if (beforeFull !== detected.qualityGate.full) {
+      out.push({ field: "qualityGate.full", before: beforeFull, after: detected.qualityGate.full });
+    }
+  }
+  if (detected.branchBase && current.branchBase !== detected.branchBase) {
+    out.push({ field: "branchBase", before: current.branchBase, after: detected.branchBase });
+  }
+  const currentEngines = new Set(current.engines);
+  const newlyDetected = detected.existingEngines.filter((e) => !currentEngines.has(e));
+  if (newlyDetected.length > 0) {
+    out.push({
+      field: "engines",
+      before: current.engines.join(", "),
+      after: [...current.engines, ...newlyDetected].join(", ")
+    });
+  }
+  return out;
+}
+function applyDiffs(raw, detected, diffs) {
+  for (const d of diffs) {
+    if (d.field === "preset") {
+      raw.preset = detected.suggestedPreset;
+    } else if (d.field === "qualityGate.fast" || d.field === "qualityGate.full") {
+      raw.qualityGate = detected.qualityGate ?? raw.qualityGate;
+    } else if (d.field === "branchBase") {
+      raw.branchBase = detected.branchBase;
+    } else if (d.field === "engines") {
+      const currentEngines = new Set(raw.engines ?? []);
+      for (const e of detected.existingEngines) currentEngines.add(e);
+      raw.engines = [...currentEngines];
+    }
+  }
+}
+var updateCommand = defineCommand9({
+  meta: {
+    name: "update",
+    description: "Re-detect the repo, refresh config and run sync (one shot 'bring me up to date')"
+  },
+  args: {
+    cwd: { type: "string", description: "Directory (default: cwd)" },
+    yes: { type: "boolean", description: "Apply detected diffs and sync without prompting" },
+    "dry-run": { type: "boolean", description: "Show what would change, do not write" },
+    "config-only": { type: "boolean", description: "Update config but skip the sync step" }
+  },
+  async run({ args }) {
+    const cwd = resolve13(args.cwd ?? process.cwd());
+    const configPath = `${cwd}/navori.config.json`;
+    p9.intro(brand("update"));
+    if (!existsSync18(cwd)) {
+      p9.cancel(`Directory not found: ${cwd}`);
+      process.exit(1);
+    }
+    if (!existsSync18(configPath)) {
+      p9.cancel(`No navori.config.json at ${configPath}. Run 'navori init' first.`);
+      process.exit(1);
+    }
+    const config = readConfig(configPath);
+    const detected = detectProject(cwd);
+    const diffs = diffConfig(config, detected);
+    const claudeMd = existsSync18(`${cwd}/CLAUDE.md`) ? readFileSync14(`${cwd}/CLAUDE.md`, "utf-8") : "";
+    const plan = computeRenderPlan(claudeMd, config);
+    if (diffs.length === 0 && !plan.changed && plan.updatesAvailable.length === 0) {
+      p9.outro("Up to date \u2014 nothing to update");
+      return;
+    }
+    if (diffs.length > 0) {
+      const lines = diffs.map(
+        (d) => `  ${color.yellow(sym.updated)} ${accent(d.field)}${dim(":")} ${color.red(d.before)} ${dim("\u2192")} ${color.green(d.after)}`
+      );
+      p9.log.info(`Config drift detected (${diffs.length}):
+${lines.join("\n")}`);
+    } else {
+      p9.log.info("Config is in sync with the repo");
+    }
+    if (plan.updatesAvailable.length > 0) {
+      const lines = plan.updatesAvailable.map(
+        (u) => `  ${color.cyan(sym.update)} ${u.id}  ${dim(`(${u.source}  ${u.fromVersion} \u2192 ${u.toVersion})`)}`
+      );
+      p9.log.info(`Managed block updates available (${plan.updatesAvailable.length}):
+${lines.join("\n")}`);
+    }
+    const conflicts = plan.entries.filter((e) => e.status === "user-modified-skipped");
+    if (conflicts.length > 0) {
+      p9.log.warn(`${conflicts.length} conflict(s) in managed blocks \u2014 sync will need a decision`);
+    }
+    if (args["dry-run"]) {
+      p9.outro("Dry-run complete (no files written)");
+      return;
+    }
+    if (!args.yes && diffs.length > 0) {
+      const ok = await p9.confirm({
+        message: `Apply ${diffs.length} config update${diffs.length === 1 ? "" : "s"}?`,
+        initialValue: true
+      });
+      if (p9.isCancel(ok) || !ok) {
+        p9.cancel("Aborted");
+        return;
+      }
+    }
+    if (diffs.length > 0) {
+      const raw = JSON.parse(readFileSync14(configPath, "utf-8"));
+      delete raw.$schema;
+      applyDiffs(raw, detected, diffs);
+      writeConfig(configPath, raw);
+      p9.log.success(`Updated ${configPath}`);
+    }
+    if (args["config-only"]) {
+      p9.outro("Config updated. Run 'navori sync' when ready to refresh CLAUDE.md.");
+      return;
+    }
+    if (plan.changed || plan.updatesAvailable.length > 0 || diffs.length > 0) {
+      const freshConfig = readConfig(configPath);
+      const claudeMdNow = existsSync18(`${cwd}/CLAUDE.md`) ? readFileSync14(`${cwd}/CLAUDE.md`, "utf-8") : "";
+      const freshPlan = computeRenderPlan(claudeMdNow, freshConfig);
+      const fresheConflicts = freshPlan.entries.filter((e) => e.status === "user-modified-skipped");
+      if (fresheConflicts.length > 0 && !args.yes) {
+        p9.log.warn(
+          `${fresheConflicts.length} conflict(s) detected \u2014 run 'navori sync' to resolve interactively`
+        );
+        p9.outro("Done (config updated, sync deferred due to conflicts)");
+        return;
+      }
+      if (freshPlan.changed) {
+        if (existsSync18(`${cwd}/CLAUDE.md`)) {
+          const handle = createBackup(cwd, ["CLAUDE.md"]);
+          purgeOldBackups();
+          p9.log.message(`Backup: ${handle.path}`);
+        }
+        writeFileAtomic(`${cwd}/CLAUDE.md`, freshPlan.next);
+        p9.log.success(`Re-rendered ${cwd}/CLAUDE.md`);
+      } else {
+        p9.log.info("No re-render needed");
+      }
+    }
+    p9.outro("Done");
+  }
+});
+
+// src/commands/backup.ts
+import { defineCommand as defineCommand10 } from "citty";
+import * as p10 from "@clack/prompts";
+import { existsSync as existsSync19, readdirSync as readdirSync7, statSync as statSync8, copyFileSync as copyFileSync4, mkdirSync as mkdirSync5 } from "fs";
+import { join as join10, relative as relative2, resolve as resolve14, dirname as dirname5 } from "path";
+function listBackups() {
+  const root = backupRoot();
+  if (!existsSync19(root)) return [];
+  const entries = [];
+  for (const name of readdirSync7(root)) {
+    const full = join10(root, name);
+    try {
+      const stat = statSync8(full);
+      if (!stat.isDirectory()) continue;
+      const files = collectFiles(full, full);
+      entries.push({ timestamp: name, path: full, files, mtimeMs: stat.mtimeMs });
+    } catch {
+    }
+  }
+  entries.sort((a, b) => b.mtimeMs - a.mtimeMs);
+  return entries;
+}
+function collectFiles(root, dir) {
+  const out = [];
+  for (const entry of readdirSync7(dir)) {
+    const full = join10(dir, entry);
+    try {
+      const stat = statSync8(full);
+      if (stat.isDirectory()) {
+        out.push(...collectFiles(root, full));
+      } else if (stat.isFile()) {
+        out.push(relative2(root, full));
+      }
+    } catch {
+    }
+  }
+  return out;
+}
+var listSubCommand2 = defineCommand10({
+  meta: {
+    name: "list",
+    description: "List available backups in ~/.navori/backups/"
+  },
+  args: {
+    json: { type: "boolean", description: "Output as JSON" },
+    limit: { type: "string", description: "Show only the N most recent (default: 20)" }
+  },
+  run({ args }) {
+    const backups = listBackups();
+    const limit = args.limit ? Number.parseInt(args.limit, 10) : 20;
+    const truncated = backups.slice(0, limit);
+    if (args.json) {
+      console.log(JSON.stringify({ backups: truncated, totalAvailable: backups.length }, null, 2));
+      return;
+    }
+    p10.intro(brand("backup list"));
+    if (backups.length === 0) {
+      p10.log.info("No backups found. They are created automatically before each 'sync' or 'render' that modifies files.");
+      p10.outro(dim("Done"));
+      return;
+    }
+    const lines = [];
+    lines.push(dim(`${backups.length} backup(s) total. Showing ${truncated.length}:`));
+    for (const b of truncated) {
+      const date = new Date(b.mtimeMs);
+      const ago = dim(humanAge(b.mtimeMs));
+      lines.push(`  ${color.cyan(sym.bullet)} ${accent(b.timestamp)}  ${dim(date.toISOString())}  ${ago}`);
+      for (const f of b.files) {
+        lines.push(`      ${dim(sym.bullet)} ${dim(f)}`);
+      }
+    }
+    if (backups.length > truncated.length) {
+      lines.push(dim(`  ... ${backups.length - truncated.length} more (use --limit to show)`));
+    }
+    p10.log.message(lines.join("\n"));
+    p10.outro(dim("Done"));
+  }
+});
+var restoreSubCommand = defineCommand10({
+  meta: {
+    name: "restore",
+    description: "Restore files from a backup snapshot to the current directory"
+  },
+  args: {
+    timestamp: { type: "positional", description: "Backup timestamp (from 'backup list')", required: true },
+    cwd: { type: "string", description: "Target directory (default: current)" },
+    yes: { type: "boolean", description: "Skip confirmation" }
+  },
+  async run({ args }) {
+    const ts = args.timestamp;
+    const cwd = resolve14(args.cwd ?? process.cwd());
+    const backupDir = join10(backupRoot(), ts);
+    p10.intro(brand(`backup restore ${accent(ts)}`));
+    if (!existsSync19(backupDir)) {
+      p10.cancel(`Backup not found: ${backupDir}`);
+      process.exit(1);
+    }
+    const files = collectFiles(backupDir, backupDir);
+    if (files.length === 0) {
+      p10.cancel(`Backup is empty: ${backupDir}`);
+      process.exit(1);
+    }
+    p10.log.message(`Will restore ${files.length} file(s) from ${backupDir} into ${cwd}:`);
+    for (const f of files) p10.log.message(`  \xB7 ${f}`);
+    if (!args.yes) {
+      const ok = await p10.confirm({
+        message: "Existing files will be overwritten. Proceed?",
+        initialValue: false
+      });
+      if (p10.isCancel(ok) || !ok) {
+        p10.cancel("Aborted");
+        return;
+      }
+    }
+    for (const rel of files) {
+      const src = join10(backupDir, rel);
+      const dest = join10(cwd, rel);
+      mkdirSync5(dirname5(dest), { recursive: true });
+      copyFileSync4(src, dest);
+    }
+    p10.outro(`Restored ${files.length} file(s)`);
+  }
+});
+function humanAge(mtimeMs) {
+  const diffMs = Date.now() - mtimeMs;
+  const minutes = Math.floor(diffMs / 6e4);
+  if (minutes < 1) return "(just now)";
+  if (minutes < 60) return `(${minutes} min ago)`;
+  const hours = Math.floor(minutes / 60);
+  if (hours < 24) return `(${hours} h ago)`;
+  const days = Math.floor(hours / 24);
+  return `(${days} d ago)`;
+}
+var backupCommand = defineCommand10({
+  meta: {
+    name: "backup",
+    description: "List and restore navori backups"
+  },
+  subCommands: {
+    list: listSubCommand2,
+    restore: restoreSubCommand
+  }
+});
+
+// src/commands/migrations.ts
+import { defineCommand as defineCommand11 } from "citty";
+import * as p11 from "@clack/prompts";
+import { existsSync as existsSync20, readdirSync as readdirSync8, statSync as statSync9, copyFileSync as copyFileSync5, mkdirSync as mkdirSync6 } from "fs";
+import { join as join11, relative as relative3, resolve as resolve15, dirname as dirname6 } from "path";
+function listMigrations() {
+  const root = migrationsRoot();
+  if (!existsSync20(root)) return [];
+  const entries = [];
+  for (const ts of readdirSync8(root)) {
+    const tsDir = join11(root, ts);
+    try {
+      const stat = statSync9(tsDir);
+      if (!stat.isDirectory()) continue;
+      for (const repoName of readdirSync8(tsDir)) {
+        const repoDir = join11(tsDir, repoName);
+        try {
+          const repoStat = statSync9(repoDir);
+          if (!repoStat.isDirectory()) continue;
+          const files = collectFiles2(repoDir, repoDir);
+          entries.push({ timestamp: ts, repoName, path: repoDir, files, mtimeMs: repoStat.mtimeMs });
+        } catch {
+        }
+      }
+    } catch {
+    }
+  }
+  entries.sort((a, b) => b.mtimeMs - a.mtimeMs);
+  return entries;
+}
+function collectFiles2(root, dir) {
+  const out = [];
+  for (const entry of readdirSync8(dir)) {
+    const full = join11(dir, entry);
+    try {
+      const stat = statSync9(full);
+      if (stat.isDirectory()) {
+        out.push(...collectFiles2(root, full));
+      } else if (stat.isFile()) {
+        out.push(relative3(root, full));
+      }
+    } catch {
+    }
+  }
+  return out;
+}
+var listSubCommand3 = defineCommand11({
+  meta: {
+    name: "list",
+    description: "List 'init --replace' migrations stored in ~/.navori/migrations/"
+  },
+  args: {
+    json: { type: "boolean", description: "Output as JSON" },
+    limit: { type: "string", description: "Show only the N most recent (default: 20)" }
+  },
+  run({ args }) {
+    const migrations = listMigrations();
+    const limit = args.limit ? Number.parseInt(args.limit, 10) : 20;
+    const truncated = migrations.slice(0, limit);
+    if (args.json) {
+      console.log(JSON.stringify({ migrations: truncated, totalAvailable: migrations.length }, null, 2));
+      return;
+    }
+    p11.intro(brand("migrations list"));
+    if (migrations.length === 0) {
+      p11.log.info("No migrations found. They are created when 'init --replace' is used to start fresh on a repo with existing Claude infrastructure.");
+      p11.outro(dim("Done"));
+      return;
+    }
+    const lines = [];
+    lines.push(dim(`${migrations.length} migration(s) total. Showing ${truncated.length}:`));
+    for (const m of truncated) {
+      const date = new Date(m.mtimeMs);
+      lines.push(
+        `  ${color.cyan(sym.bullet)} ${accent(m.timestamp)}  ${dim(`repo='${m.repoName}'`)}  ${dim(date.toISOString())}`
+      );
+      for (const f of m.files) {
+        lines.push(`      ${dim(sym.bullet)} ${dim(f)}`);
+      }
+    }
+    if (migrations.length > truncated.length) {
+      lines.push(dim(`  ... ${migrations.length - truncated.length} more (use --limit to show)`));
+    }
+    p11.log.message(lines.join("\n"));
+    p11.outro(dim("Done"));
+  }
+});
+var restoreSubCommand2 = defineCommand11({
+  meta: {
+    name: "restore",
+    description: "Restore an 'init --replace' migration back to the original repo"
+  },
+  args: {
+    timestamp: { type: "positional", description: "Migration timestamp", required: true },
+    repo: { type: "positional", description: "Repo name (from 'migrations list')", required: true },
+    cwd: { type: "string", description: "Target directory (default: current)" },
+    yes: { type: "boolean", description: "Skip confirmation" }
+  },
+  async run({ args }) {
+    const ts = args.timestamp;
+    const repoName = args.repo;
+    const cwd = resolve15(args.cwd ?? process.cwd());
+    const migrationDir = join11(migrationsRoot(), ts, repoName);
+    p11.intro(brand(`migrations restore ${accent(`${ts}/${repoName}`)}`));
+    if (!existsSync20(migrationDir)) {
+      p11.cancel(`Migration not found: ${migrationDir}`);
+      process.exit(1);
+    }
+    const files = collectFiles2(migrationDir, migrationDir);
+    if (files.length === 0) {
+      p11.cancel(`Migration is empty: ${migrationDir}`);
+      process.exit(1);
+    }
+    p11.log.message(`Will restore ${files.length} file(s) from ${migrationDir} into ${cwd}:`);
+    for (const f of files.slice(0, 10)) p11.log.message(`  \xB7 ${f}`);
+    if (files.length > 10) p11.log.message(`  ... ${files.length - 10} more`);
+    if (!args.yes) {
+      const ok = await p11.confirm({
+        message: "Existing files will be OVERWRITTEN by the migration's snapshot. Proceed?",
+        initialValue: false
+      });
+      if (p11.isCancel(ok) || !ok) {
+        p11.cancel("Aborted");
+        return;
+      }
+    }
+    for (const rel of files) {
+      const src = join11(migrationDir, rel);
+      const dest = join11(cwd, rel);
+      mkdirSync6(dirname6(dest), { recursive: true });
+      copyFileSync5(src, dest);
+    }
+    p11.outro(`Restored ${files.length} file(s)`);
+  }
+});
+var migrationsCommand = defineCommand11({
+  meta: {
+    name: "migrations",
+    description: "List and restore 'init --replace' migrations"
+  },
+  subCommands: {
+    list: listSubCommand3,
+    restore: restoreSubCommand2
+  }
+});
+
+// src/index.ts
+function readVersion() {
+  const here = dirname7(fileURLToPath2(import.meta.url));
+  for (const candidate of [
+    resolve16(here, "..", "package.json"),
+    resolve16(here, "package.json")
+  ]) {
+    try {
+      const pkg = JSON.parse(readFileSync15(candidate, "utf-8"));
+      if (pkg.version) return pkg.version;
+    } catch {
+    }
+  }
+  return "0.0.0";
+}
+var main = defineCommand12({
+  meta: {
+    name: "navori",
+    version: readVersion(),
+    description: "Multi-agent harness + SDD scaffolder"
+  },
+  subCommands: {
+    init: initCommand,
+    add: addCommand,
+    configure: configureCommand,
+    update: updateCommand,
+    render: renderCommand,
+    sync: syncCommand,
+    doctor: doctorCommand,
+    workspace: workspaceCommand,
+    ticket: ticketCommand,
+    backup: backupCommand,
+    migrations: migrationsCommand
+  }
+});
+runMain(main);