@olorehq/olore 0.1.2 → 0.1.3

package/dist/cli.js

@@ -3,107 +3,25 @@
 // src/cli.ts
 import { createRequire } from "module";
 import { Command } from "commander";
-import pc7 from "picocolors";
+import pc9 from "picocolors";
 
-// src/commands/init.ts
-import fs from "fs";
-import path from "path";
-import readline from "readline";
+// src/commands/doctor.ts
 import pc from "picocolors";
-async function prompt(question, defaultValue) {
-  const rl = readline.createInterface({
-    input: process.stdin,
-    output: process.stdout
-  });
-  return new Promise((resolve) => {
-    const q = defaultValue ? `${question} (${defaultValue}): ` : `${question}: `;
-    rl.question(q, (answer) => {
-      rl.close();
-      resolve(answer || defaultValue || "");
-    });
-  });
-}
-async function init(options) {
-  const cwd = process.cwd();
-  const folderName = path.basename(cwd);
-  if (fs.existsSync(path.join(cwd, "olore.config.json"))) {
-    throw new Error("olore.config.json already exists. This folder is already initialized.");
-  }
-  let name;
-  let version2;
-  let description;
-  if (options.yes) {
-    name = options.name || folderName;
-    version2 = options.version || "1.0.0";
-    description = `Documentation for ${name}`;
-  } else {
-    console.log(pc.bold("\nInitialize olore documentation package\n"));
-    name = await prompt("Package name", options.name || folderName);
-    version2 = await prompt("Version", options.version || "1.0.0");
-    description = await prompt("Description", `Documentation for ${name}`);
-  }
-  const fullName = `olore-${name}-${version2}`;
-  const configContent = {
-    name,
-    version: version2,
-    description,
-    contentPath: "./docs",
-    outputPath: "./olore-package",
-    extensions: [".md", ".mdx"],
-    exclude: []
-  };
-  fs.writeFileSync(
-    path.join(cwd, "olore.config.json"),
-    JSON.stringify(configContent, null, 2) + "\n"
-  );
-  const docsDir = path.join(cwd, "docs");
-  if (!fs.existsSync(docsDir)) {
-    fs.mkdirSync(docsDir);
-    fs.writeFileSync(
-      path.join(docsDir, "getting-started.md"),
-      `# Getting Started with ${name}
-
-Add your documentation content here.
-
-## Overview
-
-Describe what this documentation covers.
-
-## Topics
-
-- Topic 1
-- Topic 2
-`
-    );
-  }
-  console.log(pc.bold(`
-Initialized olore package: `) + pc.cyan(fullName));
-  console.log("");
-  console.log(pc.gray("Created:"));
-  console.log(pc.green("  \u2713 olore.config.json"));
-  console.log(pc.green("  \u2713 docs/") + pc.gray(" (add your documentation here)"));
-  console.log("");
-  console.log(pc.gray("Next steps:"));
-  console.log("  1. Add your .md files to the " + pc.cyan("docs/") + " folder");
-  console.log("  2. Run " + pc.cyan("/olore-docs-packager-1.0.0") + " in Claude Code to build");
-  console.log("  3. Run " + pc.cyan("olore install ./olore-package") + " to install");
-  console.log("");
-}
 
-// src/commands/install.ts
-import path5 from "path";
-import fs5 from "fs-extra";
-import ora from "ora";
-import pc2 from "picocolors";
+// src/core/doctor.ts
+import fs4 from "fs";
+import os4 from "os";
+import path4 from "path";
+import fsExtra from "fs-extra";
 
 // src/core/download.ts
 import { createHash } from "crypto";
 import { createWriteStream } from "fs";
 import os from "os";
-import path2 from "path";
+import path from "path";
 import { Readable } from "stream";
 import { pipeline } from "stream/promises";
-import fs2 from "fs-extra";
+import fs from "fs-extra";
 import * as tar from "tar";
 
 // src/core/constants.ts
@@ -138,7 +56,7 @@ async function downloadFile(url, dest) {
     if (!response.body) {
       throw new DownloadError("No response body", "NETWORK_ERROR");
     }
-    await fs2.ensureDir(path2.dirname(dest));
+    await fs.ensureDir(path.dirname(dest));
     const nodeReadable = Readable.fromWeb(response.body);
     const writeStream = createWriteStream(dest);
     await pipeline(nodeReadable, writeStream);
@@ -159,7 +77,7 @@ async function downloadFile(url, dest) {
 }
 async function calculateChecksum(filePath) {
   const hash = createHash("sha256");
-  const stream = fs2.createReadStream(filePath);
+  const stream = fs.createReadStream(filePath);
   return new Promise((resolve, reject) => {
     stream.on("data", (data) => hash.update(data));
     stream.on("end", () => resolve(`sha256-${hash.digest("base64")}`));
@@ -171,7 +89,7 @@ async function verifyChecksum(filePath, expected) {
   return actual === expected;
 }
 async function extractTarball(tarball, dest) {
-  await fs2.ensureDir(dest);
+  await fs.ensureDir(dest);
   try {
     await tar.extract({
       file: tarball,
@@ -187,8 +105,8 @@ async function extractTarball(tarball, dest) {
   }
 }
 async function downloadAndInstall(url, dest, integrity) {
-  const tempDir = await fs2.mkdtemp(path2.join(os.tmpdir(), "olore-"));
-  const tarballPath = path2.join(tempDir, "package.tar.gz");
+  const tempDir = await fs.mkdtemp(path.join(os.tmpdir(), "olore-"));
+  const tarballPath = path.join(tempDir, "package.tar.gz");
   try {
     await downloadFile(url, tarballPath);
     const checksumValid = await verifyChecksum(tarballPath, integrity);
@@ -201,37 +119,12 @@ Actual: ${actual}`,
         "CHECKSUM_MISMATCH"
       );
     }
-    await fs2.remove(dest);
+    await fs.remove(dest);
     await extractTarball(tarballPath, dest);
     return dest;
   } finally {
-    await fs2.remove(tempDir).catch(() => {
-    });
-  }
-}
-async function downloadAndExtractToTemp(url, integrity) {
-  const tempDir = await fs2.mkdtemp(path2.join(os.tmpdir(), "olore-"));
-  const tarballPath = path2.join(tempDir, "package.tar.gz");
-  const extractDir = path2.join(tempDir, "package");
-  try {
-    await downloadFile(url, tarballPath);
-    const checksumValid = await verifyChecksum(tarballPath, integrity);
-    if (!checksumValid) {
-      const actual = await calculateChecksum(tarballPath);
-      throw new DownloadError(
-        `Checksum verification failed.
-Expected: ${integrity}
-Actual: ${actual}`,
-        "CHECKSUM_MISMATCH"
-      );
-    }
-    await extractTarball(tarballPath, extractDir);
-    await fs2.remove(tarballPath);
-    return extractDir;
-  } catch (error) {
-    await fs2.remove(tempDir).catch(() => {
+    await fs.remove(tempDir).catch(() => {
     });
-    throw error;
   }
 }
 function formatBytes(bytes) {
@@ -243,28 +136,32 @@ function formatBytes(bytes) {
 }
 
 // src/core/paths.ts
-import fs4 from "fs";
+import fs3 from "fs";
 import os3 from "os";
-import path4 from "path";
+import path3 from "path";
 import { fileURLToPath } from "url";
 
 // src/core/platform.ts
 import os2 from "os";
-import path3 from "path";
-import fs3 from "fs-extra";
+import path2 from "path";
+import fs2 from "fs-extra";
 var isWindows = process.platform === "win32";
 async function linkOrCopy(source, target) {
   if (isWindows) {
-    await fs3.copy(source, target);
+    try {
+      await fs2.symlink(source, target, "junction");
+    } catch {
+      await fs2.copy(source, target);
+    }
   } else {
-    await fs3.symlink(source, target, "dir");
+    await fs2.symlink(source, target, "dir");
   }
 }
 function expandPath(p) {
   if (p.startsWith("~")) {
-    return path3.join(os2.homedir(), p.slice(1));
+    return path2.join(os2.homedir(), p.slice(1));
   }
-  return path3.resolve(p);
+  return path2.resolve(p);
 }
 function isLocalPath(p) {
   if (p.startsWith(".") || p.startsWith("/") || p.startsWith("~")) {
@@ -285,33 +182,33 @@ function pathStartsWith(child, parent) {
   return child.startsWith(parent);
 }
 function getLinkActionText() {
-  return isWindows ? "Copying" : "Creating symlinks";
+  return "Linking";
 }
 function getLinkTypeText() {
-  return isWindows ? "copied to" : "symlinked to";
+  return "linked to";
 }
 
 // src/core/paths.ts
 var __filename2 = fileURLToPath(import.meta.url);
-var __dirname2 = path4.dirname(__filename2);
+var __dirname2 = path3.dirname(__filename2);
 function getOloreHome() {
-  return path4.join(os3.homedir(), ".olore");
+  return path3.join(os3.homedir(), ".olore");
 }
 function getOlorePackagePath(name, version2) {
-  return path4.join(getOloreHome(), "packages", name, version2);
+  return path3.join(getOloreHome(), "packages", name, version2);
 }
 function isInstalledPackage(symlinkPath) {
   try {
-    const target = fs4.readlinkSync(symlinkPath);
+    const target = fs3.readlinkSync(symlinkPath);
     const oloreHome = getOloreHome();
     return pathStartsWith(target, oloreHome);
   } catch {
-    return fs4.existsSync(symlinkPath) && fs4.statSync(symlinkPath).isDirectory();
+    return fs3.existsSync(symlinkPath) && fs3.statSync(symlinkPath).isDirectory();
   }
 }
 function getSymlinkTarget(symlinkPath) {
   try {
-    return fs4.readlinkSync(symlinkPath);
+    return fs3.readlinkSync(symlinkPath);
   } catch {
     return null;
   }
@@ -319,17 +216,17 @@ function getSymlinkTarget(symlinkPath) {
 function getAgentPaths() {
   const home = os3.homedir();
   return {
-    claude: path4.join(home, ".claude", "skills"),
-    codex: path4.join(home, ".codex", "skills"),
-    opencode: path4.join(home, ".config", "opencode", "skills")
+    claude: path3.join(home, ".claude", "skills"),
+    codex: path3.join(home, ".codex", "skills"),
+    opencode: path3.join(home, ".config", "opencode", "skills")
   };
 }
 function detectAgents() {
   const agents = [];
   const paths = getAgentPaths();
   for (const [agent, agentPath] of Object.entries(paths)) {
-    const parentDir = path4.dirname(agentPath);
-    if (fs4.existsSync(parentDir)) {
+    const parentDir = path3.dirname(agentPath);
+    if (fs3.existsSync(parentDir)) {
       agents.push(agent);
     }
   }
@@ -340,18 +237,18 @@ async function getInstalledPackages() {
   const packages = [];
   const seen = /* @__PURE__ */ new Set();
   for (const [agent, skillsDir] of Object.entries(agentPaths)) {
-    if (!fs4.existsSync(skillsDir)) {
+    if (!fs3.existsSync(skillsDir)) {
       continue;
     }
-    const entries = fs4.readdirSync(skillsDir, { withFileTypes: true });
+    const entries = fs3.readdirSync(skillsDir, { withFileTypes: true });
     for (const entry of entries) {
       const isValidEntry = entry.isDirectory() || entry.isSymbolicLink();
       if (!isValidEntry || !entry.name.startsWith("olore-")) {
         continue;
       }
-      const pkgPath = path4.join(skillsDir, entry.name);
-      const lockPath = path4.join(pkgPath, "olore-lock.json");
-      if (!fs4.existsSync(lockPath)) {
+      const pkgPath = path3.join(skillsDir, entry.name);
+      const lockPath = path3.join(pkgPath, "olore-lock.json");
+      if (!fs3.existsSync(lockPath)) {
         continue;
       }
       const pkgName = entry.name;
@@ -360,7 +257,7 @@ async function getInstalledPackages() {
       }
       seen.add(pkgName);
       try {
-        const lock = JSON.parse(fs4.readFileSync(lockPath, "utf-8"));
+        const lock = JSON.parse(fs3.readFileSync(lockPath, "utf-8"));
         const stats = await getDirectoryStats(pkgPath);
         const symlinkTarget = getSymlinkTarget(pkgPath);
         let installType;
@@ -389,14 +286,14 @@ async function getDirectoryStats(dir) {
   let files = 0;
   let size = 0;
   function walk(currentDir) {
-    const entries = fs4.readdirSync(currentDir, { withFileTypes: true });
+    const entries = fs3.readdirSync(currentDir, { withFileTypes: true });
     for (const entry of entries) {
-      const fullPath = path4.join(currentDir, entry.name);
+      const fullPath = path3.join(currentDir, entry.name);
       if (entry.isDirectory()) {
         walk(fullPath);
       } else if (entry.isFile()) {
         files++;
-        size += fs4.statSync(fullPath).size;
+        size += fs3.statSync(fullPath).size;
       }
     }
   }
@@ -404,6 +301,416 @@ async function getDirectoryStats(dir) {
   return { files, size };
 }
 
+// src/core/doctor.ts
+async function diagnose() {
+  const issues = [];
+  const [dangling, orphaned, partial] = await Promise.all([
+    scanAgentDirs(),
+    scanOrphanedPackages(),
+    scanPartialInstalls()
+  ]);
+  issues.push(...dangling, ...orphaned, ...partial);
+  return {
+    ok: issues.length === 0,
+    issues
+  };
+}
+async function scanAgentDirs() {
+  const issues = [];
+  const agentPaths = getAgentPaths();
+  for (const [agent, skillsDir] of Object.entries(agentPaths)) {
+    if (!fs4.existsSync(skillsDir)) {
+      continue;
+    }
+    let entries;
+    try {
+      entries = fs4.readdirSync(skillsDir, { withFileTypes: true });
+    } catch {
+      continue;
+    }
+    for (const entry of entries) {
+      if (!entry.name.startsWith("olore-")) {
+        continue;
+      }
+      if (!entry.isSymbolicLink()) {
+        continue;
+      }
+      const fullPath = path4.join(skillsDir, entry.name);
+      const target = readSymlinkTarget(fullPath);
+      if (target === null) {
+        continue;
+      }
+      const resolvedTarget = path4.resolve(skillsDir, target);
+      if (!fs4.existsSync(resolvedTarget)) {
+        issues.push({
+          type: "dangling-symlink",
+          path: fullPath,
+          target: resolvedTarget,
+          agent
+        });
+      }
+    }
+  }
+  return issues;
+}
+async function scanOrphanedPackages() {
+  const issues = [];
+  const packagesDir = path4.join(getOloreHome(), "packages");
+  if (!fs4.existsSync(packagesDir)) {
+    return issues;
+  }
+  const activeTargets = await collectActiveSymlinkTargets();
+  let nameEntries;
+  try {
+    nameEntries = fs4.readdirSync(packagesDir, { withFileTypes: true });
+  } catch {
+    return issues;
+  }
+  for (const nameEntry of nameEntries) {
+    if (!nameEntry.isDirectory()) {
+      continue;
+    }
+    const nameDir = path4.join(packagesDir, nameEntry.name);
+    let versionEntries;
+    try {
+      versionEntries = fs4.readdirSync(nameDir, { withFileTypes: true });
+    } catch {
+      continue;
+    }
+    for (const versionEntry of versionEntries) {
+      if (!versionEntry.isDirectory()) {
+        continue;
+      }
+      const versionDir = path4.join(nameDir, versionEntry.name);
+      const lockPath = path4.join(versionDir, "olore-lock.json");
+      if (!fs4.existsSync(lockPath)) {
+        continue;
+      }
+      const realPath = fs4.realpathSync(versionDir);
+      if (activeTargets.has(realPath)) {
+        continue;
+      }
+      const stats = getDirectoryStats2(versionDir);
+      issues.push({
+        type: "orphaned",
+        path: versionDir,
+        name: nameEntry.name,
+        version: versionEntry.name,
+        files: stats.files,
+        size: stats.size
+      });
+    }
+  }
+  return issues;
+}
+async function scanPartialInstalls() {
+  const issues = [];
+  const packagesDir = path4.join(getOloreHome(), "packages");
+  if (!fs4.existsSync(packagesDir)) {
+    return issues;
+  }
+  let nameEntries;
+  try {
+    nameEntries = fs4.readdirSync(packagesDir, { withFileTypes: true });
+  } catch {
+    return issues;
+  }
+  for (const nameEntry of nameEntries) {
+    if (!nameEntry.isDirectory()) {
+      continue;
+    }
+    const nameDir = path4.join(packagesDir, nameEntry.name);
+    let versionEntries;
+    try {
+      versionEntries = fs4.readdirSync(nameDir, { withFileTypes: true });
+    } catch {
+      continue;
+    }
+    for (const versionEntry of versionEntries) {
+      if (!versionEntry.isDirectory()) {
+        continue;
+      }
+      const versionDir = path4.join(nameDir, versionEntry.name);
+      const lockPath = path4.join(versionDir, "olore-lock.json");
+      if (!fs4.existsSync(lockPath)) {
+        issues.push({
+          type: "partial-install",
+          path: versionDir,
+          name: nameEntry.name,
+          version: versionEntry.name
+        });
+      }
+    }
+  }
+  return issues;
+}
+async function collectActiveSymlinkTargets() {
+  const targets = /* @__PURE__ */ new Set();
+  const agentPaths = getAgentPaths();
+  for (const skillsDir of Object.values(agentPaths)) {
+    if (!fs4.existsSync(skillsDir)) {
+      continue;
+    }
+    let entries;
+    try {
+      entries = fs4.readdirSync(skillsDir, { withFileTypes: true });
+    } catch {
+      continue;
+    }
+    for (const entry of entries) {
+      if (!entry.name.startsWith("olore-") || !entry.isSymbolicLink()) {
+        continue;
+      }
+      const fullPath = path4.join(skillsDir, entry.name);
+      try {
+        const realTarget = fs4.realpathSync(fullPath);
+        targets.add(realTarget);
+      } catch {
+      }
+    }
+  }
+  return targets;
+}
+async function pruneIssues(issues) {
+  const removed = [];
+  const failed = [];
+  for (const issue of issues) {
+    if (!pathExists(issue.path)) {
+      continue;
+    }
+    try {
+      let freedBytes = 0;
+      if (issue.type === "dangling-symlink") {
+        await fsExtra.remove(issue.path);
+      } else if (issue.type === "orphaned") {
+        freedBytes = issue.size;
+        await fsExtra.remove(issue.path);
+        await cleanEmptyParentDir(issue.path);
+      } else if (issue.type === "partial-install") {
+        const stats = getDirectoryStats2(issue.path);
+        freedBytes = stats.size;
+        await fsExtra.remove(issue.path);
+        await cleanEmptyParentDir(issue.path);
+      }
+      removed.push({ issue, freedBytes });
+    } catch (error) {
+      failed.push({
+        issue,
+        error: error instanceof Error ? error.message : "Unknown error"
+      });
+    }
+  }
+  return { removed, failed };
+}
+function pathExists(p) {
+  try {
+    fs4.lstatSync(p);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function readSymlinkTarget(symlinkPath) {
+  try {
+    return fs4.readlinkSync(symlinkPath);
+  } catch {
+    return null;
+  }
+}
+async function cleanEmptyParentDir(removedPath) {
+  const parentDir = path4.dirname(removedPath);
+  try {
+    const remaining = fs4.readdirSync(parentDir);
+    if (remaining.length === 0) {
+      await fsExtra.remove(parentDir);
+    }
+  } catch {
+  }
+}
+function getDirectoryStats2(dir) {
+  let files = 0;
+  let size = 0;
+  function walk(currentDir) {
+    let entries;
+    try {
+      entries = fs4.readdirSync(currentDir, { withFileTypes: true });
+    } catch {
+      return;
+    }
+    for (const entry of entries) {
+      const fullPath = path4.join(currentDir, entry.name);
+      if (entry.isDirectory()) {
+        walk(fullPath);
+      } else if (entry.isFile()) {
+        try {
+          files++;
+          size += fs4.statSync(fullPath).size;
+        } catch {
+        }
+      }
+    }
+  }
+  walk(dir);
+  return { files, size };
+}
+function displayPath(p) {
+  const home = os4.homedir();
+  if (p.startsWith(home)) {
+    return "~" + p.slice(home.length);
+  }
+  return p;
+}
+function formatIssue(issue) {
+  switch (issue.type) {
+    case "dangling-symlink":
+      return `${displayPath(issue.path)}  ->  ${displayPath(issue.target)} (missing)`;
+    case "orphaned":
+      return `${displayPath(issue.path)}  (no agent links, ${issue.files} files, ${formatBytes(issue.size)})`;
+    case "partial-install":
+      return `${displayPath(issue.path)}  (missing olore-lock.json)`;
+  }
+}
+
+// src/commands/doctor.ts
+async function doctor(options) {
+  if (!options.json) {
+    console.log(pc.bold("\nChecking installed packages...\n"));
+  }
+  const result = await diagnose();
+  if (options.json) {
+    console.log(JSON.stringify(result, null, 2));
+    if (!result.ok) {
+      process.exit(1);
+    }
+    return;
+  }
+  if (result.ok) {
+    console.log(pc.green("No issues found. Everything looks good."));
+    return;
+  }
+  const dangling = result.issues.filter((i) => i.type === "dangling-symlink");
+  const orphaned = result.issues.filter((i) => i.type === "orphaned");
+  const partial = result.issues.filter((i) => i.type === "partial-install");
+  console.log(
+    `Found ${pc.yellow(String(result.issues.length))} issue${result.issues.length === 1 ? "" : "s"}:
+`
+  );
+  if (dangling.length > 0) {
+    console.log(pc.bold(`Dangling symlinks (${dangling.length}):`));
+    for (const issue of dangling) {
+      console.log(`  ${formatIssue(issue)}`);
+    }
+    console.log("");
+  }
+  if (orphaned.length > 0) {
+    console.log(pc.bold(`Orphaned packages (${orphaned.length}):`));
+    for (const issue of orphaned) {
+      console.log(`  ${formatIssue(issue)}`);
+    }
+    console.log("");
+  }
+  if (partial.length > 0) {
+    console.log(pc.bold(`Partial installs (${partial.length}):`));
+    for (const issue of partial) {
+      console.log(`  ${formatIssue(issue)}`);
+    }
+    console.log("");
+  }
+  console.log(`Run ${pc.cyan("olore prune")} to fix these issues.`);
+  process.exit(1);
+}
+
+// src/commands/init.ts
+import fs5 from "fs";
+import path5 from "path";
+import readline from "readline";
+import pc2 from "picocolors";
+async function prompt(question, defaultValue) {
+  const rl = readline.createInterface({
+    input: process.stdin,
+    output: process.stdout
+  });
+  return new Promise((resolve) => {
+    const q = defaultValue ? `${question} (${defaultValue}): ` : `${question}: `;
+    rl.question(q, (answer) => {
+      rl.close();
+      resolve(answer || defaultValue || "");
+    });
+  });
+}
+async function init(options) {
+  const cwd = process.cwd();
+  const folderName = path5.basename(cwd);
+  if (fs5.existsSync(path5.join(cwd, "olore.config.json"))) {
+    throw new Error("olore.config.json already exists. This folder is already initialized.");
+  }
+  let name;
+  let version2;
+  let description;
+  if (options.yes) {
+    name = options.name || folderName;
+    version2 = options.version || "1.0.0";
+    description = `Documentation for ${name}`;
+  } else {
+    console.log(pc2.bold("\nInitialize olore documentation package\n"));
+    name = await prompt("Package name", options.name || folderName);
+    version2 = await prompt("Version", options.version || "1.0.0");
+    description = await prompt("Description", `Documentation for ${name}`);
+  }
+  const fullName = `olore-${name}-${version2}`;
+  const configContent = {
+    name,
+    version: version2,
+    description,
+    contentPath: "./docs",
+    outputPath: "./olore-package",
+    extensions: [".md", ".mdx"],
+    exclude: []
+  };
+  fs5.writeFileSync(
+    path5.join(cwd, "olore.config.json"),
+    JSON.stringify(configContent, null, 2) + "\n"
+  );
+  const docsDir = path5.join(cwd, "docs");
+  if (!fs5.existsSync(docsDir)) {
+    fs5.mkdirSync(docsDir);
+    fs5.writeFileSync(
+      path5.join(docsDir, "getting-started.md"),
+      `# Getting Started with ${name}
+
+Add your documentation content here.
+
+## Overview
+
+Describe what this documentation covers.
+
+## Topics
+
+- Topic 1
+- Topic 2
+`
+    );
+  }
+  console.log(pc2.bold(`
+Initialized olore package: `) + pc2.cyan(fullName));
+  console.log("");
+  console.log(pc2.gray("Created:"));
+  console.log(pc2.green("  \u2713 olore.config.json"));
+  console.log(pc2.green("  \u2713 docs/") + pc2.gray(" (add your documentation here)"));
+  console.log("");
+  console.log(pc2.gray("Next steps:"));
+  console.log("  1. Add your .md files to the " + pc2.cyan("docs/") + " folder");
+  console.log("  2. Run " + pc2.cyan("/olore-docs-packager-1.0.0") + " in Claude Code to build");
+  console.log("  3. Run " + pc2.cyan("olore install ./olore-package") + " to install");
+  console.log("");
+}
+
+// src/commands/install.ts
+import path6 from "path";
+import fs6 from "fs-extra";
+import ora from "ora";
+import pc3 from "picocolors";
+
 // src/core/registry.ts
 var RegistryError = class extends Error {
   constructor(message, code) {
@@ -468,22 +775,22 @@ async function resolveVersion(name, version2) {
 // src/commands/install.ts
 async function installFromLocal(localPath) {
   const fullPath = expandPath(localPath);
-  if (!await fs5.pathExists(fullPath)) {
+  if (!await fs6.pathExists(fullPath)) {
     throw new Error(`Path not found: ${fullPath}`);
   }
-  const stat = await fs5.stat(fullPath);
+  const stat = await fs6.stat(fullPath);
   if (!stat.isDirectory()) {
     throw new Error(`Not a directory: ${fullPath}`);
   }
-  const lockPath = path5.join(fullPath, "olore-lock.json");
-  if (!await fs5.pathExists(lockPath)) {
+  const lockPath = path6.join(fullPath, "olore-lock.json");
+  if (!await fs6.pathExists(lockPath)) {
     throw new Error(`Missing olore-lock.json in ${fullPath}`);
   }
-  const skillPath = path5.join(fullPath, "SKILL.md");
-  if (!await fs5.pathExists(skillPath)) {
+  const skillPath = path6.join(fullPath, "SKILL.md");
+  if (!await fs6.pathExists(skillPath)) {
     throw new Error(`Missing SKILL.md in ${fullPath}. Run /generate-agent-skills first.`);
   }
-  const lock = await fs5.readJson(lockPath);
+  const lock = await fs6.readJson(lockPath);
   const packageName = lock.name;
   const packageVersion = lock.version;
   if (!packageName) {
@@ -493,72 +800,57 @@ async function installFromLocal(localPath) {
     throw new Error(`Invalid olore-lock.json: missing "version" field`);
   }
   const skillName = `olore-${packageName}-${packageVersion}`;
-  const skillContent = await fs5.readFile(skillPath, "utf-8");
+  const skillContent = await fs6.readFile(skillPath, "utf-8");
   const nameMatch = skillContent.match(/^name:\s*(.+)$/m);
   const skillMdName = nameMatch ? nameMatch[1].trim() : null;
   if (skillMdName !== skillName) {
-    console.log(pc2.yellow(`
+    console.log(pc3.yellow(`
 Warning: SKILL.md name mismatch`));
-    console.log(pc2.gray(`  Expected: ${skillName}`));
-    console.log(pc2.gray(`  Found:    ${skillMdName || "(none)"}`));
-    console.log(pc2.yellow(`  Updating SKILL.md to fix...`));
+    console.log(pc3.gray(`  Expected: ${skillName}`));
+    console.log(pc3.gray(`  Found:    ${skillMdName || "(none)"}`));
+    console.log(pc3.yellow(`  Updating SKILL.md to fix...`));
     const updatedContent = skillMdName ? skillContent.replace(/^name:\s*.+$/m, `name: ${skillName}`) : skillContent.replace(/^---\n/, `---
 name: ${skillName}
 `);
-    await fs5.writeFile(skillPath, updatedContent);
+    await fs6.writeFile(skillPath, updatedContent);
   }
-  console.log(pc2.bold(`
+  console.log(pc3.bold(`
 Installing ${packageName}@${packageVersion} from local path...
 `));
   const agents = detectAgents();
   if (agents.length === 0) {
-    console.log(pc2.yellow("No agents detected. Creating directories anyway."));
+    console.log(pc3.yellow("No agents detected. Creating directories anyway."));
   }
   const agentPaths = getAgentPaths();
-  if (isWindows) {
-    const spinner = ora("Copying to agent directories...").start();
-    const copied = [];
-    for (const [agent, skillsDir] of Object.entries(agentPaths)) {
-      const targetDir = path5.join(skillsDir, skillName);
-      await fs5.ensureDir(skillsDir);
-      await fs5.remove(targetDir);
-      await fs5.copy(fullPath, targetDir);
-      copied.push(`${pc2.green("\u2713")} ${agent} ${pc2.gray("\u2192")} ${pc2.gray(targetDir)}`);
-    }
-    spinner.stop();
-    copied.forEach((line) => console.log(`  ${line}`));
-    console.log(pc2.gray(`    \u2514\u2500 copied from ${fullPath}`));
-  } else {
-    const olorePath = getOlorePackagePath(packageName, packageVersion);
-    const spinner = ora("Copying to ~/.olore...").start();
-    await fs5.ensureDir(path5.dirname(olorePath));
-    await fs5.remove(olorePath);
-    await fs5.copy(fullPath, olorePath);
-    spinner.succeed(`Copied to ${pc2.gray(olorePath)}`);
-    const linkSpinner = ora("Creating symlinks...").start();
-    const linked = [];
-    for (const [agent, skillsDir] of Object.entries(agentPaths)) {
-      const targetDir = path5.join(skillsDir, skillName);
-      await fs5.ensureDir(skillsDir);
-      await fs5.remove(targetDir);
-      await linkOrCopy(olorePath, targetDir);
-      linked.push(`${pc2.green("\u2713")} ${agent} ${pc2.gray("\u2192")} ${pc2.gray(targetDir)}`);
-    }
-    linkSpinner.stop();
-    linked.forEach((line) => console.log(`  ${line}`));
-    console.log(pc2.gray(`    \u2514\u2500 all symlinked to ${olorePath}`));
+  const olorePath = getOlorePackagePath(packageName, packageVersion);
+  const spinner = ora("Copying to ~/.olore...").start();
+  await fs6.ensureDir(path6.dirname(olorePath));
+  await fs6.remove(olorePath);
+  await fs6.copy(fullPath, olorePath);
+  spinner.succeed(`Copied to ${pc3.gray(olorePath)}`);
+  const linkSpinner = ora("Linking to agent directories...").start();
+  const linked = [];
+  for (const [agent, skillsDir] of Object.entries(agentPaths)) {
+    const targetDir = path6.join(skillsDir, skillName);
+    await fs6.ensureDir(skillsDir);
+    await fs6.remove(targetDir);
+    await linkOrCopy(olorePath, targetDir);
+    linked.push(`${pc3.green("\u2713")} ${agent} ${pc3.gray("\u2192")} ${pc3.gray(targetDir)}`);
   }
+  linkSpinner.stop();
+  linked.forEach((line) => console.log(`  ${line}`));
+  console.log(pc3.gray(`    \u2514\u2500 all linked to ${olorePath}`));
   console.log("");
-  console.log(pc2.green("Installation complete!"));
+  console.log(pc3.green("Installation complete!"));
   console.log("");
-  console.log(pc2.gray("Skill is now available as:"));
-  console.log(pc2.cyan(`  /${skillName}`) + pc2.gray(" (Claude Code)"));
-  console.log(pc2.cyan(`  $${skillName}`) + pc2.gray(" (Codex)"));
-  console.log(pc2.cyan(`  ${skillName}`) + pc2.gray(" (OpenCode)"));
+  console.log(pc3.gray("Skill is now available as:"));
+  console.log(pc3.cyan(`  /${skillName}`) + pc3.gray(" (Claude Code)"));
+  console.log(pc3.cyan(`  $${skillName}`) + pc3.gray(" (Codex)"));
+  console.log(pc3.cyan(`  ${skillName}`) + pc3.gray(" (OpenCode)"));
 }
 async function install(pkg, options) {
   if (options.force) {
-    console.log(pc2.cyan("\n\u2728 May the Skill be with you.\n"));
+    console.log(pc3.cyan("\n\u2728 May the Skill be with you.\n"));
   }
   if (isLocalPath(pkg)) {
     await installFromLocal(pkg);
@@ -579,7 +871,7 @@ function parsePackageSpec(spec) {
 async function installFromRemote(pkg, optionsVersion) {
   const { name, version: specVersion } = parsePackageSpec(pkg);
   const requestedVersion = optionsVersion || specVersion || "latest";
-  console.log(pc2.bold(`
+  console.log(pc3.bold(`
 Installing ${name}@${requestedVersion} from registry...
 `));
   const spinner = ora("Fetching package info...").start();
@@ -591,18 +883,18 @@ Installing ${name}@${requestedVersion} from registry...
     spinner.fail("Failed to resolve package");
     if (error instanceof RegistryError) {
       if (error.code === "NOT_FOUND") {
-        console.log(pc2.yellow(`
+        console.log(pc3.yellow(`
 Package "${name}" not found in registry.`));
-        console.log(pc2.gray("\nFor local packages, use a path:"));
-        console.log(pc2.cyan(`  olore install ./vault/packages/${name}/<version>`));
+        console.log(pc3.gray("\nFor local packages, use a path:"));
+        console.log(pc3.cyan(`  olore install ./vault/packages/${name}/<version>`));
         console.log("");
       } else if (error.code === "NETWORK_ERROR" || error.code === "TIMEOUT") {
-        console.log(pc2.red(`
+        console.log(pc3.red(`
 Network error: ${error.message}`));
-        console.log(pc2.gray("Please check your internet connection and try again."));
+        console.log(pc3.gray("Please check your internet connection and try again."));
       }
     } else {
-      console.log(pc2.red(`
+      console.log(pc3.red(`
 Error: ${error instanceof Error ? error.message : "Unknown error"}`));
     }
     process.exit(1);
@@ -610,114 +902,74 @@ Error: ${error instanceof Error ? error.message : "Unknown error"}`));
   const skillName = `olore-${name}-${versionInfo.version}`;
   const agents = detectAgents();
   if (agents.length === 0) {
-    console.log(pc2.yellow("No agents detected. Creating directories anyway."));
+    console.log(pc3.yellow("No agents detected. Creating directories anyway."));
   }
   const agentPaths = getAgentPaths();
-  if (isWindows) {
-    const downloadSpinner = ora("Downloading package...").start();
-    let tempDir;
-    try {
-      tempDir = await downloadAndExtractToTemp(versionInfo.downloadUrl, versionInfo.integrity);
-      downloadSpinner.succeed("Downloaded and verified");
-    } catch (error) {
-      downloadSpinner.fail("Download failed");
-      if (error instanceof DownloadError) {
-        if (error.code === "CHECKSUM_MISMATCH") {
-          console.log(pc2.red("\nChecksum verification failed!"));
-          console.log(pc2.gray("The downloaded package may be corrupted or tampered with."));
-        } else {
-          console.log(pc2.red(`
-Download error: ${error.message}`));
-        }
+  const olorePath = getOlorePackagePath(name, versionInfo.version);
+  const downloadSpinner = ora("Downloading package...").start();
+  try {
+    await downloadAndInstall(versionInfo.downloadUrl, olorePath, versionInfo.integrity);
+    downloadSpinner.succeed(`Downloaded to ${pc3.gray(olorePath)}`);
+  } catch (error) {
+    downloadSpinner.fail("Download failed");
+    if (error instanceof DownloadError) {
+      if (error.code === "CHECKSUM_MISMATCH") {
+        console.log(pc3.red("\nChecksum verification failed!"));
+        console.log(pc3.gray("The downloaded package may be corrupted or tampered with."));
       } else {
-        console.log(pc2.red(`
-Error: ${error instanceof Error ? error.message : "Unknown error"}`));
-      }
-      process.exit(1);
-    }
-    try {
-      const copySpinner = ora("Copying to agent directories...").start();
-      const copied = [];
-      for (const [agent, skillsDir] of Object.entries(agentPaths)) {
-        const targetDir = path5.join(skillsDir, skillName);
-        await fs5.ensureDir(skillsDir);
-        await fs5.remove(targetDir);
-        await fs5.copy(tempDir, targetDir);
-        copied.push(`${pc2.green("\u2713")} ${agent} ${pc2.gray("\u2192")} ${pc2.gray(targetDir)}`);
-      }
-      copySpinner.stop();
-      copied.forEach((line) => console.log(`  ${line}`));
-    } finally {
-      await fs5.remove(path5.dirname(tempDir)).catch(() => {
-      });
-    }
-  } else {
-    const olorePath = getOlorePackagePath(name, versionInfo.version);
-    const downloadSpinner = ora("Downloading package...").start();
-    try {
-      await downloadAndInstall(versionInfo.downloadUrl, olorePath, versionInfo.integrity);
-      downloadSpinner.succeed(`Downloaded to ${pc2.gray(olorePath)}`);
-    } catch (error) {
-      downloadSpinner.fail("Download failed");
-      if (error instanceof DownloadError) {
-        if (error.code === "CHECKSUM_MISMATCH") {
-          console.log(pc2.red("\nChecksum verification failed!"));
-          console.log(pc2.gray("The downloaded package may be corrupted or tampered with."));
-        } else {
-          console.log(pc2.red(`
+        console.log(pc3.red(`
 Download error: ${error.message}`));
-        }
-      } else {
-        console.log(pc2.red(`
-Error: ${error instanceof Error ? error.message : "Unknown error"}`));
       }
-      process.exit(1);
-    }
-    const linkSpinner = ora("Creating symlinks...").start();
-    const linked = [];
-    for (const [agent, skillsDir] of Object.entries(agentPaths)) {
-      const targetDir = path5.join(skillsDir, skillName);
-      await fs5.ensureDir(skillsDir);
-      await fs5.remove(targetDir);
-      await linkOrCopy(olorePath, targetDir);
-      linked.push(`${pc2.green("\u2713")} ${agent} ${pc2.gray("\u2192")} ${pc2.gray(targetDir)}`);
+    } else {
+      console.log(pc3.red(`
+Error: ${error instanceof Error ? error.message : "Unknown error"}`));
     }
-    linkSpinner.stop();
-    linked.forEach((line) => console.log(`  ${line}`));
-    console.log(pc2.gray(`    \u2514\u2500 all symlinked to ${olorePath}`));
+    process.exit(1);
   }
+  const linkSpinner = ora("Linking to agent directories...").start();
+  const linked = [];
+  for (const [agent, skillsDir] of Object.entries(agentPaths)) {
+    const targetDir = path6.join(skillsDir, skillName);
+    await fs6.ensureDir(skillsDir);
+    await fs6.remove(targetDir);
+    await linkOrCopy(olorePath, targetDir);
+    linked.push(`${pc3.green("\u2713")} ${agent} ${pc3.gray("\u2192")} ${pc3.gray(targetDir)}`);
+  }
+  linkSpinner.stop();
+  linked.forEach((line) => console.log(`  ${line}`));
+  console.log(pc3.gray(`    \u2514\u2500 all linked to ${olorePath}`));
   console.log("");
-  console.log(pc2.green("Installation complete!"));
+  console.log(pc3.green("Installation complete!"));
   console.log("");
-  console.log(pc2.gray("Skill is now available as:"));
-  console.log(pc2.cyan(`  /${skillName}`) + pc2.gray(" (Claude Code)"));
-  console.log(pc2.cyan(`  $${skillName}`) + pc2.gray(" (Codex)"));
-  console.log(pc2.cyan(`  ${skillName}`) + pc2.gray(" (OpenCode)"));
+  console.log(pc3.gray("Skill is now available as:"));
+  console.log(pc3.cyan(`  /${skillName}`) + pc3.gray(" (Claude Code)"));
+  console.log(pc3.cyan(`  $${skillName}`) + pc3.gray(" (Codex)"));
+  console.log(pc3.cyan(`  ${skillName}`) + pc3.gray(" (OpenCode)"));
 }
 
 // src/commands/link.ts
-import path6 from "path";
-import fs6 from "fs-extra";
+import path7 from "path";
+import fs7 from "fs-extra";
 import ora2 from "ora";
-import pc3 from "picocolors";
+import pc4 from "picocolors";
 async function link(localPath) {
   const fullPath = expandPath(localPath);
-  if (!await fs6.pathExists(fullPath)) {
+  if (!await fs7.pathExists(fullPath)) {
     throw new Error(`Path not found: ${fullPath}`);
   }
-  const stat = await fs6.stat(fullPath);
+  const stat = await fs7.stat(fullPath);
   if (!stat.isDirectory()) {
     throw new Error(`Not a directory: ${fullPath}`);
   }
-  const lockPath = path6.join(fullPath, "olore-lock.json");
-  if (!await fs6.pathExists(lockPath)) {
+  const lockPath = path7.join(fullPath, "olore-lock.json");
+  if (!await fs7.pathExists(lockPath)) {
     throw new Error(`Missing olore-lock.json in ${fullPath}`);
   }
-  const skillPath = path6.join(fullPath, "SKILL.md");
-  if (!await fs6.pathExists(skillPath)) {
+  const skillPath = path7.join(fullPath, "SKILL.md");
+  if (!await fs7.pathExists(skillPath)) {
     throw new Error(`Missing SKILL.md in ${fullPath}. Run /build-docs first.`);
   }
-  const lock = await fs6.readJson(lockPath);
+  const lock = await fs7.readJson(lockPath);
   const packageName = lock.name;
   const packageVersion = lock.version;
   if (!packageName) {
@@ -727,87 +979,96 @@ async function link(localPath) {
     throw new Error(`Invalid olore-lock.json: missing "version" field`);
   }
   const skillName = `olore-${packageName}-${packageVersion}`;
-  const skillContent = await fs6.readFile(skillPath, "utf-8");
+  const skillContent = await fs7.readFile(skillPath, "utf-8");
   const nameMatch = skillContent.match(/^name:\s*(.+)$/m);
   const skillMdName = nameMatch ? nameMatch[1].trim() : null;
   if (skillMdName !== skillName) {
-    console.log(pc3.yellow(`
+    console.log(pc4.yellow(`
 Warning: SKILL.md name mismatch`));
-    console.log(pc3.gray(`  Expected: ${skillName}`));
-    console.log(pc3.gray(`  Found:    ${skillMdName || "(none)"}`));
-    console.log(pc3.yellow(`  Updating SKILL.md to fix...`));
+    console.log(pc4.gray(`  Expected: ${skillName}`));
+    console.log(pc4.gray(`  Found:    ${skillMdName || "(none)"}`));
+    console.log(pc4.yellow(`  Updating SKILL.md to fix...`));
     const updatedContent = skillMdName ? skillContent.replace(/^name:\s*.+$/m, `name: ${skillName}`) : skillContent.replace(/^---\n/, `---
 name: ${skillName}
 `);
-    await fs6.writeFile(skillPath, updatedContent);
+    await fs7.writeFile(skillPath, updatedContent);
   }
-  console.log(pc3.bold(`
+  console.log(pc4.bold(`
 Linking ${packageName}@${packageVersion}...
 `));
   const agents = detectAgents();
   if (agents.length === 0) {
-    console.log(pc3.yellow("No agents detected. Creating directories anyway."));
+    console.log(pc4.yellow("No agents detected. Creating directories anyway."));
   }
   const agentPaths = getAgentPaths();
   const spinner = ora2(`${getLinkActionText()}...`).start();
   const linked = [];
   for (const [agent, skillsDir] of Object.entries(agentPaths)) {
-    const targetDir = path6.join(skillsDir, skillName);
-    await fs6.ensureDir(skillsDir);
-    await fs6.remove(targetDir);
+    const targetDir = path7.join(skillsDir, skillName);
+    await fs7.ensureDir(skillsDir);
+    await fs7.remove(targetDir);
     await linkOrCopy(fullPath, targetDir);
-    linked.push(`${pc3.blue("\u26D3")} ${agent} ${pc3.gray("\u2192")} ${pc3.gray(targetDir)}`);
+    linked.push(`${pc4.blue("\u26D3")} ${agent} ${pc4.gray("\u2192")} ${pc4.gray(targetDir)}`);
   }
   spinner.stop();
   linked.forEach((line) => console.log(`  ${line}`));
-  console.log(pc3.gray(`    \u2514\u2500 ${getLinkTypeText()} ${fullPath}`));
+  console.log(pc4.gray(`    \u2514\u2500 ${getLinkTypeText()} ${fullPath}`));
   console.log("");
-  console.log(pc3.blue("Link complete!"));
+  console.log(pc4.blue("Link complete!"));
   console.log("");
-  console.log(pc3.gray("Skill is now available as:"));
-  console.log(pc3.cyan(`  /${skillName}`) + pc3.gray(" (Claude Code)"));
-  console.log(pc3.cyan(`  $${skillName}`) + pc3.gray(" (Codex)"));
-  console.log(pc3.cyan(`  ${skillName}`) + pc3.gray(" (OpenCode)"));
+  console.log(pc4.gray("Skill is now available as:"));
+  console.log(pc4.cyan(`  /${skillName}`) + pc4.gray(" (Claude Code)"));
+  console.log(pc4.cyan(`  $${skillName}`) + pc4.gray(" (Codex)"));
+  console.log(pc4.cyan(`  ${skillName}`) + pc4.gray(" (OpenCode)"));
   console.log("");
-  console.log(pc3.gray(`Development mode: ${getLinkTypeText()} source (bypasses ~/.olore).`));
-  console.log(pc3.gray("On Unix, changes to source are immediately visible."));
-  console.log(pc3.gray("On Windows, re-run link after changes."));
+  console.log(pc4.gray(`Development mode: ${getLinkTypeText()} source (bypasses ~/.olore).`));
+  console.log(pc4.gray("Changes to source are immediately visible."));
   console.log(
-    pc3.gray("Use ") + pc3.cyan("olore install") + pc3.gray(" for a stable copy in ~/.olore.")
+    pc4.gray("Use ") + pc4.cyan("olore install") + pc4.gray(" for a stable copy in ~/.olore.")
   );
 }
 
 // src/commands/list.ts
-import pc4 from "picocolors";
+import pc5 from "picocolors";
 async function list(options) {
   const packages = await getInstalledPackages();
   if (packages.length === 0) {
-    console.log(pc4.yellow("\nI find your lack of skills disturbing.\n"));
-    console.log(pc4.gray("No packages installed."));
-    console.log(`Run ${pc4.cyan("olore install <package>")} to install documentation.`);
+    console.log(pc5.yellow("\nI find your lack of skills disturbing.\n"));
+    console.log(pc5.gray("No packages installed."));
+    console.log(`Run ${pc5.cyan("olore install <package>")} to install documentation.`);
     return;
   }
   if (options.json) {
-    console.log(JSON.stringify(packages, null, 2));
+    const { issues: issues2 } = await diagnose();
+    console.log(JSON.stringify({ packages, issueCount: issues2.length }, null, 2));
     return;
   }
-  console.log(pc4.bold("\nInstalled packages:\n"));
+  console.log(pc5.bold("\nInstalled packages:\n"));
   console.log(
-    pc4.gray(
+    pc5.gray(
       "PACKAGE".padEnd(25) + "VERSION".padEnd(12) + "TYPE".padEnd(10) + "FILES".padStart(8) + "SIZE".padStart(12)
     )
   );
-  console.log(pc4.gray("-".repeat(67)));
+  console.log(pc5.gray("-".repeat(67)));
   for (const pkg of packages) {
-    const typeLabel = pkg.installType === "linked" ? pc4.blue("linked") : pkg.installType;
+    const typeLabel = pkg.installType === "linked" ? pc5.blue("linked") : pkg.installType;
     console.log(
       pkg.name.padEnd(25) + pkg.version.padEnd(12) + typeLabel.padEnd(10) + String(pkg.files).padStart(8) + formatSize(pkg.size).padStart(12)
     );
   }
-  console.log(pc4.gray("-".repeat(67)));
-  console.log(pc4.gray(`Total: ${packages.length} packages`));
+  console.log(pc5.gray("-".repeat(67)));
+  console.log(pc5.gray(`Total: ${packages.length} packages`));
   console.log("");
-  console.log(pc4.gray("Types: installed = in ~/.olore, linked = dev symlink, copied = legacy"));
+  console.log(pc5.gray("Types: installed = in ~/.olore, linked = dev symlink, copied = legacy"));
+  const { issues } = await diagnose();
+  if (issues.length > 0) {
+    console.log("");
+    console.log(
+      pc5.yellow(
+        `\u26A0 ${issues.length} issue${issues.length === 1 ? "" : "s"} detected. Run ${pc5.cyan("olore doctor")} for details.`
+      )
+    );
+  }
 }
 function formatSize(bytes) {
   if (bytes < 1024) return `${bytes} B`;
@@ -816,54 +1077,129 @@ function formatSize(bytes) {
 }
 
 // src/commands/order66.ts
-import path7 from "path";
-import fs7 from "fs-extra";
+import path8 from "path";
+import fs8 from "fs-extra";
 import ora3 from "ora";
-import pc5 from "picocolors";
+import pc6 from "picocolors";
 async function order66() {
-  console.log(pc5.red("\n\u26A0\uFE0F  Execute Order 66?\n"));
-  console.log(pc5.yellow("This will remove ALL installed documentation packages."));
+  console.log(pc6.red("\n\u26A0\uFE0F  Execute Order 66?\n"));
+  console.log(pc6.yellow("This will remove ALL installed documentation packages."));
   const packages = await getInstalledPackages();
   if (packages.length === 0) {
-    console.log(pc5.gray("\nNo packages to remove. The Jedi are already gone."));
+    console.log(pc6.gray("\nNo packages to remove. The Jedi are already gone."));
     return;
   }
-  console.log(pc5.gray(`
+  console.log(pc6.gray(`
 Packages to be removed: ${packages.length}`));
   for (const pkg of packages) {
-    console.log(pc5.gray(`  - ${pkg.name}@${pkg.version}`));
+    console.log(pc6.gray(`  - ${pkg.name}@${pkg.version}`));
   }
-  console.log(pc5.red('\n"It will be done, my lord."\n'));
+  console.log(pc6.red('\n"It will be done, my lord."\n'));
   const spinner = ora3("Executing Order 66...").start();
   let removedCount = 0;
   const agentPaths = getAgentPaths();
   for (const pkg of packages) {
     const skillName = `olore-${pkg.name}-${pkg.version}`;
     for (const [, basePath] of Object.entries(agentPaths)) {
-      const skillPath = path7.join(basePath, skillName);
-      if (await fs7.pathExists(skillPath)) {
-        await fs7.remove(skillPath);
+      const skillPath = path8.join(basePath, skillName);
+      if (await fs8.pathExists(skillPath)) {
+        await fs8.remove(skillPath);
       }
     }
     if (pkg.installType === "installed") {
       const olorePath = getOlorePackagePath(pkg.name, pkg.version);
-      if (await fs7.pathExists(olorePath)) {
-        await fs7.remove(olorePath);
+      if (await fs8.pathExists(olorePath)) {
+        await fs8.remove(olorePath);
       }
     }
     removedCount++;
   }
   spinner.succeed(`Removed ${removedCount} packages`);
-  console.log(pc5.gray("\nThe Jedi have been eliminated."));
+  console.log(pc6.gray("\nThe Jedi have been eliminated."));
+}
+
+// src/commands/prune.ts
+import pc7 from "picocolors";
+async function prune(options) {
+  if (!options.json) {
+    console.log(pc7.bold("\nScanning for issues...\n"));
+  }
+  const { issues } = await diagnose();
+  if (issues.length === 0) {
+    if (options.json) {
+      console.log(JSON.stringify({ removed: [], failed: [] }, null, 2));
+    } else {
+      console.log(pc7.green("Nothing to prune. Everything is clean."));
+    }
+    return;
+  }
+  if (options.dryRun) {
+    if (options.json) {
+      console.log(JSON.stringify({ dryRun: true, wouldRemove: issues }, null, 2));
+      return;
+    }
+    console.log(
+      pc7.yellow(`Would remove ${issues.length} item${issues.length === 1 ? "" : "s"}:
+`)
+    );
+    for (const issue of issues) {
+      console.log(`  ${issueLabel(issue.type)}  ${displayPath(issue.path)}`);
+    }
+    console.log(`
+Run ${pc7.cyan("olore prune")} (without --dry-run) to remove them.`);
+    return;
+  }
+  const result = await pruneIssues(issues);
+  if (options.json) {
+    console.log(JSON.stringify(result, null, 2));
+    return;
+  }
+  if (result.removed.length > 0) {
+    let totalFreed = 0;
+    console.log(`Removed ${result.removed.length} item${result.removed.length === 1 ? "" : "s"}:`);
+    for (const entry of result.removed) {
+      totalFreed += entry.freedBytes;
+      console.log(
+        `  ${pc7.green("\u2713")} ${displayPath(entry.issue.path)} (${issueLabel(entry.issue.type)})`
+      );
+    }
+    if (totalFreed > 0) {
+      console.log(`
+${formatBytes(totalFreed)} freed.`);
+    }
+  }
+  if (result.failed.length > 0) {
+    console.log("");
+    console.log(
+      pc7.red(
+        `Failed to remove ${result.failed.length} item${result.failed.length === 1 ? "" : "s"}:`
+      )
+    );
+    for (const entry of result.failed) {
+      console.log(`  ${pc7.red("\u2717")} ${displayPath(entry.issue.path)}: ${entry.error}`);
+    }
+  }
+}
+function issueLabel(type) {
+  switch (type) {
+    case "dangling-symlink":
+      return "dangling symlink";
+    case "orphaned":
+      return "orphaned package";
+    case "partial-install":
+      return "partial install";
+    default:
+      return type;
+  }
 }
 
 // src/commands/remove.ts
-import path8 from "path";
-import fs8 from "fs-extra";
+import path9 from "path";
+import fs9 from "fs-extra";
 import ora4 from "ora";
-import pc6 from "picocolors";
+import pc8 from "picocolors";
 async function remove(pkg) {
-  console.log(pc6.bold(`
+  console.log(pc8.bold(`
 Removing ${pkg}...
 `));
   const packages = await getInstalledPackages();
@@ -879,20 +1215,20 @@ Removing ${pkg}...
     return p.name === name;
   });
   if (matches.length === 0) {
-    console.error(pc6.red(`Package not found: ${pkg}`));
+    console.error(pc8.red(`Package not found: ${pkg}`));
     console.log("\nInstalled packages:");
     for (const p of packages) {
-      console.log(`  ${pc6.cyan(p.name)}@${p.version}`);
+      console.log(`  ${pc8.cyan(p.name)}@${p.version}`);
     }
     process.exit(1);
   }
   if (matches.length > 1 && !version2) {
-    console.error(pc6.red(`Multiple versions found for ${name}:`));
+    console.error(pc8.red(`Multiple versions found for ${name}:`));
     for (const p of matches) {
-      console.log(`  ${pc6.cyan(p.name)}@${p.version} (${p.installType})`);
+      console.log(`  ${pc8.cyan(p.name)}@${p.version} (${p.installType})`);
     }
     console.log(`
-Specify version: ${pc6.cyan(`olore remove ${name}@<version>`)}`);
+Specify version: ${pc8.cyan(`olore remove ${name}@<version>`)}`);
     process.exit(1);
   }
   const found = matches[0];
@@ -901,26 +1237,26 @@ Specify version: ${pc6.cyan(`olore remove ${name}@<version>`)}`);
   const removed = [];
   const agentPaths = getAgentPaths();
   for (const [agent, basePath] of Object.entries(agentPaths)) {
-    const skillPath = path8.join(basePath, skillName);
-    if (await fs8.pathExists(skillPath)) {
-      await fs8.remove(skillPath);
-      removed.push(`${pc6.green("\u2713")} ${agent}`);
+    const skillPath = path9.join(basePath, skillName);
+    if (await fs9.pathExists(skillPath)) {
+      await fs9.remove(skillPath);
+      removed.push(`${pc8.green("\u2713")} ${agent}`);
     }
   }
   if (found.installType === "installed") {
     const olorePath = getOlorePackagePath(found.name, found.version);
-    if (await fs8.pathExists(olorePath)) {
-      await fs8.remove(olorePath);
-      removed.push(`${pc6.green("\u2713")} ~/.olore`);
+    if (await fs9.pathExists(olorePath)) {
+      await fs9.remove(olorePath);
+      removed.push(`${pc8.green("\u2713")} ~/.olore`);
     }
   }
   spinner.stop();
   if (removed.length === 0) {
-    console.log(pc6.yellow("No files found to remove."));
+    console.log(pc8.yellow("No files found to remove."));
   } else {
     removed.forEach((line) => console.log(`  ${line}`));
     console.log("");
-    console.log(pc6.green(`Removed ${found.name}@${found.version}`));
+    console.log(pc8.green(`Removed ${found.name}@${found.version}`));
   }
 }
 
@@ -929,12 +1265,12 @@ var require2 = createRequire(import.meta.url);
 var { version } = require2("../package.json");
 var program = new Command();
 program.name("olore").description("Universal documentation for any AI coding agent").version(version).addHelpText("after", `
-${pc7.gray("May the Skill be with you.")}`);
+${pc9.gray("May the Skill be with you.")}`);
 program.command("init").description("Initialize a documentation package in the current directory").option("-n, --name <name>", "Package name (default: folder name)").option("-v, --version <version>", "Package version (default: latest)").option("-y, --yes", "Skip prompts, use defaults").action(async (options) => {
   try {
     await init(options);
   } catch (error) {
-    console.error(pc7.red(`Error: ${error.message}`));
+    console.error(pc9.red(`Error: ${error.message}`));
     process.exit(1);
   }
 });
@@ -942,7 +1278,7 @@ program.command("install <package>").alias("i").description("Install a documenta
   try {
     await install(pkg, options);
   } catch (error) {
-    console.error(pc7.red(`Error: ${error.message}`));
+    console.error(pc9.red(`Error: ${error.message}`));
     process.exit(1);
   }
 });
@@ -950,7 +1286,7 @@ program.command("link <path>").description("Link a local package for development
   try {
     await link(localPath);
   } catch (error) {
-    console.error(pc7.red(`Error: ${error.message}`));
+    console.error(pc9.red(`Error: ${error.message}`));
     process.exit(1);
   }
 });
@@ -958,7 +1294,7 @@ program.command("list").alias("ls").description("List installed documentation pa
   try {
     await list(options);
   } catch (error) {
-    console.error(pc7.red(`Error: ${error.message}`));
+    console.error(pc9.red(`Error: ${error.message}`));
     process.exit(1);
   }
 });
@@ -966,7 +1302,23 @@ program.command("remove <package>").alias("rm").description("Remove an installed
   try {
     await remove(pkg);
   } catch (error) {
-    console.error(pc7.red(`Error: ${error.message}`));
+    console.error(pc9.red(`Error: ${error.message}`));
+    process.exit(1);
+  }
+});
+program.command("doctor").description("Check for issues with installed packages").option("--json", "Output as JSON").action(async (options) => {
+  try {
+    await doctor(options);
+  } catch (error) {
+    console.error(pc9.red(`Error: ${error.message}`));
+    process.exit(1);
+  }
+});
+program.command("prune").description("Remove dangling symlinks, orphaned packages, and partial installs").option("--dry-run", "Show what would be removed without acting").option("--json", "Output as JSON").action(async (options) => {
+  try {
+    await prune(options);
+  } catch (error) {
+    console.error(pc9.red(`Error: ${error.message}`));
     process.exit(1);
   }
 });
@@ -974,7 +1326,7 @@ program.command("order66").description(false).action(async () => {
   try {
     await order66();
   } catch (error) {
-    console.error(pc7.red(`Error: ${error.message}`));
+    console.error(pc9.red(`Error: ${error.message}`));
     process.exit(1);
   }
 });