skissue 0.1.15 → 0.1.17

package/dist/entry.js

@@ -4,13 +4,14 @@
 // src/entry.ts
 import { Command } from "commander";
 import { createRequire } from "node:module";
-import { resolve as resolve3 } from "node:path";
+import { resolve as resolve4 } from "node:path";
 
 // src/commands/init.ts
-import * as p from "@clack/prompts";
-import chalk from "chalk";
-import { existsSync as existsSync3 } from "node:fs";
-import { mkdir as mkdir3 } from "node:fs/promises";
+import * as p2 from "@clack/prompts";
+import chalk2 from "chalk";
+import { existsSync as existsSync4 } from "node:fs";
+import { mkdir as mkdir4 } from "node:fs/promises";
+import { relative, resolve as resolve3 } from "node:path";
 
 // src/config.ts
 import { existsSync } from "node:fs";
@@ -116,17 +117,10 @@ function defaultConfigTemplate() {
   return DEFAULT_CONFIG_YAML;
 }
 
-// src/git/registry-repo.ts
-import { createHash } from "node:crypto";
-import { existsSync as existsSync2, statSync } from "node:fs";
-import { mkdir as mkdir2, access, rm } from "node:fs/promises";
-import { homedir } from "node:os";
-import { join as join2, resolve } from "node:path";
-
 // src/git/exec.ts
 import { spawn } from "node:child_process";
 function execGit(args, options = {}) {
-  return new Promise((resolve4) => {
+  return new Promise((resolve5) => {
     const env = { ...process.env, ...options.env };
     if (env.GIT_TERMINAL_PROMPT === void 0) {
       env.GIT_TERMINAL_PROMPT = "0";
@@ -151,7 +145,7 @@ function execGit(args, options = {}) {
     child.on("close", (code, signal) => {
       if (timeout !== void 0) clearTimeout(timeout);
       if (signal === "SIGTERM") {
-        resolve4({
+        resolve5({
           code: 124,
           stdout,
           stderr: `${stderr}
@@ -159,16 +153,21 @@ skissue: git timed out after ${timeoutMs}ms`.trim()
         });
         return;
       }
-      resolve4({ code: code ?? 1, stdout, stderr });
+      resolve5({ code: code ?? 1, stdout, stderr });
     });
     child.on("error", (err) => {
       if (timeout !== void 0) clearTimeout(timeout);
-      resolve4({ code: 1, stdout, stderr: String(err) });
+      resolve5({ code: 1, stdout, stderr: String(err) });
     });
   });
 }
 
 // src/git/registry-repo.ts
+import { createHash } from "node:crypto";
+import { existsSync as existsSync2, statSync } from "node:fs";
+import { mkdir as mkdir2, access, rm } from "node:fs/promises";
+import { homedir } from "node:os";
+import { join as join2, resolve } from "node:path";
 function githubTokenFromEnv() {
   const raw = process.env.GITHUB_TOKEN ?? process.env.GH_TOKEN;
   const t = typeof raw === "string" ? raw.trim() : "";
@@ -287,7 +286,7 @@ async function ensureRegistryCheckout(cwd, config) {
     }
   } else {
     const fetch = await execGit(
-      ["fetch", "origin", `refs/heads/${branch}:refs/remotes/origin/${branch}`, "--depth", "1"],
+      ["fetch", "origin", `+refs/heads/${branch}:refs/remotes/origin/${branch}`, "--depth", "1"],
       { cwd: dir, timeoutMs: 3e5 }
     );
     if (fetch.code !== 0) {
@@ -340,8 +339,214 @@ async function diffPath(repoPath, fromCommit, toCommit, pathInRepo) {
 function isPathStale(diffStdout) {
   return diffStdout.trim().length > 0;
 }
+async function isSkillPathStaleAtHead(repoPath, head, entry) {
+  const d = await diffPath(repoPath, entry.registryCommit, head, entry.skillPath);
+  return isPathStale(d);
+}
+
+// src/commands/init-registry.ts
+import * as p from "@clack/prompts";
+import chalk from "chalk";
+import { existsSync as existsSync3, statSync as statSync2 } from "node:fs";
+import { mkdir as mkdir3, writeFile as writeFile2 } from "node:fs/promises";
+import { join as join3, resolve as resolve2 } from "node:path";
+function validateSkillId(raw) {
+  const id = raw.trim();
+  if (!id) return "Skill id is required";
+  if (id.includes("/") || id.includes("\\")) return "Use a single segment (no path separators)";
+  if (id === "." || id === ".." || id.includes("..")) return "Invalid skill id";
+  return void 0;
+}
+function registryLayoutExists(root) {
+  const jsonPath = join3(root, "registry.json");
+  const regDir = join3(root, "registry");
+  if (existsSync3(jsonPath)) return true;
+  if (!existsSync3(regDir)) return false;
+  try {
+    return statSync2(regDir).isDirectory();
+  } catch {
+    return false;
+  }
+}
+function skillMarkdown(skillId) {
+  const title = skillId.split(/[-_]/).map((w) => w.charAt(0).toUpperCase() + w.slice(1)).join(" ");
+  return `---
+name: ${skillId}
+description: Sample skill scaffolded by skissue init-registry. Replace this description.
+---
+
+# ${title}
+
+A minimal starter skill for your registry.
+
+## When to use
+
+Use when the user works with this sample capability (customize this section).
+
+## Instructions
+
+1. Edit this file to describe what the agent should do.
+2. Optionally add \`hard/\` with executable checks.
+`;
+}
+async function commitScaffoldedRegistry(root, skillId) {
+  const gitDir = join3(root, ".git");
+  if (!existsSync3(gitDir)) {
+    return { committed: false };
+  }
+  const regSkillPath = `registry/${skillId}`;
+  const addJson = await execGit(["add", "registry.json"], { cwd: root });
+  if (addJson.code !== 0) {
+    throw new Error(
+      `git add registry.json failed: ${addJson.stderr || addJson.stdout || `exit ${addJson.code}`}`
+    );
+  }
+  const addSkill = await execGit(["add", regSkillPath], { cwd: root });
+  if (addSkill.code !== 0) {
+    throw new Error(
+      `git add ${regSkillPath} failed: ${addSkill.stderr || addSkill.stdout || `exit ${addSkill.code}`}`
+    );
+  }
+  const diff = await execGit(["diff", "--cached", "--quiet"], { cwd: root });
+  const hasStaged = diff.code === 1;
+  if (hasStaged) {
+    const commit = await execGit(["commit", "-m", "chore: scaffold skill registry"], { cwd: root });
+    if (commit.code !== 0) {
+      throw new Error(
+        `git commit failed. Configure git user.name and user.email in this repo or globally. ${(commit.stderr || commit.stdout || "").trim()}`
+      );
+    }
+    return { committed: true };
+  }
+  const head = await execGit(["rev-parse", "HEAD"], { cwd: root });
+  if (head.code !== 0) {
+    throw new Error(
+      "Local registry must have at least one git commit so installs can resolve HEAD. Stage and commit the scaffolded files, or run git commit."
+    );
+  }
+  return { committed: false };
+}
+async function promptMinimalRegistryScaffold(root) {
+  const exists = registryLayoutExists(root);
+  if (exists) {
+    const ok = await p.confirm({
+      message: `${chalk.yellow("registry.json and/or registry/ already exist here.")} Replace with a minimal single-skill layout?`,
+      initialValue: false
+    });
+    if (p.isCancel(ok) || !ok) {
+      return null;
+    }
+  }
+  const idRaw = await p.text({
+    message: "Sample skill id (folder name under registry/)",
+    initialValue: "sample-skill",
+    validate: (v) => validateSkillId(String(v ?? ""))
+  });
+  if (p.isCancel(idRaw)) {
+    return null;
+  }
+  const skillId = String(idRaw).trim();
+  const gitDir = join3(root, ".git");
+  const hadGit = existsSync3(gitDir);
+  let runGitInit = false;
+  if (!hadGit) {
+    const initGit = await p.confirm({
+      message: "No git repository here yet. Run `git init`? (recommended \u2014 skissue local registry mode needs a git repo)",
+      initialValue: true
+    });
+    if (p.isCancel(initGit)) {
+      return null;
+    }
+    runGitInit = Boolean(initGit);
+  }
+  return { skillId, runGitInit, hadGit };
+}
+async function scaffoldMinimalRegistry(params) {
+  const { root, skillId, runGitInit } = params;
+  const regPath = `registry/${skillId}`;
+  const manifest = { skills: { [skillId]: regPath } };
+  await mkdir3(join3(root, regPath), { recursive: true });
+  await writeFile2(join3(root, "registry.json"), `${JSON.stringify(manifest, null, 2)}
+`, "utf8");
+  await writeFile2(join3(root, regPath, "SKILL.md"), skillMarkdown(skillId), "utf8");
+  let gitInitRan = false;
+  if (runGitInit) {
+    const r = await execGit(["init"], { cwd: root });
+    if (r.code === 0) {
+      gitInitRan = true;
+    } else {
+      throw new Error(`git init failed: ${r.stderr || r.stdout || `exit ${r.code}`}`);
+    }
+  }
+  const { committed } = await commitScaffoldedRegistry(root, skillId);
+  return { root, skillId, gitInitRan, committed };
+}
+async function runInitRegistry(cwd) {
+  p.intro(chalk.bold("skissue init-registry"));
+  const where = await p.select({
+    message: "Where should the skill registry live?",
+    options: [
+      { value: "here", label: "Current directory \u2014 create registry files here" },
+      { value: "other", label: "Another directory \u2014 I will enter the path" }
+    ],
+    initialValue: "here"
+  });
+  if (p.isCancel(where)) {
+    p.cancel("Aborted.");
+    process.exit(0);
+  }
+  let root;
+  if (where === "here") {
+    root = resolve2(cwd);
+  } else {
+    const raw = await p.text({
+      message: "Path to registry root (absolute or relative to current directory)",
+      placeholder: "../my-skill-registry",
+      validate: (v) => v?.trim() ? void 0 : "Required"
+    });
+    if (p.isCancel(raw)) {
+      p.cancel("Aborted.");
+      process.exit(0);
+    }
+    root = resolve2(cwd, String(raw).trim());
+  }
+  const prompted = await promptMinimalRegistryScaffold(root);
+  if (!prompted) {
+    p.cancel("Aborted. No files were changed.");
+    process.exit(0);
+  }
+  const { skillId, runGitInit, hadGit } = prompted;
+  try {
+    const result = await scaffoldMinimalRegistry({ root, skillId, runGitInit });
+    if (!hadGit && !result.gitInitRan) {
+      p.note(
+        "This folder is not a git repository. Run `git init` before using it as a local skissue registry.",
+        chalk.yellow("Heads up")
+      );
+    }
+    p.outro(
+      chalk.green(
+        `Wrote ${chalk.cyan("registry.json")} and ${chalk.cyan(`registry/${skillId}/SKILL.md`)} under ${chalk.cyan(result.root)}`
+      )
+    );
+  } catch (e) {
+    p.cancel(e instanceof Error ? e.message : String(e));
+    process.exitCode = 1;
+  }
+}
 
 // src/commands/init.ts
+async function gitBranchShowCurrent(root) {
+  const r = await execGit(["branch", "--show-current"], { cwd: root });
+  if (r.code !== 0) return void 0;
+  const b = r.stdout.trim();
+  return b.length > 0 ? b : void 0;
+}
+function localRegistryPathForConfig(cwd, resolvedRoot) {
+  const rel = relative(cwd, resolvedRoot);
+  if (!rel || rel === "") return ".";
+  return rel;
+}
 function summarizeConfig(cfg) {
   const r = cfg.registry;
   if (r.path?.trim()) {
@@ -357,27 +562,27 @@ Branch: ${r.branch}
 skillsRoot: ${cfg.skillsRoot}`;
 }
 async function runInit(cwd) {
-  p.intro(chalk.bold("skissue init"));
+  p2.intro(chalk2.bold("skissue init"));
   const existingPath = configPath(cwd);
   let hasExistingConfig = false;
-  if (existsSync3(existingPath)) {
+  if (existsSync4(existingPath)) {
     hasExistingConfig = true;
     try {
       const existing = await loadConfig(cwd);
-      p.note(summarizeConfig(existing), "Current config");
+      p2.note(summarizeConfig(existing), "Current config");
     } catch (err) {
-      p.note(err instanceof Error ? err.message : String(err), "Existing config (could not parse)");
+      p2.note(err instanceof Error ? err.message : String(err), "Existing config (could not parse)");
     }
-    const overwrite = await p.confirm({
+    const overwrite = await p2.confirm({
       message: "Overwrite existing .skill-issue/config.yaml?",
       initialValue: false
     });
-    if (p.isCancel(overwrite) || !overwrite) {
-      p.cancel("Aborted. Existing config unchanged.");
+    if (p2.isCancel(overwrite) || !overwrite) {
+      p2.cancel("Aborted. Existing config unchanged.");
       process.exit(0);
     }
   }
-  const source = await p.select({
+  const source = await p2.select({
     message: "Where does the skill registry live?",
     options: [
       {
@@ -391,64 +596,151 @@ async function runInit(cwd) {
     ],
     initialValue: "local"
   });
-  if (p.isCancel(source)) {
-    p.cancel("Aborted.");
+  if (p2.isCancel(source)) {
+    p2.cancel("Aborted.");
     process.exit(0);
   }
   let cfg;
+  let bootstrappedSkillId;
   if (source === "local") {
-    const regPath = await p.text({
-      message: "Path to registry repo root (relative to this project or absolute). Must contain registry/ and be a git repository.",
-      placeholder: ".",
-      initialValue: ".",
-      validate: (v) => v?.trim() ? void 0 : "Required"
+    const localMode = await p2.select({
+      message: "Local registry setup",
+      options: [
+        {
+          value: "existing",
+          label: "Use an existing registry folder (registry.json + registry/)"
+        },
+        {
+          value: "bootstrap",
+          label: "Bootstrap a minimal sample registry"
+        }
+      ],
+      initialValue: "existing"
     });
-    if (p.isCancel(regPath)) {
-      p.cancel("Aborted.");
+    if (p2.isCancel(localMode)) {
+      p2.cancel("Aborted.");
       process.exit(0);
     }
-    const branch = await p.text({
-      message: "Branch label (stored in config; installs use git HEAD from that directory)",
-      initialValue: "main",
-      validate: (v) => v?.trim() ? void 0 : "Required"
-    });
-    if (p.isCancel(branch)) {
-      p.cancel("Aborted.");
-      process.exit(0);
+    if (localMode === "existing") {
+      const regPath = await p2.text({
+        message: "Path to registry repo root (relative to this project or absolute). Must contain registry/ and be a git repository.",
+        placeholder: ".",
+        initialValue: ".",
+        validate: (v) => v?.trim() ? void 0 : "Required"
+      });
+      if (p2.isCancel(regPath)) {
+        p2.cancel("Aborted.");
+        process.exit(0);
+      }
+      const resolvedExisting = resolve3(cwd, String(regPath).trim());
+      const branchDefault = await gitBranchShowCurrent(resolvedExisting) ?? "main";
+      const branch = await p2.text({
+        message: "Branch label (stored in config; installs use git HEAD from that directory)",
+        initialValue: branchDefault,
+        validate: (v) => v?.trim() ? void 0 : "Required"
+      });
+      if (p2.isCancel(branch)) {
+        p2.cancel("Aborted.");
+        process.exit(0);
+      }
+      cfg = ConfigSchema.parse({
+        registry: {
+          path: String(regPath).trim(),
+          branch: String(branch).trim()
+        },
+        skillsRoot: ".agents/skills"
+      });
+    } else {
+      const pathRaw = await p2.text({
+        message: "Path for the new registry root (relative to this project or absolute)",
+        placeholder: "./skill-registry",
+        initialValue: "./skill-registry",
+        validate: (v) => v?.trim() ? void 0 : "Required"
+      });
+      if (p2.isCancel(pathRaw)) {
+        p2.cancel("Aborted.");
+        process.exit(0);
+      }
+      const resolvedRoot = resolve3(cwd, String(pathRaw).trim());
+      const atConsumerRoot = resolvedRoot === resolve3(cwd);
+      if (atConsumerRoot && !registryLayoutExists(resolvedRoot)) {
+        const okRoot = await p2.confirm({
+          message: "This adds registry.json and registry/ at your project root. Continue?",
+          initialValue: false
+        });
+        if (p2.isCancel(okRoot) || !okRoot) {
+          p2.cancel("Aborted.");
+          process.exit(0);
+        }
+      }
+      const prompted = await promptMinimalRegistryScaffold(resolvedRoot);
+      if (!prompted) {
+        p2.cancel("Aborted. No files were changed.");
+        process.exit(0);
+      }
+      let result;
+      try {
+        result = await scaffoldMinimalRegistry({
+          root: resolvedRoot,
+          skillId: prompted.skillId,
+          runGitInit: prompted.runGitInit
+        });
+      } catch (e) {
+        p2.cancel(e instanceof Error ? e.message : String(e));
+        process.exitCode = 1;
+        return;
+      }
+      bootstrappedSkillId = result.skillId;
+      if (!prompted.hadGit && !result.gitInitRan) {
+        p2.note(
+          "This folder is not a git repository. Run `git init` before using it as a local skissue registry.",
+          chalk2.yellow("Heads up")
+        );
+      }
+      const branchDefault = await gitBranchShowCurrent(resolvedRoot) ?? "main";
+      const branch = await p2.text({
+        message: "Branch label (stored in config; installs use git HEAD from that directory)",
+        initialValue: branchDefault,
+        validate: (v) => v?.trim() ? void 0 : "Required"
+      });
+      if (p2.isCancel(branch)) {
+        p2.cancel("Aborted.");
+        process.exit(0);
+      }
+      cfg = ConfigSchema.parse({
+        registry: {
+          path: localRegistryPathForConfig(cwd, resolvedRoot),
+          branch: String(branch).trim()
+        },
+        skillsRoot: ".agents/skills"
+      });
     }
-    cfg = ConfigSchema.parse({
-      registry: {
-        path: String(regPath).trim(),
-        branch: String(branch).trim()
-      },
-      skillsRoot: ".agents/skills"
-    });
   } else {
-    const owner = await p.text({
+    const owner = await p2.text({
       message: "GitHub registry owner (org or user)",
       placeholder: "acme",
       validate: (v) => v?.trim() ? void 0 : "Required"
     });
-    if (p.isCancel(owner)) {
-      p.cancel("Aborted.");
+    if (p2.isCancel(owner)) {
+      p2.cancel("Aborted.");
       process.exit(0);
     }
-    const repo = await p.text({
+    const repo = await p2.text({
       message: "Registry repository name",
       placeholder: "skill-registry",
       validate: (v) => v?.trim() ? void 0 : "Required"
     });
-    if (p.isCancel(repo)) {
-      p.cancel("Aborted.");
+    if (p2.isCancel(repo)) {
+      p2.cancel("Aborted.");
       process.exit(0);
     }
-    const branch = await p.text({
+    const branch = await p2.text({
       message: "Branch to track",
       initialValue: "main",
       validate: (v) => v?.trim() ? void 0 : "Required"
     });
-    if (p.isCancel(branch)) {
-      p.cancel("Aborted.");
+    if (p2.isCancel(branch)) {
+      p2.cancel("Aborted.");
       process.exit(0);
     }
     cfg = ConfigSchema.parse({
@@ -460,42 +752,42 @@ async function runInit(cwd) {
       skillsRoot: ".agents/skills"
     });
   }
-  const skillsRoot = await p.text({
+  const skillsRoot = await p2.text({
     message: "Install skills under (relative to project root)",
     initialValue: cfg.skillsRoot,
     validate: (v) => v?.trim() ? void 0 : "Required"
   });
-  if (p.isCancel(skillsRoot)) {
-    p.cancel("Aborted.");
+  if (p2.isCancel(skillsRoot)) {
+    p2.cancel("Aborted.");
     process.exit(0);
   }
   cfg = ConfigSchema.parse({ ...cfg, skillsRoot: String(skillsRoot).trim() });
-  const confirm4 = await p.confirm({
-    message: hasExistingConfig ? `Overwrite ${chalk.cyan(".skill-issue/config.yaml")} and use ${chalk.cyan(cfg.skillsRoot)} for installs?` : `Create ${chalk.cyan(".skill-issue/config.yaml")} and use ${chalk.cyan(cfg.skillsRoot)} for installs?`,
+  const confirm4 = await p2.confirm({
+    message: hasExistingConfig ? `Overwrite ${chalk2.cyan(".skill-issue/config.yaml")} and use ${chalk2.cyan(cfg.skillsRoot)} for installs?` : `Create ${chalk2.cyan(".skill-issue/config.yaml")} and use ${chalk2.cyan(cfg.skillsRoot)} for installs?`,
     initialValue: true
   });
-  if (p.isCancel(confirm4) || !confirm4) {
-    p.cancel("Aborted.");
+  if (p2.isCancel(confirm4) || !confirm4) {
+    p2.cancel("Aborted.");
     process.exit(0);
   }
   const dir = skillIssueDir(cwd);
-  await mkdir3(dir, { recursive: true });
+  await mkdir4(dir, { recursive: true });
   await writeConfig(cwd, cfg);
-  p.note(defaultConfigTemplate().trim(), "Template reference");
-  p.outro(
-    chalk.green(
-      "Wrote .skill-issue/config.yaml. Run skissue install <id>, or skissue for the manage menu."
-    )
-  );
+  p2.note(defaultConfigTemplate().trim(), "Template reference");
+  const outroLines = bootstrappedSkillId ? [
+    "Wrote .skill-issue/config.yaml.",
+    `Try ${chalk2.cyan(`skissue install ${bootstrappedSkillId}`)}, or run skissue for the manage menu.`
+  ] : ["Wrote .skill-issue/config.yaml. Run skissue install <id>, or skissue for the manage menu."];
+  p2.outro(chalk2.green(outroLines.join(" ")));
 }
 
 // src/commands/install.ts
-import chalk2 from "chalk";
+import chalk3 from "chalk";
 import ora from "ora";
-import { join as join5 } from "node:path";
+import { join as join6 } from "node:path";
 
 // src/lockfile.ts
-import { readFile as readFile2, writeFile as writeFile2, mkdir as mkdir4 } from "node:fs/promises";
+import { readFile as readFile2, writeFile as writeFile3, mkdir as mkdir5 } from "node:fs/promises";
 import { dirname as dirname2 } from "node:path";
 import { z as z2 } from "zod";
 var LockSkillEntrySchema = z2.object({
@@ -518,9 +810,9 @@ async function readLock(cwd) {
 }
 async function writeLock(cwd, lock) {
   const path = lockPath(cwd);
-  await mkdir4(dirname2(path), { recursive: true });
+  await mkdir5(dirname2(path), { recursive: true });
   const parsed = LockSchema.parse(lock);
-  await writeFile2(path, JSON.stringify(parsed, null, 2) + "\n", "utf8");
+  await writeFile3(path, JSON.stringify(parsed, null, 2) + "\n", "utf8");
 }
 async function readLockOrEmpty(cwd) {
   try {
@@ -543,29 +835,29 @@ function removeSkillLock(lock, skillId) {
 
 // src/registry/resolve.ts
 import { readFile as readFile3 } from "node:fs/promises";
-import { join as join3 } from "node:path";
+import { join as join4 } from "node:path";
 import { z as z3 } from "zod";
 var RegistryJsonSchema = z3.object({
   skills: z3.record(z3.string(), z3.string()).optional()
 }).passthrough();
 async function resolveSkillPath(registryRepoRoot, skillId) {
-  const registryFile = join3(registryRepoRoot, "registry.json");
+  const registryFile = join4(registryRepoRoot, "registry.json");
   let raw;
   try {
     raw = await readFile3(registryFile, "utf8");
   } catch {
-    return { skillPath: join3("registry", skillId).replace(/\\/g, "/"), source: "convention" };
+    return { skillPath: join4("registry", skillId).replace(/\\/g, "/"), source: "convention" };
   }
   const parsed = JSON.parse(raw);
   const reg = RegistryJsonSchema.safeParse(parsed);
   if (!reg.success || !reg.data.skills) {
-    return { skillPath: join3("registry", skillId).replace(/\\/g, "/"), source: "convention" };
+    return { skillPath: join4("registry", skillId).replace(/\\/g, "/"), source: "convention" };
   }
   const mapped = reg.data.skills[skillId];
   if (mapped !== void 0 && mapped.length > 0) {
     return { skillPath: normalizeRelPath(mapped), source: "registry.json" };
   }
-  return { skillPath: join3("registry", skillId).replace(/\\/g, "/"), source: "convention" };
+  return { skillPath: join4("registry", skillId).replace(/\\/g, "/"), source: "convention" };
 }
 function normalizeRelPath(p4) {
   return p4.replace(/\\/g, "/").replace(/^\.\/+/, "").replace(/\/+$/, "");
@@ -574,9 +866,9 @@ function normalizeRelPath(p4) {
 // src/io.ts
 import { access as access2, cp, rm as rm2 } from "node:fs/promises";
 import { constants } from "node:fs";
-import { join as join4 } from "node:path";
+import { join as join5 } from "node:path";
 async function assertSkillMdPresent(skillSourceDir) {
-  const p4 = join4(skillSourceDir, "SKILL.md");
+  const p4 = join5(skillSourceDir, "SKILL.md");
   try {
     await access2(p4, constants.R_OK);
   } catch {
@@ -591,7 +883,7 @@ async function copySkillTree(fromDir, toDir) {
 // src/commands/install.ts
 async function installSkillFromCheckout(cwd, config, repoPath, head, skillId) {
   const { skillPath } = await resolveSkillPath(repoPath, skillId);
-  const src = join5(repoPath, skillPath);
+  const src = join6(repoPath, skillPath);
   await assertSkillMdPresent(src);
   const dest = skillInstallPath(cwd, config.skillsRoot, skillId);
   await copySkillTree(src, dest);
@@ -611,9 +903,9 @@ async function runInstall(cwd, skillId) {
   try {
     const { path: repoPath, head } = await ensureRegistryCheckout(cwd, config);
     const dest = await installSkillFromCheckout(cwd, config, repoPath, head, skillId);
-    spin.succeed(chalk2.green(`Installed ${skillId} \u2192 ${dest}`));
+    spin.succeed(chalk3.green(`Installed ${skillId} \u2192 ${dest}`));
   } catch (err) {
-    spin.fail(chalk2.red(err instanceof Error ? err.message : String(err)));
+    spin.fail(chalk3.red(err instanceof Error ? err.message : String(err)));
     throw err;
   }
 }
@@ -629,9 +921,9 @@ async function runInstallMany(cwd, skillIds, options) {
       const c = await ensureRegistryCheckout(cwd, config);
       repoPath = c.path;
       head = c.head;
-      prep.succeed(chalk2.green("Registry ready."));
+      prep.succeed(chalk3.green("Registry ready."));
     } catch (err) {
-      prep.fail(chalk2.red(err instanceof Error ? err.message : String(err)));
+      prep.fail(chalk3.red(err instanceof Error ? err.message : String(err)));
       throw err;
     }
   }
@@ -639,16 +931,16 @@ async function runInstallMany(cwd, skillIds, options) {
     const spin = ora(`Installing ${skillId}\u2026`).start();
     try {
       const dest = await installSkillFromCheckout(cwd, config, repoPath, head, skillId);
-      spin.succeed(chalk2.green(`Installed ${skillId} \u2192 ${dest}`));
+      spin.succeed(chalk3.green(`Installed ${skillId} \u2192 ${dest}`));
     } catch (err) {
-      spin.fail(chalk2.red(err instanceof Error ? err.message : String(err)));
+      spin.fail(chalk3.red(err instanceof Error ? err.message : String(err)));
       throw err;
     }
   }
 }
 
 // src/commands/uninstall.ts
-import chalk3 from "chalk";
+import chalk4 from "chalk";
 import ora2 from "ora";
 import { rm as rm3 } from "node:fs/promises";
 async function runUninstall(cwd, skillId) {
@@ -660,27 +952,27 @@ async function runUninstall(cwd, skillId) {
     const lock = await readLockOrEmpty(cwd);
     if (!lock.skills[skillId]) {
       spin.stopAndPersist({
-        symbol: chalk3.yellow("\u26A0"),
-        text: chalk3.yellow(`No lock entry for ${skillId}; removed directory if present.`)
+        symbol: chalk4.yellow("\u26A0"),
+        text: chalk4.yellow(`No lock entry for ${skillId}; removed directory if present.`)
       });
     } else {
       await writeLock(cwd, removeSkillLock(lock, skillId));
-      spin.succeed(chalk3.green(`Uninstalled ${skillId}`));
+      spin.succeed(chalk4.green(`Uninstalled ${skillId}`));
     }
   } catch (err) {
-    spin.fail(chalk3.red(err instanceof Error ? err.message : String(err)));
+    spin.fail(chalk4.red(err instanceof Error ? err.message : String(err)));
     throw err;
   }
 }
 
 // src/commands/list.ts
-import chalk4 from "chalk";
+import chalk5 from "chalk";
 async function runList(cwd) {
   const config = await loadConfig(cwd);
   const lock = await readLockOrEmpty(cwd);
   const ids = Object.keys(lock.skills).sort();
   if (ids.length === 0) {
-    console.log(chalk4.dim("No skills installed (lock empty)."));
+    console.log(chalk5.dim("No skills installed (lock empty)."));
     return;
   }
   for (const id of ids) {
@@ -688,24 +980,24 @@ async function runList(cwd) {
     const dest = skillInstallPath(cwd, config.skillsRoot, id);
     console.log(
       [
-        chalk4.bold(id),
-        chalk4.dim("\u2192"),
+        chalk5.bold(id),
+        chalk5.dim("\u2192"),
         dest,
-        chalk4.dim(`commit=${e.registryCommit.slice(0, 7)} path=${e.skillPath}`)
+        chalk5.dim(`commit=${e.registryCommit.slice(0, 7)} path=${e.skillPath}`)
       ].join(" ")
     );
   }
 }
 
 // src/commands/outdated.ts
-import chalk5 from "chalk";
+import chalk6 from "chalk";
 import ora3 from "ora";
 async function runOutdated(cwd) {
   const config = await loadConfig(cwd);
   const lock = await readLockOrEmpty(cwd);
   const ids = Object.keys(lock.skills).sort();
   if (ids.length === 0) {
-    console.log(chalk5.dim("Nothing installed."));
+    console.log(chalk6.dim("Nothing installed."));
     return;
   }
   const spin = ora3("Fetching registry and comparing paths").start();
@@ -714,32 +1006,29 @@ async function runOutdated(cwd) {
     spin.stop();
     for (const id of ids) {
       const e = lock.skills[id];
-      const d = await diffPath(repoPath, e.registryCommit, head, e.skillPath);
-      const stale = isPathStale(d);
+      const stale = await isSkillPathStaleAtHead(repoPath, head, e);
       if (stale) {
         console.log(
-          chalk5.yellow(`${id}`) + chalk5.dim(
-            ` outdated (path changed ${e.registryCommit.slice(0, 7)} \u2192 ${head.slice(0, 7)})`
-          )
+          chalk6.bold.yellowBright("OUTDATED") + " " + chalk6.yellow(id) + chalk6.dim(` \u2014 path changed ${e.registryCommit.slice(0, 7)} \u2192 ${head.slice(0, 7)}`)
         );
       } else {
-        console.log(chalk5.green(`${id}`) + chalk5.dim(` up to date @ ${head.slice(0, 7)}`));
+        console.log(chalk6.green(`${id}`) + chalk6.dim(` up to date @ ${head.slice(0, 7)}`));
       }
     }
   } catch (err) {
-    spin.fail(chalk5.red(err instanceof Error ? err.message : String(err)));
+    spin.fail(chalk6.red(err instanceof Error ? err.message : String(err)));
     process.exitCode = 1;
   }
 }
 
 // src/commands/update.ts
-import chalk6 from "chalk";
+import chalk7 from "chalk";
 async function runUpdate(cwd, skillId) {
   await loadConfig(cwd);
   const lock = await readLockOrEmpty(cwd);
   if (skillId) {
     if (!lock.skills[skillId]) {
-      console.error(chalk6.red(`Unknown skill in lock: ${skillId}`));
+      console.error(chalk7.red(`Unknown skill in lock: ${skillId}`));
       process.exitCode = 1;
       return;
     }
@@ -752,7 +1041,7 @@ async function runUpdate(cwd, skillId) {
   }
   const ids = Object.keys(lock.skills).sort();
   if (ids.length === 0) {
-    console.log(chalk6.dim("Nothing to update (lock empty)."));
+    console.log(chalk7.dim("Nothing to update (lock empty)."));
     return;
   }
   try {
@@ -763,11 +1052,12 @@ async function runUpdate(cwd, skillId) {
 }
 
 // src/commands/manage.ts
-import * as p2 from "@clack/prompts";
-import chalk8 from "chalk";
+import * as p3 from "@clack/prompts";
+import chalk9 from "chalk";
+import readline from "node:readline";
 
 // src/commands/banner.ts
-import chalk7 from "chalk";
+import chalk8 from "chalk";
 var LOGO = [
   "  \u2597\u2584\u2584\u2596\u2597\u2596 \u2597\u2596\u2597\u2584\u2584\u2584\u2596\u2597\u2596   \u2597\u2596   ",
   "  \u2590\u258C   \u2590\u258C\u2597\u259E\u2598  \u2588  \u2590\u258C   \u2590\u258C   ",
@@ -801,7 +1091,7 @@ function gradientLine(line, row, totalRows) {
   const hi = Math.min(lo + 1, GRADIENT_STOPS.length - 1);
   const t = stopIdx - lo;
   const [r, g, b] = lerpColor(GRADIENT_STOPS[lo], GRADIENT_STOPS[hi], t);
-  return chalk7.rgb(r, g, b)(line);
+  return chalk8.rgb(r, g, b)(line);
 }
 function printSkillIssueBanner(version) {
   console.log("");
@@ -809,7 +1099,7 @@ function printSkillIssueBanner(version) {
     console.log(gradientLine(LOGO[i], i, LOGO.length));
   }
   if (version) {
-    console.log(chalk7.dim(`  v${version}`));
+    console.log(chalk8.dim(`  v${version}`));
   }
   console.log("");
 }
@@ -817,14 +1107,14 @@ function printSkillIssueBanner(version) {
 // src/registry/catalog.ts
 import { access as access3, readFile as readFile4, readdir } from "node:fs/promises";
 import { constants as constants2 } from "node:fs";
-import { join as join6 } from "node:path";
+import { join as join7 } from "node:path";
 import { z as z4 } from "zod";
 var RegistryJsonSchema2 = z4.object({
   skills: z4.record(z4.string(), z4.string()).optional()
 }).passthrough();
 async function listRegistrySkillIds(registryRepoRoot) {
   const ids = /* @__PURE__ */ new Set();
-  const registryFile = join6(registryRepoRoot, "registry.json");
+  const registryFile = join7(registryRepoRoot, "registry.json");
   try {
     const raw = await readFile4(registryFile, "utf8");
     const parsed = JSON.parse(raw);
@@ -836,16 +1126,16 @@ async function listRegistrySkillIds(registryRepoRoot) {
     }
   } catch {
   }
-  const registryDir = join6(registryRepoRoot, "registry");
+  const registryDir = join7(registryRepoRoot, "registry");
   try {
     const entries = await readdir(registryDir, { withFileTypes: true });
     for (const e of entries) {
       if (!e.isDirectory()) continue;
       const id = e.name;
       if (!id.trim()) continue;
-      const skillRoot = join6(registryDir, id);
+      const skillRoot = join7(registryDir, id);
       try {
-        await access3(join6(skillRoot, "SKILL.md"), constants2.R_OK);
+        await access3(join7(skillRoot, "SKILL.md"), constants2.R_OK);
         ids.add(id);
       } catch {
       }
@@ -856,133 +1146,274 @@ async function listRegistrySkillIds(registryRepoRoot) {
 }
 
 // src/commands/manage.ts
+var MAIN_MENU_DOUBLE_ESCAPE_MS = 1200;
+async function promptMainMenuSelect(availableCount, installedCount) {
+  const onCtrlC = (_s, key) => {
+    if (key?.ctrl && key?.name === "c") {
+      p3.cancel("Aborted.");
+      process.exit(0);
+    }
+  };
+  const { stdin } = process;
+  if (stdin.isTTY) {
+    readline.emitKeypressEvents(stdin);
+    stdin.prependListener("keypress", onCtrlC);
+  }
+  try {
+    return await p3.select({
+      message: chalk9.bold("Next step"),
+      initialValue: "install",
+      options: [
+        {
+          value: "install",
+          label: "Install",
+          hint: chalk9.dim(`${availableCount} available`)
+        },
+        {
+          value: "uninstall",
+          label: "Uninstall",
+          hint: chalk9.dim(`${installedCount} installed`)
+        },
+        {
+          value: "update",
+          label: "Update",
+          hint: chalk9.dim("refresh from registry checkout")
+        },
+        { value: "done", label: "Exit", hint: chalk9.dim("back to shell") }
+      ]
+    });
+  } finally {
+    if (stdin.isTTY) {
+      stdin.removeListener("keypress", onCtrlC);
+    }
+  }
+}
 function printRegistryStats(catalogLen, installed, canInstall) {
-  const sep = chalk8.dim(" \xB7 ");
+  const sep = chalk9.dim(" \xB7 ");
   const line = [
-    chalk8.dim("Registry"),
-    chalk8.cyan(catalogLen),
-    chalk8.dim("skills"),
+    chalk9.dim("Registry"),
+    chalk9.cyan(catalogLen),
+    chalk9.dim("skills"),
     sep,
-    chalk8.dim("installed"),
-    chalk8.cyan(installed),
+    chalk9.dim("installed"),
+    chalk9.cyan(installed),
     sep,
-    chalk8.dim("not installed"),
-    chalk8.cyan(canInstall)
+    chalk9.dim("not installed"),
+    chalk9.cyan(canInstall)
   ].join(" ");
-  p2.log.info(line);
+  p3.log.info(line);
 }
 async function runManage(cwd) {
   printSkillIssueBanner();
-  p2.intro(chalk8.dim("manage"));
+  p3.intro(chalk9.dim("manage"));
   const config = await loadConfig(cwd);
-  const spin = p2.spinner();
+  const spin = p3.spinner();
   spin.start("Preparing registry\u2026");
   let checkout;
   try {
     checkout = await ensureRegistryCheckout(cwd, config);
-    spin.stop(chalk8.green("Registry ready."));
+    spin.stop(chalk9.green("Registry ready."));
   } catch (err) {
     const msg = err instanceof Error ? err.message : String(err);
-    spin.stop(chalk8.red(msg));
+    spin.stop(chalk9.red(msg));
     throw err;
   }
   const catalog = await listRegistrySkillIds(checkout.path);
   let lock = await readLockOrEmpty(cwd);
+  let lastMainMenuEscapeAt = 0;
   while (true) {
     const installedIds = Object.keys(lock.skills).sort();
     const available = catalog.filter((id) => !lock.skills[id]);
     printRegistryStats(catalog.length, installedIds.length, available.length);
-    const action = await p2.select({
-      message: chalk8.bold("Next step"),
-      initialValue: "install",
-      options: [
-        {
-          value: "install",
-          label: "Install",
-          hint: chalk8.dim(`${available.length} available`)
-        },
-        {
-          value: "uninstall",
-          label: "Uninstall",
-          hint: chalk8.dim(`${installedIds.length} installed`)
-        },
-        { value: "done", label: "Exit", hint: chalk8.dim("back to shell") }
-      ]
-    });
-    if (p2.isCancel(action)) {
-      p2.cancel("Aborted.");
-      process.exit(0);
+    const action = await promptMainMenuSelect(available.length, installedIds.length);
+    if (p3.isCancel(action)) {
+      const now = Date.now();
+      if (now - lastMainMenuEscapeAt < MAIN_MENU_DOUBLE_ESCAPE_MS) {
+        p3.cancel("Aborted.");
+        process.exit(0);
+      }
+      lastMainMenuEscapeAt = now;
+      p3.log.message(
+        chalk9.dim(
+          `Press Esc twice within ${MAIN_MENU_DOUBLE_ESCAPE_MS / 1e3}s to exit, or choose a step.`
+        )
+      );
+      continue;
     }
+    lastMainMenuEscapeAt = 0;
     if (action === "done") {
-      p2.outro(chalk8.green("Finished."));
+      p3.outro(chalk9.green("Finished."));
       return;
     }
+    if (action === "update") {
+      if (installedIds.length === 0) {
+        p3.log.warn(chalk9.dim("Nothing installed yet."));
+        continue;
+      }
+      const checkSpin = p3.spinner();
+      checkSpin.start("Checking installed skills against registry\u2026");
+      let staleById;
+      try {
+        staleById = {};
+        for (const id of installedIds) {
+          staleById[id] = await isSkillPathStaleAtHead(
+            checkout.path,
+            checkout.head,
+            lock.skills[id]
+          );
+        }
+        checkSpin.stop(chalk9.green("Ready."));
+      } catch (err) {
+        const msg = err instanceof Error ? err.message : String(err);
+        checkSpin.stop(chalk9.red(msg));
+        p3.log.error(chalk9.red(`Could not compare skills: ${msg}`));
+        continue;
+      }
+      const staleIds = installedIds.filter((id) => staleById[id]);
+      const updateMode = await p3.select({
+        message: chalk9.bold("Update skills"),
+        initialValue: "pick",
+        options: [
+          {
+            value: "pick",
+            label: "Choose which to update",
+            hint: staleIds.length > 0 ? chalk9.bold.yellowBright(
+              `${staleIds.length} OUTDATED \u2014 differs from registry head`
+            ) : chalk9.dim("all match registry")
+          },
+          {
+            value: "all",
+            label: "Update all",
+            hint: chalk9.dim(`${installedIds.length} installed`)
+          }
+        ]
+      });
+      if (p3.isCancel(updateMode)) {
+        p3.log.message(chalk9.dim("Back to the menu."));
+        continue;
+      }
+      if (updateMode === "all") {
+        const ok2 = await p3.confirm({
+          message: `Update all ${chalk9.cyan(String(installedIds.length))} installed skills?`,
+          initialValue: true
+        });
+        if (p3.isCancel(ok2)) {
+          p3.log.message(chalk9.dim("Back to the menu."));
+          continue;
+        }
+        if (!ok2) continue;
+        try {
+          await runInstallMany(cwd, installedIds, { checkout });
+        } catch {
+          p3.log.error(chalk9.red("Update failed."));
+        }
+        lock = await readLockOrEmpty(cwd);
+        continue;
+      }
+      p3.log.message(chalk9.dim("Space toggle \xB7 Enter confirm \xB7 Esc back"));
+      const selected = await p3.multiselect({
+        message: "Skills to update",
+        options: installedIds.map((id) => ({
+          value: id,
+          label: id,
+          hint: staleById[id] ? chalk9.bold.yellowBright("OUTDATED") + chalk9.dim(" \xB7 update to sync") : chalk9.dim("up to date")
+        })),
+        initialValues: staleIds,
+        required: false
+      });
+      if (p3.isCancel(selected)) {
+        p3.log.message(chalk9.dim("Back to the menu."));
+        continue;
+      }
+      if (selected.length === 0) {
+        p3.log.warn(chalk9.dim("No selection \u2014 back to the menu."));
+        continue;
+      }
+      const ok = await p3.confirm({
+        message: `Update ${chalk9.cyan(selected.join(", "))}?`,
+        initialValue: true
+      });
+      if (p3.isCancel(ok)) {
+        p3.log.message(chalk9.dim("Back to the menu."));
+        continue;
+      }
+      if (!ok) continue;
+      try {
+        await runInstallMany(cwd, selected, { checkout });
+      } catch {
+        p3.log.error(chalk9.red("Update failed."));
+      }
+      lock = await readLockOrEmpty(cwd);
+      continue;
+    }
     if (action === "install") {
       if (available.length === 0) {
-        p2.log.warn(
-          chalk8.dim("Nothing left to install \u2014 everything in the registry is already installed.")
+        p3.log.warn(
+          chalk9.dim("Nothing left to install \u2014 everything in the registry is already installed.")
         );
         continue;
       }
-      p2.log.message(chalk8.dim("Space toggle \xB7 Enter confirm \xB7 Esc cancel"));
-      const selected2 = await p2.multiselect({
+      p3.log.message(chalk9.dim("Space toggle \xB7 Enter confirm \xB7 Esc back"));
+      const selected = await p3.multiselect({
         message: "Skills to install",
         options: available.map((id) => ({ value: id, label: id })),
         required: false
       });
-      if (p2.isCancel(selected2)) {
-        p2.cancel("Aborted.");
-        process.exit(0);
+      if (p3.isCancel(selected)) {
+        p3.log.message(chalk9.dim("Back to the menu."));
+        continue;
       }
-      if (selected2.length === 0) {
-        p2.log.warn(chalk8.dim("No selection \u2014 back to the menu."));
+      if (selected.length === 0) {
+        p3.log.warn(chalk9.dim("No selection \u2014 back to the menu."));
         continue;
       }
-      const ok2 = await p2.confirm({
-        message: `Install ${chalk8.cyan(selected2.join(", "))}?`,
+      const ok = await p3.confirm({
+        message: `Install ${chalk9.cyan(selected.join(", "))}?`,
         initialValue: true
       });
-      if (p2.isCancel(ok2)) {
-        p2.cancel("Aborted.");
-        process.exit(0);
+      if (p3.isCancel(ok)) {
+        p3.log.message(chalk9.dim("Back to the menu."));
+        continue;
       }
-      if (!ok2) continue;
-      await runInstallMany(cwd, selected2, { checkout });
+      if (!ok) continue;
+      await runInstallMany(cwd, selected, { checkout });
       lock = await readLockOrEmpty(cwd);
       continue;
     }
-    if (installedIds.length === 0) {
-      p2.log.warn(chalk8.dim("Nothing installed yet."));
-      continue;
-    }
-    p2.log.message(chalk8.dim("Space toggle \xB7 Enter confirm \xB7 Esc cancel"));
-    const selected = await p2.multiselect({
-      message: "Skills to remove",
-      options: installedIds.map((id) => ({ value: id, label: id })),
-      required: false
-    });
-    if (p2.isCancel(selected)) {
-      p2.cancel("Aborted.");
-      process.exit(0);
-    }
-    if (selected.length === 0) {
-      p2.log.warn(chalk8.dim("No selection \u2014 back to the menu."));
-      continue;
-    }
-    const ok = await p2.confirm({
-      message: `Remove ${chalk8.cyan(selected.join(", "))}?`,
-      initialValue: false
-    });
-    if (p2.isCancel(ok)) {
-      p2.cancel("Aborted.");
-      process.exit(0);
-    }
-    if (!ok) continue;
-    const toRemove = [...selected].sort((a, b) => a.localeCompare(b));
-    for (const id of toRemove) {
-      await runUninstall(cwd, id);
+    if (action === "uninstall") {
+      if (installedIds.length === 0) {
+        p3.log.warn(chalk9.dim("Nothing installed yet."));
+        continue;
+      }
+      p3.log.message(chalk9.dim("Space toggle \xB7 Enter confirm \xB7 Esc back"));
+      const selected = await p3.multiselect({
+        message: "Skills to remove",
+        options: installedIds.map((id) => ({ value: id, label: id })),
+        required: false
+      });
+      if (p3.isCancel(selected)) {
+        p3.log.message(chalk9.dim("Back to the menu."));
+        continue;
+      }
+      if (selected.length === 0) {
+        p3.log.warn(chalk9.dim("No selection \u2014 back to the menu."));
+        continue;
+      }
+      const ok = await p3.confirm({
+        message: `Remove ${chalk9.cyan(selected.join(", "))}?`,
+        initialValue: false
+      });
+      if (p3.isCancel(ok)) {
+        p3.log.message(chalk9.dim("Back to the menu."));
+        continue;
+      }
+      if (!ok) continue;
+      const toRemove = [...selected].sort((a, b) => a.localeCompare(b));
+      for (const id of toRemove) {
+        await runUninstall(cwd, id);
+      }
+      lock = await readLockOrEmpty(cwd);
     }
-    lock = await readLockOrEmpty(cwd);
   }
 }
 
@@ -997,7 +1428,7 @@ async function runDefault(cwd) {
 }
 
 // src/commands/doctor.ts
-import chalk9 from "chalk";
+import chalk10 from "chalk";
 function nodeOk() {
   const major = Number(process.versions.node.split(".")[0]);
   if (Number.isFinite(major) && major >= 24) {
@@ -1020,172 +1451,25 @@ function authHint(config) {
 }
 async function runDoctor(cwd) {
   const n = nodeOk();
-  console.log(n.ok ? chalk9.green(`\u2713 ${n.detail}`) : chalk9.red(`\u2717 ${n.detail}`));
+  console.log(n.ok ? chalk10.green(`\u2713 ${n.detail}`) : chalk10.red(`\u2717 ${n.detail}`));
   let config;
   try {
     config = await loadConfig(cwd);
-    console.log(chalk9.green("\u2713 .skill-issue/config.yaml valid"));
+    console.log(chalk10.green("\u2713 .skill-issue/config.yaml valid"));
   } catch (e) {
-    console.log(chalk9.red(`\u2717 config: ${e instanceof Error ? e.message : String(e)}`));
+    console.log(chalk10.red(`\u2717 config: ${e instanceof Error ? e.message : String(e)}`));
     process.exitCode = 1;
     return;
   }
   if (!isLocalRegistry(config)) {
-    console.log(chalk9.dim(`\u2022 ${authHint(config)}`));
+    console.log(chalk10.dim(`\u2022 ${authHint(config)}`));
   }
   try {
     const { path: repoPath, head } = await ensureRegistryCheckout(cwd, config);
     const label = isLocalRegistry(config) ? "Local registry" : "Registry cache";
-    console.log(chalk9.green(`\u2713 ${label} synced (${repoPath}) @ ${head.slice(0, 7)}`));
-  } catch (e) {
-    console.log(chalk9.red(`\u2717 Registry: ${e instanceof Error ? e.message : String(e)}`));
-    process.exitCode = 1;
-  }
-}
-
-// src/commands/init-registry.ts
-import * as p3 from "@clack/prompts";
-import chalk10 from "chalk";
-import { existsSync as existsSync4, statSync as statSync2 } from "node:fs";
-import { mkdir as mkdir5, writeFile as writeFile3 } from "node:fs/promises";
-import { join as join7, resolve as resolve2 } from "node:path";
-function validateSkillId(raw) {
-  const id = raw.trim();
-  if (!id) return "Skill id is required";
-  if (id.includes("/") || id.includes("\\")) return "Use a single segment (no path separators)";
-  if (id === "." || id === ".." || id.includes("..")) return "Invalid skill id";
-  return void 0;
-}
-function registryLayoutExists(root) {
-  const jsonPath = join7(root, "registry.json");
-  const regDir = join7(root, "registry");
-  if (existsSync4(jsonPath)) return true;
-  if (!existsSync4(regDir)) return false;
-  try {
-    return statSync2(regDir).isDirectory();
-  } catch {
-    return false;
-  }
-}
-function skillMarkdown(skillId) {
-  const title = skillId.split(/[-_]/).map((w) => w.charAt(0).toUpperCase() + w.slice(1)).join(" ");
-  return `---
-name: ${skillId}
-description: Sample skill scaffolded by skissue init-registry. Replace this description.
----
-
-# ${title}
-
-A minimal starter skill for your registry.
-
-## When to use
-
-Use when the user works with this sample capability (customize this section).
-
-## Instructions
-
-1. Edit this file to describe what the agent should do.
-2. Optionally add \`hard/\` with executable checks.
-`;
-}
-async function scaffoldMinimalRegistry(params) {
-  const { root, skillId, runGitInit } = params;
-  const regPath = `registry/${skillId}`;
-  const manifest = { skills: { [skillId]: regPath } };
-  await mkdir5(join7(root, regPath), { recursive: true });
-  await writeFile3(join7(root, "registry.json"), `${JSON.stringify(manifest, null, 2)}
-`, "utf8");
-  await writeFile3(join7(root, regPath, "SKILL.md"), skillMarkdown(skillId), "utf8");
-  let gitInitRan = false;
-  if (runGitInit) {
-    const r = await execGit(["init"], { cwd: root });
-    if (r.code === 0) {
-      gitInitRan = true;
-    } else {
-      throw new Error(`git init failed: ${r.stderr || r.stdout || `exit ${r.code}`}`);
-    }
-  }
-  return { root, skillId, gitInitRan };
-}
-async function runInitRegistry(cwd) {
-  p3.intro(chalk10.bold("skissue init-registry"));
-  const where = await p3.select({
-    message: "Where should the skill registry live?",
-    options: [
-      { value: "here", label: "Current directory \u2014 create registry files here" },
-      { value: "other", label: "Another directory \u2014 I will enter the path" }
-    ],
-    initialValue: "here"
-  });
-  if (p3.isCancel(where)) {
-    p3.cancel("Aborted.");
-    process.exit(0);
-  }
-  let root;
-  if (where === "here") {
-    root = resolve2(cwd);
-  } else {
-    const raw = await p3.text({
-      message: "Path to registry root (absolute or relative to current directory)",
-      placeholder: "../my-skill-registry",
-      validate: (v) => v?.trim() ? void 0 : "Required"
-    });
-    if (p3.isCancel(raw)) {
-      p3.cancel("Aborted.");
-      process.exit(0);
-    }
-    root = resolve2(cwd, String(raw).trim());
-  }
-  const exists = registryLayoutExists(root);
-  if (exists) {
-    const ok = await p3.confirm({
-      message: `${chalk10.yellow("registry.json and/or registry/ already exist here.")} Replace with a minimal single-skill layout?`,
-      initialValue: false
-    });
-    if (p3.isCancel(ok) || !ok) {
-      p3.cancel("Aborted. No files were changed.");
-      process.exit(0);
-    }
-  }
-  const idRaw = await p3.text({
-    message: "Sample skill id (folder name under registry/)",
-    initialValue: "sample-skill",
-    validate: (v) => validateSkillId(String(v ?? ""))
-  });
-  if (p3.isCancel(idRaw)) {
-    p3.cancel("Aborted.");
-    process.exit(0);
-  }
-  const skillId = String(idRaw).trim();
-  const gitDir = join7(root, ".git");
-  const hadGit = existsSync4(gitDir);
-  let runGitInit = false;
-  if (!hadGit) {
-    const initGit = await p3.confirm({
-      message: "No git repository here yet. Run `git init`? (recommended \u2014 skissue local registry mode needs a git repo)",
-      initialValue: true
-    });
-    if (p3.isCancel(initGit)) {
-      p3.cancel("Aborted.");
-      process.exit(0);
-    }
-    runGitInit = Boolean(initGit);
-  }
-  try {
-    const result = await scaffoldMinimalRegistry({ root, skillId, runGitInit });
-    if (!hadGit && !result.gitInitRan) {
-      p3.note(
-        "This folder is not a git repository. Run `git init` before using it as a local skissue registry.",
-        chalk10.yellow("Heads up")
-      );
-    }
-    p3.outro(
-      chalk10.green(
-        `Wrote ${chalk10.cyan("registry.json")} and ${chalk10.cyan(`registry/${skillId}/SKILL.md`)} under ${chalk10.cyan(result.root)}`
-      )
-    );
+    console.log(chalk10.green(`\u2713 ${label} synced (${repoPath}) @ ${head.slice(0, 7)}`));
   } catch (e) {
-    p3.cancel(e instanceof Error ? e.message : String(e));
+    console.log(chalk10.red(`\u2717 Registry: ${e instanceof Error ? e.message : String(e)}`));
     process.exitCode = 1;
   }
 }
@@ -1262,7 +1546,7 @@ program.command("update").description("Re-fetch and overwrite installed skill(s)
   }
 });
 program.command("doctor").description("Check Node, config, and sync registry checkout").option("-C, --cwd <path>", "Project root", process.cwd()).action(async (opts) => {
-  const cwd = resolve3(opts.cwd ?? process.cwd());
+  const cwd = resolve4(opts.cwd ?? process.cwd());
   try {
     await runDoctor(cwd);
   } catch {