dme-agent 7.4.1 → 9.69.0

package/src/install.mjs

@@ -1,17 +1,41 @@
 /**
- * DME bootstrap installer — copies manifesto, system prompt, skills, rules
- * into every major agent CLI surface.
+ * DME bootstrap installer — detect-only by default, AGENTS.md conflict prompts.
+ * v9.69 — full skill set, 9.69 asset names with fallbacks.
  */
 
 import fs from "node:fs";
 import path from "node:path";
 import { fileURLToPath } from "node:url";
-import { filterTargets } from "./targets.mjs";
-import { ok, fail, skip, info, warn, step, hr, box, table } from "./ui.mjs";
+import { resolveInstallTargets, getDetectedTargets, formatScanReport } from "./detect.mjs";
+import { getTargets } from "./targets.mjs";
+import {
+  ok,
+  fail,
+  skip,
+  info,
+  warn,
+  step,
+  hr,
+  box,
+  table,
+  progressBar,
+  asciiLogo,
+  c,
+} from "./ui.mjs";
+import { agentsConflictPromptInline, multiSelect, printScanTable } from "./tui.mjs";
 
 const __dirname = path.dirname(fileURLToPath(import.meta.url));
 const PKG_ROOT = path.resolve(__dirname, "..");
 const ASSETS = path.join(PKG_ROOT, "assets");
+const VERSION = "9.69.0";
+const VERSION_SHORT = "9.69";
+const MARKER_BEGIN = "<!-- DME-AGENT-9.69 BEGIN -->";
+const MARKER_END = "<!-- DME-AGENT-9.69 END -->";
+/** Also strip/recognize older installs */
+const LEGACY_MARKERS = [
+  { begin: "<!-- DME-AGENT-7.4 BEGIN -->", end: "<!-- DME-AGENT-7.4 END -->" },
+  { begin: "<!-- DME-AGENT-9.69 BEGIN -->", end: "<!-- DME-AGENT-9.69 END -->" },
+];
 
 const SKILL_NAMES = [
   "dme-design",
@@ -21,6 +45,10 @@ const SKILL_NAMES = [
   "dme-dashboard",
   "dme-landing",
   "dme-ux",
+  "dme-motion",
+  "dme-icons",
+  "dme-app-shell",
+  "dme-welcome",
 ];
 
 function ensureDir(dir) {
@@ -33,47 +61,53 @@ function readAsset(...parts) {
   return fs.readFileSync(p, "utf8");
 }
 
-function writeFile(filePath, content, { appendMarker } = {}) {
-  ensureDir(path.dirname(filePath));
-  if (appendMarker && fs.existsSync(filePath)) {
-    const existing = fs.readFileSync(filePath, "utf8");
-    if (existing.includes(appendMarker)) {
-      // replace block between markers
-      const re = new RegExp(
-        `${escapeRe(appendMarker)}[\\s\\S]*?${escapeRe(appendMarker.replace("BEGIN", "END"))}`,
-        "m"
-      );
-      const endMarker = appendMarker.replace("BEGIN", "END");
-      const block = `${appendMarker}\n${content.trim()}\n${endMarker}\n`;
-      if (re.test(existing)) {
-        fs.writeFileSync(filePath, existing.replace(re, block.trimEnd() + "\n"), "utf8");
-      } else {
-        fs.writeFileSync(
-          filePath,
-          existing.trimEnd() + "\n\n" + block,
-          "utf8"
-        );
-      }
-      return "updated";
-    }
-    const endMarker = appendMarker.replace("BEGIN", "END");
-    fs.writeFileSync(
-      filePath,
-      existing.trimEnd() +
-        "\n\n" +
-        `${appendMarker}\n${content.trim()}\n${endMarker}\n`,
-      "utf8"
-    );
-    return "appended";
+/** Prefer 9.69 filenames, fall back to older names */
+function readAssetPrefer(candidates) {
+  for (const parts of candidates) {
+    const content = readAsset(...parts);
+    if (content) return content;
   }
-  fs.writeFileSync(filePath, content, "utf8");
-  return fs.existsSync(filePath) ? "written" : "written";
+  return null;
 }
 
 function escapeRe(s) {
   return s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
 }
 
+function writeRaw(filePath, content) {
+  ensureDir(path.dirname(filePath));
+  fs.writeFileSync(filePath, content, "utf8");
+  return "written";
+}
+
+function mergeBlock(filePath, content) {
+  ensureDir(path.dirname(filePath));
+  const block = `${MARKER_BEGIN}\n${content.trim()}\n${MARKER_END}\n`;
+  if (!fs.existsSync(filePath)) {
+    fs.writeFileSync(filePath, block, "utf8");
+    return "created";
+  }
+  let existing = fs.readFileSync(filePath, "utf8");
+  // strip any known DME marker blocks first
+  for (const { begin, end } of LEGACY_MARKERS) {
+    const re = new RegExp(
+      `${escapeRe(begin)}[\\s\\S]*?${escapeRe(end)}\\n?`,
+      "m"
+    );
+    existing = existing.replace(re, "");
+  }
+  const reCurrent = new RegExp(
+    `${escapeRe(MARKER_BEGIN)}[\\s\\S]*?${escapeRe(MARKER_END)}\\n?`,
+    "m"
+  );
+  if (reCurrent.test(existing)) {
+    fs.writeFileSync(filePath, existing.replace(reCurrent, block), "utf8");
+    return "updated";
+  }
+  fs.writeFileSync(filePath, existing.trimEnd() + "\n\n" + block, "utf8");
+  return "appended";
+}
+
 function copySkill(skillName, destRoot) {
   const src = path.join(ASSETS, "skills", skillName, "SKILL.md");
   if (!fs.existsSync(src)) return null;
@@ -86,31 +120,48 @@ function copySkill(skillName, destRoot) {
 
 function systemPrompt() {
   return (
-    readAsset("agent", "DME-Agent-v7.4-SYSTEM.md") ||
-    readAsset("agent", "SYSTEM.md") ||
-    "# DME 7.4\n"
+    readAssetPrefer([
+      ["agent", "DME-Agent-v9.69-SYSTEM.md"],
+      ["agent", "DME-Agent-v7.4-SYSTEM.md"],
+      ["agent", "SYSTEM.md"],
+    ]) || `# DME ${VERSION_SHORT}\n`
+  );
+}
+
+function agentsDoctrine() {
+  return (
+    readAssetPrefer([
+      ["agent", "AGENTS.md"],
+      ["agent", "PROMPT-COMPACT.md"],
+    ]) || systemPrompt()
   );
 }
 
 function compactPrompt() {
-  return readAsset("agent", "PROMPT-COMPACT.md") || systemPrompt();
+  return readAsset("agent", "PROMPT-COMPACT.md") || agentsDoctrine();
 }
 
 function manifesto() {
   return (
-    readAsset("manifesto", "DME-Agent-v7.4.md") ||
-    readAsset("manifesto", "MANIFESTO.md") ||
-    systemPrompt()
+    readAssetPrefer([
+      ["manifesto", "DME-Agent-v9.69.md"],
+      ["manifesto", "DME-Agent-v7.4.md"],
+    ]) || agentsDoctrine()
   );
 }
 
 function agentProfile() {
-  return readAsset("agent", "dme-v7.4.md") || systemPrompt();
+  return (
+    readAssetPrefer([
+      ["agent", "dme-v9.69.md"],
+      ["agent", "dme-v7.4.md"],
+    ]) || systemPrompt()
+  );
 }
 
 function cursorRule() {
   return `---
-description: DME Agent 7.4 — Neominimal Identity Engine. Apply on any UI/UX/frontend work.
+description: DME Agent ${VERSION} — Neominimal Identity Engine. Apply on any UI/UX/frontend work.
 globs:
   - "**/*.{tsx,jsx,vue,svelte,css,html}"
   - "**/components/**"
@@ -119,41 +170,182 @@ globs:
 alwaysApply: false
 ---
 
-${compactPrompt()}
+${agentsDoctrine()}
 `;
 }
 
-function rulesSnippet() {
-  return compactPrompt();
+function isAgentsLikePath(filePath) {
+  const base = path.basename(filePath).toLowerCase();
+  return (
+    base === "agents.md" ||
+    base === "claude.md" ||
+    base === "gemini.md" ||
+    base === "conventions.md" ||
+    base === "copilot-instructions.md" ||
+    base === ".cursorrules" ||
+    base === ".windsurfrules"
+  );
+}
+
+/**
+ * Resolve policy for an existing AGENTS-like file.
+ * @returns {Promise<"merge"|"overwrite"|"skip">}
+ */
+async function resolveAgentsPolicy(filePath, opts) {
+  if (opts.agentsPolicy && opts.agentsPolicy !== "ask") {
+    return opts.agentsPolicy;
+  }
+  if (opts.force) return "merge";
+  if (opts.dryRun) return "merge";
+  if (!fs.existsSync(filePath)) return "overwrite";
+
+  const existing = fs.readFileSync(filePath, "utf8");
+  if (
+    (existing.includes("DME Agent 9.69") ||
+      existing.includes("DME Agent 7.4") ||
+      existing.includes("Neominimal Identity")) &&
+    existing.length < 12000 &&
+    !existing.includes(MARKER_BEGIN) &&
+    !existing.includes("<!-- DME-AGENT-7.4 BEGIN -->")
+  ) {
+    return "overwrite";
+  }
+
+  if (opts.quiet) return "merge";
+
+  return agentsConflictPromptInline(filePath);
+}
+
+async function writeAgentsFile(filePath, doctrine, opts, row) {
+  if (opts.dryRun) {
+    row.files.push(`[dry] agents → ${filePath}`);
+    return;
+  }
+
+  if (!fs.existsSync(filePath)) {
+    writeRaw(filePath, doctrine);
+    row.files.push(`${filePath} (created)`);
+    console.log(ok(`AGENTS  created  ${filePath}`));
+    return;
+  }
+
+  const policy = await resolveAgentsPolicy(filePath, opts);
+  if (policy === "skip") {
+    row.files.push(`${filePath} (skipped)`);
+    console.log(skip(`AGENTS  skipped   ${filePath}`));
+    return;
+  }
+  if (policy === "overwrite") {
+    writeRaw(filePath, doctrine);
+    row.files.push(`${filePath} (overwritten)`);
+    console.log(warn(`AGENTS  overwrite ${filePath}`));
+    return;
+  }
+  const mode = mergeBlock(filePath, doctrine);
+  row.files.push(`${filePath} (${mode})`);
+  console.log(ok(`AGENTS  ${mode.padEnd(9)} ${filePath}`));
 }
 
 /**
- * @param {{ targets?: string[], force?: boolean, dryRun?: boolean, cwdProject?: boolean }} opts
+ * @param {{
+ *   targets?: string[],
+ *   force?: boolean,
+ *   dryRun?: boolean,
+ *   cwdProject?: boolean,
+ *   agentsPolicy?: "ask"|"merge"|"overwrite"|"skip",
+ *   interactive?: boolean,
+ *   quiet?: boolean,
+ *   pick?: boolean,
+ * }} opts
  */
 export async function installDme(opts = {}) {
-  const targets = filterTargets(opts.targets);
-  const results = [];
-  const total = 6;
+  const interactive = opts.interactive !== false && process.stdin.isTTY;
+  let targetIds = opts.targets;
+
+  if (!targetIds || targetIds.length === 0) {
+    targetIds = ["detected"];
+  }
 
-  console.log(step(1, total, "Reading DME 7.4 assets…"));
+  let targets = resolveInstallTargets(targetIds, { force: opts.force });
+
+  if (
+    interactive &&
+    opts.pick !== false &&
+    (targetIds.includes("detected") || targetIds.length === 0) &&
+    !opts.quiet
+  ) {
+    const detected = getDetectedTargets();
+    if (detected.length === 0) {
+      console.log(asciiLogo(VERSION_SHORT));
+      console.log(fail("No AI CLIs detected on this machine."));
+      console.log(
+        info("Run with --targets all  or  --targets claude,cursor  to force.")
+      );
+      console.log(info("Or: dme scan   to see the detection report."));
+      console.log("");
+      return { ok: false, results: [], reason: "none-detected" };
+    }
+
+    const selected = await multiSelect(
+      "Select CLIs to install DME into",
+      detected.map((t) => ({
+        id: t.id,
+        label: t.name,
+        detail: t.agentsMd ? path.basename(t.agentsMd) : "",
+        checked: true,
+      }))
+    );
+
+    if (selected.length === 0) {
+      console.log(warn("Nothing selected. Abort."));
+      return { ok: false, results: [], reason: "none-selected" };
+    }
+    targets = resolveInstallTargets(selected, { force: true });
+  }
+
+  if (targets.length === 0) {
+    console.log(fail("No targets to install."));
+    console.log(info("dme scan  — see detection"));
+    console.log(info("dme install --targets all  — force every surface"));
+    return { ok: false, results: [] };
+  }
+
+  const results = [];
+  const total = 5;
+  const doctrine = agentsDoctrine();
   const sys = systemPrompt();
-  const compact = compactPrompt();
   const full = manifesto();
   const profile = agentProfile();
+  const compact = compactPrompt();
 
-  if (!sys || sys.length < 100) {
-    console.log(fail("System prompt asset missing or empty."));
+  console.log(asciiLogo(VERSION_SHORT));
+  console.log(hr());
+  console.log(step(1, total, "Loading DME doctrine…"));
+  if (!doctrine || doctrine.length < 80) {
+    console.log(fail("AGENTS.md asset missing."));
     return { ok: false, results };
   }
-  console.log(ok(`Manifesto ${full.length} chars · system ${sys.length} chars`));
+  console.log(
+    ok(
+      `doctrine ${doctrine.length} chars · manifesto ${full.length} · system ${sys.length}`
+    )
+  );
+  console.log(
+    info(
+      `targets: ${targets.map((t) => t.id).join(", ")} ${c.dim}(detected-only by default)${c.reset}`
+    )
+  );
   console.log(hr());
 
-  console.log(step(2, total, `Installing into ${targets.length} surfaces…`));
-
+  console.log(step(2, total, `Installing ${targets.length} surface(s)…`));
+  let i = 0;
   for (const t of targets) {
+    i++;
+    console.log(
+      `\n  ${c.brightMagenta}${c.bold}▸ ${t.name}${c.reset}  ${c.dim}${t.id}${c.reset}  ${progressBar(i, targets.length, 16)}`
+    );
     const row = { id: t.id, name: t.name, files: [], errors: [] };
     try {
-      // skills
       for (const skillDir of t.skillDirs) {
         if (opts.dryRun) {
           row.files.push(`[dry] skills → ${skillDir}`);
@@ -164,90 +356,75 @@ export async function installDme(opts = {}) {
           const dest = copySkill(skill, skillDir);
           if (dest) row.files.push(dest);
         }
+        console.log(ok(`skills → ${skillDir}`));
       }
 
-      // agent profiles
       for (const af of t.agentFiles) {
         if (opts.dryRun) {
           row.files.push(`[dry] agent → ${af}`);
           continue;
         }
-        const content =
-          af.endsWith(".mdc") || af.includes("rules")
-            ? cursorRule()
-            : profile.includes("name: dme")
-              ? profile
-              : profile;
-        writeFile(af, af.includes("cursor") && af.endsWith(".md") ? profile : content);
-        // for agent md files use profile; for CLAUDE_DME use full system
         if (af.includes("CLAUDE_DME") || af.includes("instructions")) {
-          writeFile(af, sys);
-        } else if (af.endsWith("dme-v7.4.md")) {
-          writeFile(af, profile);
+          writeRaw(af, sys);
+        } else {
+          writeRaw(af, profile);
         }
         row.files.push(af);
       }
 
-      // rules — append or write dedicated
+      if (t.agentsMd) {
+        await writeAgentsFile(t.agentsMd, doctrine, opts, row);
+      }
+
       for (const rf of t.rulesFiles) {
         if (opts.dryRun) {
           row.files.push(`[dry] rules → ${rf}`);
           continue;
         }
+        if (t.agentsMd && path.resolve(rf) === path.resolve(t.agentsMd)) {
+          continue;
+        }
+
         ensureDir(path.dirname(rf));
         const base = path.basename(rf).toLowerCase();
 
         if (base === "dme-agent.mdc" || rf.endsWith(".mdc")) {
-          writeFile(rf, cursorRule());
+          writeRaw(rf, cursorRule());
           row.files.push(rf);
           continue;
         }
 
-        if (
-          base === "claude.md" ||
-          base === "agents.md" ||
-          base === "agents.md" ||
-          base === ".cursorrules" ||
-          base === ".windsurfrules" ||
-          base === "gemini.md" ||
-          base === "copilot-instructions.md" ||
-          base === "dme-conventions.md" ||
-          base.endsWith("agents.md")
-        ) {
-          // append DME block to shared rules so we don't wipe user content
-          const marker = "<!-- DME-AGENT-7.4 BEGIN -->";
-          writeFile(rf, rulesSnippet(), { appendMarker: marker });
-          row.files.push(rf + " (merged)");
+        if (isAgentsLikePath(rf)) {
+          await writeAgentsFile(rf, doctrine, opts, row);
           continue;
         }
 
         if (base.includes("dme") || base.includes("conventions")) {
-          writeFile(rf, sys);
+          writeRaw(rf, sys);
           row.files.push(rf);
           continue;
         }
 
-        writeFile(rf, compact);
+        writeRaw(rf, compact);
         row.files.push(rf);
       }
 
-      // always drop full manifesto into target root if root exists or is under home config
       if (!opts.dryRun && t.root) {
         try {
           ensureDir(t.root);
-          const manPath = path.join(t.root, "DME-Agent-v7.4.md");
-          writeFile(manPath, full);
-          row.files.push(manPath);
-          const sysPath = path.join(t.root, "DME-SYSTEM.md");
-          writeFile(sysPath, sys);
-          row.files.push(sysPath);
+          const manName = "DME-Agent-v9.69.md";
+          writeRaw(path.join(t.root, manName), full);
+          writeRaw(path.join(t.root, "DME-SYSTEM.md"), sys);
+          // keep legacy filename for older tooling that looks for 7.4
+          writeRaw(path.join(t.root, "DME-Agent-v7.4.md"), full);
+          row.files.push(path.join(t.root, manName));
         } catch {
-          /* ignore optional root */
+          /* ignore */
         }
       }
 
       results.push({ ...row, status: "ok" });
-      console.log(ok(`${t.name.padEnd(28)} ${row.files.length} paths`));
+      console.log(ok(`${t.name} done — ${row.files.length} paths`));
     } catch (e) {
       results.push({ ...row, status: "error", error: String(e?.message || e) });
       console.log(fail(`${t.name}: ${e?.message || e}`));
@@ -255,32 +432,17 @@ export async function installDme(opts = {}) {
   }
 
   console.log(hr());
-  console.log(step(3, total, "Project-local install (cwd)…"));
+  console.log(step(3, total, "Project-local (cwd)…"));
   if (opts.cwdProject !== false) {
     try {
-      const cwd = process.cwd();
-      const localRoots = [
-        path.join(cwd, ".grok", "skills"),
-        path.join(cwd, ".claude", "skills"),
-        path.join(cwd, ".cursor", "skills"),
-        path.join(cwd, ".agents", "skills"),
-      ];
-      for (const lr of localRoots) {
-        if (opts.dryRun) continue;
-        ensureDir(lr);
-        for (const skill of SKILL_NAMES) copySkill(skill, lr);
-      }
-      if (!opts.dryRun) {
-        writeFile(path.join(cwd, "AGENTS.dme.md"), compact);
-        writeFile(path.join(cwd, ".dme", "DME-Agent-v7.4.md"), full);
-        writeFile(path.join(cwd, ".dme", "SYSTEM.md"), sys);
-        // merge into AGENTS.md if present or create pointer
-        const agentsMd = path.join(cwd, "AGENTS.md");
-        writeFile(agentsMd, compact, {
-          appendMarker: "<!-- DME-AGENT-7.4 BEGIN -->",
-        });
-      }
-      console.log(ok(`Project skills + AGENTS.md in ${cwd}`));
+      await installProjectLocal({
+        opts,
+        doctrine,
+        sys,
+        full,
+        compact,
+        targets,
+      });
     } catch (e) {
       console.log(warn(`Project install: ${e?.message || e}`));
     }
@@ -289,78 +451,133 @@ export async function installDme(opts = {}) {
   }
 
   console.log(hr());
-  console.log(step(4, total, "Obsidian-ready manifesto…"));
-  if (!opts.dryRun) {
-    const obs = path.join(process.cwd(), "obsidian");
-    ensureDir(obs);
-    writeFile(path.join(obs, "DME-Agent-v7.4.md"), full);
-    console.log(ok(path.join(obs, "DME-Agent-v7.4.md")));
-  }
-
-  console.log(step(5, total, "Summary"));
+  console.log(step(4, total, "Summary"));
   const okN = results.filter((r) => r.status === "ok").length;
   const errN = results.filter((r) => r.status === "error").length;
   console.log(
     table([
-      ["version", "7.4.1"],
+      ["version", VERSION],
       ["targets ok", String(okN)],
       ["errors", String(errN)],
-      ["skills", SKILL_NAMES.join(", ")],
+      ["mode", targetIds.includes("all") ? "all" : "detected"],
+      ["skills", String(SKILL_NAMES.length)],
     ])
   );
 
   console.log(hr());
-  console.log(step(6, total, "Next"));
+  console.log(step(5, total, "Next"));
   console.log(
-    box("DME is live", [
-      "Restart Claude / Cursor / Zed / Grok sessions",
-      "Slash: /dme-design  /dme-dashboard  /dme-landing",
-      "System: ask the agent to follow DME 7.4",
-      "Full doctrine: DME-Agent-v7.4.md in each root",
-    ])
+    box(
+      "DME 9.69 is live",
+      [
+        "Restart agent sessions (Claude / Cursor / Grok…)",
+        "AGENTS.md is in each CLI’s correct path",
+        "Skills: design · dashboard · landing · motion · icons",
+        "app-shell · welcome · ux · shadcn · research · critique",
+        "dme doctor  ·  dme scan  ·  dme uninstall",
+      ],
+      "green"
+    )
   );
   console.log("");
-  console.log(info("dme doctor   — verify install"));
-  console.log(info("dme update   — re-sync latest assets"));
-  console.log(info("dme uninstall — remove DME blocks (safe merge)"));
-  console.log("");
 
   return { ok: errN === 0, results };
 }
 
+async function installProjectLocal({ opts, doctrine, sys, full, compact, targets }) {
+  const cwd = process.cwd();
+  const skillRoots = new Set();
+  for (const t of targets) {
+    if (t.id === "claude") skillRoots.add(path.join(cwd, ".claude", "skills"));
+    if (t.id === "cursor") skillRoots.add(path.join(cwd, ".cursor", "skills"));
+    if (t.id === "grok") skillRoots.add(path.join(cwd, ".grok", "skills"));
+    if (t.id === "codex") skillRoots.add(path.join(cwd, ".codex", "skills"));
+    if (t.id === "zed") skillRoots.add(path.join(cwd, ".agents", "skills"));
+  }
+  skillRoots.add(path.join(cwd, ".agents", "skills"));
+
+  if (!opts.dryRun) {
+    for (const lr of skillRoots) {
+      ensureDir(lr);
+      for (const skill of SKILL_NAMES) copySkill(skill, lr);
+    }
+    writeRaw(path.join(cwd, ".dme", "DME-Agent-v9.69.md"), full);
+    writeRaw(path.join(cwd, ".dme", "DME-Agent-v7.4.md"), full);
+    writeRaw(path.join(cwd, ".dme", "SYSTEM.md"), sys);
+    writeRaw(path.join(cwd, ".dme", "AGENTS.md"), doctrine);
+    writeRaw(path.join(cwd, "AGENTS.dme.md"), doctrine);
+
+    const agentsMd = path.join(cwd, "AGENTS.md");
+    const row = { files: [] };
+    await writeAgentsFile(agentsMd, doctrine, opts, row);
+    console.log(ok(`project → ${cwd}`));
+  } else {
+    console.log(skip(`[dry] project → ${cwd}`));
+  }
+}
+
 export function doctor() {
-  const targets = filterTargets(["all"]);
-  console.log(step(1, 1, "Scanning DME install…"));
+  console.log(asciiLogo(VERSION_SHORT));
+  console.log(step(1, 1, "Scanning DME install health…"));
   console.log(hr());
-  for (const t of targets) {
+  const report = formatScanReport();
+  for (const row of report) {
+    const t = getTargets().find((x) => x.id === row.id);
+    if (!t) continue;
     const hits = [];
+    if (row.detected) hits.push("cli-present");
     for (const skillDir of t.skillDirs) {
       for (const skill of SKILL_NAMES) {
-        const p = path.join(skillDir, skill, "SKILL.md");
-        if (fs.existsSync(p)) hits.push(skill);
+        if (fs.existsSync(path.join(skillDir, skill, "SKILL.md"))) hits.push(skill);
       }
     }
-    for (const af of t.agentFiles) {
-      if (fs.existsSync(af)) hits.push(path.basename(af));
+    if (t.agentsMd && fs.existsSync(t.agentsMd)) {
+      const txt = fs.readFileSync(t.agentsMd, "utf8");
+      if (txt.includes("DME") || txt.includes("9.69") || txt.includes("7.4"))
+        hits.push("agents.md");
+      else hits.push("agents.md(no-dme)");
     }
-    for (const rf of t.rulesFiles) {
-      if (fs.existsSync(rf)) {
-        const txt = fs.readFileSync(rf, "utf8");
-        if (txt.includes("DME") || txt.includes("7.4")) hits.push(path.basename(rf));
-      }
+    const man969 = path.join(t.root, "DME-Agent-v9.69.md");
+    const man74 = path.join(t.root, "DME-Agent-v7.4.md");
+    if (fs.existsSync(man969) || fs.existsSync(man74)) hits.push("manifesto");
+
+    if (hits.length && row.detected) {
+      console.log(
+        ok(
+          `${t.name.padEnd(24)} ${hits.length} hits  ${c.dim}${hits.slice(0, 5).join(", ")}${c.reset}`
+        )
+      );
+    } else if (row.detected) {
+      console.log(warn(`${t.name.padEnd(24)} detected but DME not installed`));
+    } else {
+      console.log(skip(`${t.name.padEnd(24)} CLI not on this PC`));
     }
-    const man = path.join(t.root, "DME-Agent-v7.4.md");
-    if (fs.existsSync(man)) hits.push("manifesto");
-
-    if (hits.length) console.log(ok(`${t.name.padEnd(28)} ${hits.length} hits`));
-    else console.log(skip(`${t.name.padEnd(28)} not installed`));
   }
   console.log("");
 }
 
-export function uninstall() {
-  console.log(warn("Uninstall removes DME-named files and <!-- DME-AGENT-7.4 --> blocks."));
-  const targets = filterTargets(["all"]);
+export function scan() {
+  printScanTable(formatScanReport());
+  const n = getDetectedTargets().length;
+  console.log(
+    info(
+      `${c.brightGreen}${n}${c.reset} CLI(s) detected — install will target only these by default`
+    )
+  );
+  console.log("");
+}
+
+export function uninstall(opts = {}) {
+  console.log(asciiLogo(VERSION_SHORT));
+  console.log(warn("Removing DME files & DME-AGENT marker blocks…"));
+  console.log(hr());
+
+  const targets = opts.all
+    ? getTargets()
+    : getDetectedTargets().length
+      ? getDetectedTargets()
+      : getTargets();
+
   for (const t of targets) {
     for (const skillDir of t.skillDirs) {
       for (const skill of SKILL_NAMES) {
@@ -372,12 +589,12 @@ export function uninstall() {
       }
     }
     for (const af of t.agentFiles) {
-      if (fs.existsSync(af) && path.basename(af).includes("dme")) {
+      if (fs.existsSync(af) && path.basename(af).toLowerCase().includes("dme")) {
         fs.unlinkSync(af);
         console.log(ok(`removed ${af}`));
       }
     }
-    for (const rf of t.rulesFiles) {
+    for (const rf of [...t.rulesFiles, t.agentsMd].filter(Boolean)) {
       if (!fs.existsSync(rf)) continue;
       const base = path.basename(rf).toLowerCase();
       if (base.includes("dme") || base.endsWith(".mdc")) {
@@ -386,17 +603,27 @@ export function uninstall() {
         continue;
       }
       let txt = fs.readFileSync(rf, "utf8");
-      const re =
-        /<!-- DME-AGENT-7\.4 BEGIN -->[\s\S]*?<!-- DME-AGENT-7\.4 END -->\n?/g;
-      if (re.test(txt)) {
-        txt = txt.replace(re, "");
+      let changed = false;
+      for (const { begin, end } of LEGACY_MARKERS) {
+        const re = new RegExp(
+          `${escapeRe(begin)}[\\s\\S]*?${escapeRe(end)}\\n?`,
+          "g"
+        );
+        if (re.test(txt)) {
+          txt = txt.replace(re, "");
+          changed = true;
+        }
+      }
+      if (changed) {
         fs.writeFileSync(rf, txt, "utf8");
         console.log(ok(`stripped DME block from ${rf}`));
       }
     }
-    const man = path.join(t.root, "DME-Agent-v7.4.md");
-    const sys = path.join(t.root, "DME-SYSTEM.md");
-    for (const p of [man, sys]) {
+    for (const p of [
+      path.join(t.root, "DME-Agent-v9.69.md"),
+      path.join(t.root, "DME-Agent-v7.4.md"),
+      path.join(t.root, "DME-SYSTEM.md"),
+    ]) {
       if (fs.existsSync(p)) {
         fs.unlinkSync(p);
         console.log(ok(`removed ${p}`));
@@ -405,3 +632,5 @@ export function uninstall() {
   }
   console.log(ok("Uninstall complete."));
 }
+
+export { SKILL_NAMES, VERSION, VERSION_SHORT };