dlw-machine-setup 0.8.10 → 0.9.0

package/bin/installer.js

@@ -2753,13 +2753,13 @@ var PromisePolyfill = class extends Promise {
   // Available starting from Node 22
   // https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Promise/withResolvers
   static withResolver() {
-    let resolve4;
+    let resolve6;
     let reject;
     const promise = new Promise((res, rej) => {
-      resolve4 = res;
+      resolve6 = res;
       reject = rej;
     });
-    return { promise, resolve: resolve4, reject };
+    return { promise, resolve: resolve6, reject };
   }
 };
 
@@ -2776,7 +2776,7 @@ function createPrompt(view) {
       output
     });
     const screen = new ScreenManager(rl);
-    const { promise, resolve: resolve4, reject } = PromisePolyfill.withResolver();
+    const { promise, resolve: resolve6, reject } = PromisePolyfill.withResolver();
     const cancel = () => reject(new CancelPromptError());
     if (signal) {
       const abort = () => reject(new AbortPromptError({ cause: signal.reason }));
@@ -2800,7 +2800,7 @@ function createPrompt(view) {
       cycle(() => {
         try {
           const nextView = view(config, (value) => {
-            setImmediate(() => resolve4(value));
+            setImmediate(() => resolve6(value));
           });
           const [content, bottomContent] = typeof nextView === "string" ? [nextView] : nextView;
           screen.render(content, bottomContent);
@@ -3244,9 +3244,9 @@ ${page}${helpTipBottom}${choiceDescription}${import_ansi_escapes3.default.cursor
 });
 
 // src/index.ts
-var import_fs12 = require("fs");
-var import_readline = require("readline");
-var import_path13 = require("path");
+var import_fs16 = require("fs");
+var import_readline2 = require("readline");
+var import_path16 = require("path");
 
 // src/utils/fetch.ts
 var DEFAULT_TIMEOUT_MS = 3e4;
@@ -3301,7 +3301,7 @@ async function fetchWithRetry(url, options = {}, maxRetries = DEFAULT_MAX_RETRIE
     }
     if (attempt < maxRetries) {
       const delay = retryDelayMs * Math.pow(2, attempt - 1);
-      await new Promise((resolve4) => setTimeout(resolve4, delay));
+      await new Promise((resolve6) => setTimeout(resolve6, delay));
     }
   }
   throw lastError || new Error("Failed after maximum retries");
@@ -3548,7 +3548,7 @@ async function pollForToken(deviceCode, interval) {
   const maxAttempts = 60;
   let attempts = 0;
   while (attempts < maxAttempts) {
-    await new Promise((resolve4) => setTimeout(resolve4, interval * 1e3));
+    await new Promise((resolve6) => setTimeout(resolve6, interval * 1e3));
     const response = await fetchWithTimeout(GITHUB_TOKEN_URL, {
       method: "POST",
       headers: {
@@ -3734,6 +3734,7 @@ async function runPipeline(steps, ctx) {
       entries.push({ name: step.name, label: step.label, result });
       if (result.status === "success") {
         console.log("\u2713");
+        ctx.journal?.recordStep(step.name, result.record);
       } else {
         console.log("\u2717");
       }
@@ -3753,6 +3754,148 @@ async function runPipeline(steps, ctx) {
   }
   return { entries };
 }
+async function runRollback(steps, ctx) {
+  const entries = [];
+  if (!ctx.journal) {
+    return { entries };
+  }
+  const stepsByName = new Map(steps.map((s) => [s.name, s]));
+  for (const journalEntry of ctx.journal.getEntriesReversed()) {
+    const step = stepsByName.get(journalEntry.step);
+    if (!step) {
+      entries.push({
+        name: journalEntry.step,
+        label: journalEntry.step,
+        result: {
+          status: "skipped",
+          detail: "step not found in this installer build \u2014 installed by a different version?"
+        }
+      });
+      continue;
+    }
+    if (!step.inverse) {
+      entries.push({
+        name: step.name,
+        label: step.label,
+        result: { status: "skipped", detail: "no inverse defined" }
+      });
+      continue;
+    }
+    const label = step.inverse.label ?? `Reversing: ${step.label}`;
+    process.stdout.write(`  ${label}...  `);
+    try {
+      const result = await step.inverse.execute(journalEntry.record, ctx);
+      entries.push({ name: step.name, label, result });
+      if (result.status === "success") {
+        console.log("\u2713");
+      } else if (result.status === "failed") {
+        console.log("\u2717");
+      } else {
+        console.log("\u2014");
+      }
+      if (result.detail) {
+        console.log(`    ${result.detail}`);
+      }
+    } catch (err) {
+      const detail = err instanceof Error ? err.message : String(err);
+      entries.push({
+        name: step.name,
+        label,
+        result: { status: "failed", detail }
+      });
+      console.log("\u2717");
+      console.log(`    ${detail}`);
+    }
+  }
+  return { entries };
+}
+
+// src/journal.ts
+var import_fs3 = require("fs");
+var import_path3 = require("path");
+var JOURNAL_SCHEMA_VERSION = 1;
+var Journal = class {
+  filePath;
+  entries = [];
+  /** Top-level summary fields (everything outside `rollback`). Owned by
+   *  write-state.ts; the journal just carries them so the on-disk file
+   *  stays one coherent JSON document instead of two side-by-side files. */
+  summary = {};
+  constructor(filePath) {
+    this.filePath = filePath;
+  }
+  /** Load existing state from disk. Used by uninstall. Tolerates a missing
+   *  or corrupt file — both surface as "no entries to roll back." */
+  load() {
+    this.entries = [];
+    this.summary = {};
+    if (!(0, import_fs3.existsSync)(this.filePath)) return;
+    try {
+      const raw = JSON.parse((0, import_fs3.readFileSync)(this.filePath, "utf-8"));
+      const { rollback, ...summary } = raw;
+      this.summary = summary;
+      if (rollback && typeof rollback === "object") {
+        const section = rollback;
+        if (Array.isArray(section.entries)) {
+          this.entries = section.entries.filter(
+            (e) => !!e && typeof e === "object" && typeof e.step === "string"
+          );
+        }
+      }
+    } catch {
+    }
+  }
+  /** Clear in-memory state and flush an empty file to disk. Used by install
+   *  at the start of a run so a previous install's journal never leaks
+   *  into a fresh run's rollback list. */
+  startFresh() {
+    this.entries = [];
+    this.summary = {};
+    this.flush();
+  }
+  /** Append a completed step to the journal and flush immediately. The
+   *  flush-per-step is intentional: an install that crashes between step 4
+   *  and step 5 still leaves a journal that ends at step 4. */
+  recordStep(name, record) {
+    this.entries.push({
+      step: name,
+      completedAt: (/* @__PURE__ */ new Date()).toISOString(),
+      record
+    });
+    this.flush();
+  }
+  /** Replace the top-level summary fields and flush. Called by
+   *  write-state.ts so the existing on-disk shape is preserved. */
+  setSummary(summary) {
+    this.summary = summary;
+    this.flush();
+  }
+  /** Entries in install order (oldest first). */
+  getEntries() {
+    return this.entries;
+  }
+  /** Entries in rollback order (most-recent first). LIFO so each step's
+   *  inverse undoes its own changes before any earlier step's state is
+   *  touched — matters when later steps depend on earlier ones (e.g.
+   *  write-instructions reads _ai-context/ that fetch-contexts populated). */
+  getEntriesReversed() {
+    return [...this.entries].reverse();
+  }
+  /** Persist the current summary + entries to disk as one JSON document.
+   *  Summary fields come first so a human opening the file sees the
+   *  familiar shape; `rollback` is the last key. */
+  flush() {
+    (0, import_fs3.mkdirSync)((0, import_path3.dirname)(this.filePath), { recursive: true });
+    const out = {
+      ...this.summary,
+      rollback: {
+        schemaVersion: JOURNAL_SCHEMA_VERSION,
+        entries: this.entries
+      }
+    };
+    (0, import_fs3.writeFileSync)(this.filePath, JSON.stringify(out, null, 2), "utf-8");
+  }
+};
 
 // src/steps/index.ts
 var steps_exports = {};
@@ -3768,19 +3911,146 @@ __export(steps_exports, {
 });
 
 // src/steps/resources/fetch-contexts.ts
-var import_fs4 = require("fs");
-var import_path4 = require("path");
+var import_fs6 = require("fs");
+var import_path6 = require("path");
 
 // src/utils/fs-copy.ts
-var import_fs3 = require("fs");
-var import_path3 = require("path");
+var import_fs4 = require("fs");
+var import_path4 = require("path");
 function copyDirectory(source, target) {
-  if (!(0, import_fs3.existsSync)(target)) (0, import_fs3.mkdirSync)(target, { recursive: true });
-  for (const entry of (0, import_fs3.readdirSync)(source, { withFileTypes: true })) {
-    const s = (0, import_path3.join)(source, entry.name);
-    const t = (0, import_path3.join)(target, entry.name);
+  if (!(0, import_fs4.existsSync)(target)) (0, import_fs4.mkdirSync)(target, { recursive: true });
+  for (const entry of (0, import_fs4.readdirSync)(source, { withFileTypes: true })) {
+    const s = (0, import_path4.join)(source, entry.name);
+    const t = (0, import_path4.join)(target, entry.name);
     if (entry.isDirectory()) copyDirectory(s, t);
-    else (0, import_fs3.copyFileSync)(s, t);
+    else (0, import_fs4.copyFileSync)(s, t);
+  }
+}
+
+// src/inverse/primitives.ts
+var import_fs5 = require("fs");
+var import_path5 = require("path");
+function deleteFileIfExists(absPath) {
+  if (!(0, import_fs5.existsSync)(absPath)) return false;
+  try {
+    (0, import_fs5.unlinkSync)(absPath);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function deleteDirIfExists(absPath) {
+  if (!(0, import_fs5.existsSync)(absPath)) return false;
+  try {
+    (0, import_fs5.rmSync)(absPath, { recursive: true, force: true });
+    return true;
+  } catch {
+    return false;
+  }
+}
+function pruneEmptyParents(startPath, projectPath, maxLevels = 5) {
+  const removed = [];
+  let current = (0, import_path5.dirname)((0, import_path5.resolve)(startPath));
+  const root = (0, import_path5.resolve)(projectPath);
+  for (let i = 0; i < maxLevels; i++) {
+    if (current === root) break;
+    if (!current.startsWith(root)) break;
+    if (!(0, import_fs5.existsSync)(current)) {
+      current = (0, import_path5.dirname)(current);
+      continue;
+    }
+    try {
+      const entries = (0, import_fs5.readdirSync)(current);
+      if (entries.length > 0) break;
+      (0, import_fs5.rmSync)(current, { recursive: false });
+      removed.push(current);
+    } catch {
+      break;
+    }
+    current = (0, import_path5.dirname)(current);
+  }
+  return removed;
+}
+function readJsonOrNull(absPath) {
+  if (!(0, import_fs5.existsSync)(absPath)) return null;
+  try {
+    return JSON.parse((0, import_fs5.readFileSync)(absPath, "utf-8"));
+  } catch {
+    return null;
+  }
+}
+function isPlainObject2(v) {
+  return typeof v === "object" && v !== null && !Array.isArray(v);
+}
+var OWNER_KEY = "_bundleOwner";
+function stripOwnedEntries(value, owner) {
+  if (Array.isArray(value)) {
+    return value.filter((item) => !(isPlainObject2(item) && item[OWNER_KEY] === owner)).map((item) => stripOwnedEntries(item, owner));
+  }
+  if (isPlainObject2(value)) {
+    return Object.fromEntries(
+      Object.entries(value).map(([k, v]) => [k, stripOwnedEntries(v, owner)])
+    );
+  }
+  return value;
+}
+function deleteJsonIfEffectivelyEmpty(absPath) {
+  if (!(0, import_fs5.existsSync)(absPath)) return false;
+  const raw = readJsonOrNull(absPath);
+  if (!isPlainObject2(raw)) return false;
+  const keys = Object.keys(raw);
+  if (keys.length === 0) {
+    return deleteFileIfExists(absPath);
+  }
+  if (keys.length === 1) {
+    const v = raw[keys[0]];
+    if (isPlainObject2(v) && Object.keys(v).length === 0) return deleteFileIfExists(absPath);
+    if (Array.isArray(v) && v.length === 0) return deleteFileIfExists(absPath);
+  }
+  return false;
+}
+function stripBundleOwnerFromJsonFile(absPath, owner) {
+  const raw = readJsonOrNull(absPath);
+  if (!isPlainObject2(raw)) return false;
+  const stripped = stripOwnedEntries(raw, owner);
+  const before = JSON.stringify(raw);
+  const after = JSON.stringify(stripped);
+  if (before === after) return false;
+  (0, import_fs5.writeFileSync)(absPath, JSON.stringify(stripped, null, 2) + "\n", "utf-8");
+  return true;
+}
+function stripMcpServers(absPath, rootKey, serverNames) {
+  const raw = readJsonOrNull(absPath);
+  if (!isPlainObject2(raw)) return { changed: false, rootEmpty: false };
+  const servers = raw[rootKey];
+  if (!isPlainObject2(servers)) return { changed: false, rootEmpty: false };
+  let changed = false;
+  for (const name of serverNames) {
+    if (name in servers) {
+      delete servers[name];
+      changed = true;
+    }
+  }
+  if (!changed) {
+    return { changed: false, rootEmpty: Object.keys(servers).length === 0 };
+  }
+  raw[rootKey] = servers;
+  (0, import_fs5.writeFileSync)(absPath, JSON.stringify(raw, null, 2) + "\n", "utf-8");
+  return { changed: true, rootEmpty: Object.keys(servers).length === 0 };
+}
+function resolveProjectPath(rel, projectPath) {
+  const base = (0, import_path5.resolve)(projectPath);
+  const full = (0, import_path5.resolve)((0, import_path5.join)(base, rel));
+  if (full !== base && !full.startsWith(base + import_path5.sep)) {
+    throw new Error(`Inverse target escapes project path: ${rel}`);
+  }
+  return full;
+}
+function isDirectorySafe(absPath) {
+  try {
+    return (0, import_fs5.statSync)(absPath).isDirectory();
+  } catch {
+    return false;
   }
 }
 
@@ -3798,6 +4068,8 @@ var fetch_contexts_default = defineStep({
         detail: "Context repo not found (topic: context-data)"
       };
     }
+    const contextsDir = (0, import_path6.join)(ctx.config.projectPath, "_ai-context");
+    const contextsDirExistedBefore = (0, import_fs6.existsSync)(contextsDir);
     const downloadResult = await fetchContexts(domainValues, ctx.token, ctx.contextRepo, ctx.config.projectPath);
     ctx.installed.domainsInstalled = downloadResult.successful;
     ctx.installed.contextReleaseVersion = downloadResult.releaseVersion;
@@ -3809,16 +4081,42 @@ var fetch_contexts_default = defineStep({
       const status = ok ? "\u2713" : `\u2717  ${reason ?? "Unknown error"}`;
       console.log(`    ${domain.padEnd(domainColWidth)}${status}`);
     }
+    const record = {
+      domains: downloadResult.successful,
+      contextsDirCreated: !contextsDirExistedBefore
+    };
     if (downloadResult.failed.length > 0) {
       return {
         status: "failed",
-        message: `${downloadResult.successful.join(", ")} succeeded; ${downloadResult.failed.join(", ")} failed`
+        message: `${downloadResult.successful.join(", ")} succeeded; ${downloadResult.failed.join(", ")} failed`,
+        record
       };
     }
     return {
       status: "success",
-      message: downloadResult.successful.join(", ")
+      message: downloadResult.successful.join(", "),
+      record
     };
+  },
+  inverse: {
+    label: "Removing contexts",
+    execute: async (raw, ctx) => {
+      const rec = raw ?? {};
+      const domains = rec.domains ?? [];
+      const removed = [];
+      for (const domain of domains) {
+        const abs = resolveProjectPath((0, import_path6.join)("_ai-context", domain), ctx.config.projectPath);
+        if (deleteDirIfExists(abs)) removed.push(domain);
+      }
+      if (rec.contextsDirCreated) {
+        const firstAbs = resolveProjectPath((0, import_path6.join)("_ai-context", domains[0] ?? "_"), ctx.config.projectPath);
+        pruneEmptyParents(firstAbs, ctx.config.projectPath, 1);
+      }
+      return {
+        status: "success",
+        message: removed.length > 0 ? removed.join(", ") : "nothing to remove"
+      };
+    }
   }
 });
 async function fetchContexts(domains, token, repo, targetDir) {
@@ -3834,11 +4132,11 @@ async function fetchContexts(domains, token, repo, targetDir) {
     }
     return result;
   }
-  const contextsDir = (0, import_path4.join)(targetDir, "_ai-context");
-  if (!(0, import_fs4.existsSync)(contextsDir)) (0, import_fs4.mkdirSync)(contextsDir, { recursive: true });
+  const contextsDir = (0, import_path6.join)(targetDir, "_ai-context");
+  if (!(0, import_fs6.existsSync)(contextsDir)) (0, import_fs6.mkdirSync)(contextsDir, { recursive: true });
   const archive = await downloadAndExtractAsset(token, asset, targetDir, ".temp-download");
   try {
-    const extractedFolders = (0, import_fs4.readdirSync)(archive.extractedRoot, { withFileTypes: true }).filter((e) => e.isDirectory()).map((e) => e.name);
+    const extractedFolders = (0, import_fs6.readdirSync)(archive.extractedRoot, { withFileTypes: true }).filter((e) => e.isDirectory()).map((e) => e.name);
     for (const domain of domains) {
       try {
         const match = extractedFolders.find((f) => f.toLowerCase() === domain.toLowerCase());
@@ -3847,8 +4145,8 @@ async function fetchContexts(domains, token, repo, targetDir) {
           result.failureReasons[domain] = "Not found in archive";
           continue;
         }
-        const domainPath = (0, import_path4.join)(contextsDir, domain);
-        copyDirectory((0, import_path4.join)(archive.extractedRoot, match), domainPath);
+        const domainPath = (0, import_path6.join)(contextsDir, domain);
+        copyDirectory((0, import_path6.join)(archive.extractedRoot, match), domainPath);
         result.successful.push(domain);
       } catch (error) {
         result.failed.push(domain);
@@ -3862,29 +4160,29 @@ async function fetchContexts(domains, token, repo, targetDir) {
 }
 
 // src/steps/resources/fetch-factory.ts
-var import_fs7 = require("fs");
-var import_path7 = require("path");
+var import_fs9 = require("fs");
+var import_path9 = require("path");
 
 // src/bundles/run-bundle.ts
-var import_fs6 = require("fs");
-var import_path6 = require("path");
+var import_fs8 = require("fs");
+var import_path8 = require("path");
 
 // src/bundles/types.ts
 var SUPPORTED_SCHEMA_VERSIONS = [1, 2];
 
 // src/utils/marker-block.ts
-var import_fs5 = require("fs");
-var import_path5 = require("path");
+var import_fs7 = require("fs");
+var import_path7 = require("path");
 function upsertMarkerBlock(filePath, startMarker, endMarker, body, opts = {}) {
   const block = `${startMarker}
 ${body}
 ${endMarker}`;
-  (0, import_fs5.mkdirSync)((0, import_path5.dirname)(filePath), { recursive: true });
-  if (!(0, import_fs5.existsSync)(filePath)) {
-    (0, import_fs5.writeFileSync)(filePath, block + "\n", "utf-8");
+  (0, import_fs7.mkdirSync)((0, import_path7.dirname)(filePath), { recursive: true });
+  if (!(0, import_fs7.existsSync)(filePath)) {
+    (0, import_fs7.writeFileSync)(filePath, block + "\n", "utf-8");
     return;
   }
-  const existing = (0, import_fs5.readFileSync)(filePath, "utf-8");
+  const existing = (0, import_fs7.readFileSync)(filePath, "utf-8");
   const s = existing.indexOf(startMarker);
   const e = existing.indexOf(endMarker);
   const hasS = s !== -1;
@@ -3894,12 +4192,43 @@ ${endMarker}`;
   }
   if (hasS && hasE && e > s) {
     const updated = existing.slice(0, s) + block + existing.slice(e + endMarker.length);
-    (0, import_fs5.writeFileSync)(filePath, updated, "utf-8");
+    (0, import_fs7.writeFileSync)(filePath, updated, "utf-8");
   } else {
-    const sep3 = existing.endsWith("\n") ? "\n" : "\n\n";
-    (0, import_fs5.writeFileSync)(filePath, existing + sep3 + block + "\n", "utf-8");
+    const sep4 = existing.endsWith("\n") ? "\n" : "\n\n";
+    (0, import_fs7.writeFileSync)(filePath, existing + sep4 + block + "\n", "utf-8");
   }
 }
+function removeMarkerBlock(filePath, startMarker, endMarker, opts = {}) {
+  if (!(0, import_fs7.existsSync)(filePath)) return "absent";
+  const existing = (0, import_fs7.readFileSync)(filePath, "utf-8");
+  const s = existing.indexOf(startMarker);
+  const e = existing.indexOf(endMarker);
+  if (s === -1 && e === -1) {
+  } else if (s === -1 || e === -1 || e < s) {
+    return "corrupt";
+  }
+  let updated = existing;
+  if (s !== -1 && e !== -1) {
+    const blockEnd = e + endMarker.length;
+    let cutStart = s;
+    let cutEnd = blockEnd;
+    if (cutStart > 0 && existing[cutStart - 1] === "\n") cutStart -= 1;
+    if (existing[cutEnd] === "\n") cutEnd += 1;
+    updated = existing.slice(0, cutStart) + existing.slice(cutEnd);
+  }
+  if (opts.deleteFileIfEmpty) {
+    const stripped = opts.emptyIgnorePattern ? updated.replace(opts.emptyIgnorePattern, "") : updated;
+    if (stripped.trim() === "") {
+      (0, import_fs7.unlinkSync)(filePath);
+      return "deleted";
+    }
+  }
+  if (updated !== existing) {
+    (0, import_fs7.writeFileSync)(filePath, updated, "utf-8");
+    return "removed";
+  }
+  return "absent";
+}
 
 // src/profiles/claude-code.ts
 var claudeCodeProfile = {
@@ -4038,7 +4367,7 @@ function getProfile(agent) {
 }
 
 // src/bundles/run-bundle.ts
-var OWNER_KEY = "_bundleOwner";
+var OWNER_KEY2 = "_bundleOwner";
 async function runBundle(manifest, ctx) {
   assertSchemaCompatible(manifest);
   assertNameValid(manifest);
@@ -4054,7 +4383,10 @@ function runBundleV1(manifest, ctx) {
   const result = {
     name: manifest.name,
     opsExecuted: 0,
-    filesTouched: []
+    filesTouched: [],
+    filesCreated: [],
+    filesPatched: [],
+    markerBlockFiles: []
   };
   const ops = manifest.targets?.[ctx.agent] ?? [];
   for (const op of ops) {
@@ -4074,7 +4406,10 @@ function runBundleV2(manifest, ctx) {
   const result = {
     name: manifest.name,
     opsExecuted: 0,
-    filesTouched: []
+    filesTouched: [],
+    filesCreated: [],
+    filesPatched: [],
+    markerBlockFiles: []
   };
   const hookPatches = /* @__PURE__ */ new Map();
   for (const asset of manifest.assets ?? []) {
@@ -4122,17 +4457,18 @@ function runAsset(asset, profile, hookPatches, ctx, result) {
 function runAssetCopy(asset, handler, ctx, result) {
   if (!handler.supported || !handler.destination) return;
   const source = resolveBundlePath(asset.source, ctx);
-  if (!(0, import_fs6.existsSync)(source)) return;
-  const isDirectory = (0, import_fs6.statSync)(source).isDirectory();
+  if (!(0, import_fs8.existsSync)(source)) return;
+  const isDirectory = (0, import_fs8.statSync)(source).isDirectory();
   const targetRel = handler.destination(asset.name, isDirectory);
-  const target = resolveProjectPath(targetRel, ctx);
+  const target = resolveProjectPath2(targetRel, ctx);
   if (isDirectory) {
     copyDirectory(source, target);
   } else {
-    (0, import_fs6.mkdirSync)((0, import_path6.dirname)(target), { recursive: true });
-    (0, import_fs6.copyFileSync)(source, target);
+    (0, import_fs8.mkdirSync)((0, import_path8.dirname)(target), { recursive: true });
+    (0, import_fs8.copyFileSync)(source, target);
   }
   result.filesTouched.push(targetRel);
+  result.filesCreated.push(targetRel);
 }
 function accumulateHook(asset, handler, hookPatches, ctx, result) {
   if (!handler.supported) return;
@@ -4141,13 +4477,14 @@ function accumulateHook(asset, handler, hookPatches, ctx, result) {
   if (eventName === null) return;
   if (asset.script && handler.scriptDir) {
     const scriptSource = resolveBundlePath(asset.script, ctx);
-    if ((0, import_fs6.existsSync)(scriptSource)) {
-      const scriptName = (0, import_path6.basename)(asset.script);
+    if ((0, import_fs8.existsSync)(scriptSource)) {
+      const scriptName = (0, import_path8.basename)(asset.script);
       const scriptRelDest = `${handler.scriptDir}/${scriptName}`;
-      const scriptDest = resolveProjectPath(scriptRelDest, ctx);
-      (0, import_fs6.mkdirSync)((0, import_path6.dirname)(scriptDest), { recursive: true });
-      (0, import_fs6.copyFileSync)(scriptSource, scriptDest);
+      const scriptDest = resolveProjectPath2(scriptRelDest, ctx);
+      (0, import_fs8.mkdirSync)((0, import_path8.dirname)(scriptDest), { recursive: true });
+      (0, import_fs8.copyFileSync)(scriptSource, scriptDest);
       result.filesTouched.push(scriptRelDest);
+      result.filesCreated.push(scriptRelDest);
     }
   }
   const command = handler.scriptDir ? asset.command.replace(/\{hookDir\}/g, handler.scriptDir) : asset.command;
@@ -4181,22 +4518,24 @@ function substituteHookDir(op, profile) {
 function writeGitignoreBlock(manifest, ctx, result) {
   if (!manifest.gitignore?.length) return;
   upsertMarkerBlock(
-    (0, import_path6.join)(ctx.projectPath, ".gitignore"),
+    (0, import_path8.join)(ctx.projectPath, ".gitignore"),
     `# ${manifest.name}:start`,
     `# ${manifest.name}:end`,
     manifest.gitignore.join("\n")
   );
   result.filesTouched.push(".gitignore");
+  result.markerBlockFiles.push(".gitignore");
 }
 function writeInstructionsBlock(bundleName, snippet, instructionsFile, ctx, result) {
   if (ctx.skipInstructions) return;
   upsertMarkerBlock(
-    (0, import_path6.join)(ctx.projectPath, instructionsFile),
+    (0, import_path8.join)(ctx.projectPath, instructionsFile),
     `<!-- ${bundleName}:start -->`,
     `<!-- ${bundleName}:end -->`,
     snippet
   );
   result.filesTouched.push(instructionsFile);
+  result.markerBlockFiles.push(instructionsFile);
 }
 function executeOp(op, owner, ctx, result) {
   switch (op.op) {
@@ -4214,63 +4553,65 @@ function executeOp(op, owner, ctx, result) {
 }
 function runCopy(op, ctx, result) {
   const source = resolveBundlePath(op.from, ctx);
-  const target = resolveProjectPath(op.to, ctx);
-  if (!(0, import_fs6.existsSync)(source)) return;
-  if ((0, import_fs6.statSync)(source).isDirectory()) {
+  const target = resolveProjectPath2(op.to, ctx);
+  if (!(0, import_fs8.existsSync)(source)) return;
+  if ((0, import_fs8.statSync)(source).isDirectory()) {
     copyDirectory(source, target);
   } else {
-    (0, import_fs6.mkdirSync)((0, import_path6.dirname)(target), { recursive: true });
-    (0, import_fs6.copyFileSync)(source, target);
+    (0, import_fs8.mkdirSync)((0, import_path8.dirname)(target), { recursive: true });
+    (0, import_fs8.copyFileSync)(source, target);
   }
   result.filesTouched.push(op.to);
+  result.filesCreated.push(op.to);
 }
 function runMergeJson(op, owner, ctx, result) {
-  const filePath = resolveProjectPath(op.file, ctx);
+  const filePath = resolveProjectPath2(op.file, ctx);
   const existing = readJsonOrEmpty(filePath);
-  const stripped = stripOwnedEntries(existing, owner);
+  const stripped = stripOwnedEntries2(existing, owner);
   const tagged = tagEntries(op.patch, owner);
   const merged = deepMerge2(stripped, tagged);
-  (0, import_fs6.mkdirSync)((0, import_path6.dirname)(filePath), { recursive: true });
-  (0, import_fs6.writeFileSync)(filePath, JSON.stringify(merged, null, 2) + "\n", "utf-8");
+  (0, import_fs8.mkdirSync)((0, import_path8.dirname)(filePath), { recursive: true });
+  (0, import_fs8.writeFileSync)(filePath, JSON.stringify(merged, null, 2) + "\n", "utf-8");
   result.filesTouched.push(op.file);
+  result.filesPatched.push(op.file);
 }
 function readJsonOrEmpty(path) {
-  if (!(0, import_fs6.existsSync)(path)) return {};
+  if (!(0, import_fs8.existsSync)(path)) return {};
   try {
-    return JSON.parse((0, import_fs6.readFileSync)(path, "utf-8"));
+    return JSON.parse((0, import_fs8.readFileSync)(path, "utf-8"));
   } catch {
     return {};
   }
 }
-function isPlainObject2(v) {
+function isPlainObject3(v) {
   return typeof v === "object" && v !== null && !Array.isArray(v);
 }
 function tagEntries(value, owner) {
   if (Array.isArray(value)) {
     return value.map(
-      (item) => isPlainObject2(item) ? { ...item, [OWNER_KEY]: owner } : item
+      (item) => isPlainObject3(item) ? { ...item, [OWNER_KEY2]: owner } : item
     );
   }
-  if (isPlainObject2(value)) {
+  if (isPlainObject3(value)) {
     return Object.fromEntries(
       Object.entries(value).map(([k, v]) => [k, tagEntries(v, owner)])
     );
   }
   return value;
 }
-function stripOwnedEntries(value, owner) {
+function stripOwnedEntries2(value, owner) {
   if (Array.isArray(value)) {
-    return value.filter((item) => !(isPlainObject2(item) && item[OWNER_KEY] === owner)).map((item) => stripOwnedEntries(item, owner));
+    return value.filter((item) => !(isPlainObject3(item) && item[OWNER_KEY2] === owner)).map((item) => stripOwnedEntries2(item, owner));
   }
-  if (isPlainObject2(value)) {
+  if (isPlainObject3(value)) {
     return Object.fromEntries(
-      Object.entries(value).map(([k, v]) => [k, stripOwnedEntries(v, owner)])
+      Object.entries(value).map(([k, v]) => [k, stripOwnedEntries2(v, owner)])
     );
   }
   return value;
 }
 function deepMerge2(a, b) {
-  if (isPlainObject2(a) && isPlainObject2(b)) {
+  if (isPlainObject3(a) && isPlainObject3(b)) {
     const out = { ...a };
     for (const [k, v] of Object.entries(b)) {
       out[k] = k in a ? deepMerge2(a[k], v) : v;
@@ -4283,17 +4624,17 @@ function deepMerge2(a, b) {
   return b;
 }
 function resolveBundlePath(rel, ctx) {
-  const base = (0, import_path6.resolve)(ctx.bundleRoot);
-  const full = (0, import_path6.resolve)((0, import_path6.join)(base, rel));
-  if (full !== base && !full.startsWith(base + import_path6.sep)) {
+  const base = (0, import_path8.resolve)(ctx.bundleRoot);
+  const full = (0, import_path8.resolve)((0, import_path8.join)(base, rel));
+  if (full !== base && !full.startsWith(base + import_path8.sep)) {
     throw new Error(`Bundle op "from" escapes bundle root: ${rel}`);
   }
   return full;
 }
-function resolveProjectPath(rel, ctx) {
-  const base = (0, import_path6.resolve)(ctx.projectPath);
-  const full = (0, import_path6.resolve)((0, import_path6.join)(base, rel));
-  if (full !== base && !full.startsWith(base + import_path6.sep)) {
+function resolveProjectPath2(rel, ctx) {
+  const base = (0, import_path8.resolve)(ctx.projectPath);
+  const full = (0, import_path8.resolve)((0, import_path8.join)(base, rel));
+  if (full !== base && !full.startsWith(base + import_path8.sep)) {
     throw new Error(`Bundle op "to" escapes project path: ${rel}`);
   }
   return full;
@@ -4314,7 +4655,7 @@ function assertNameValid(manifest) {
   }
 }
 function assertBundleRootExists(ctx) {
-  if (!(0, import_fs6.existsSync)(ctx.bundleRoot) || !(0, import_fs6.statSync)(ctx.bundleRoot).isDirectory()) {
+  if (!(0, import_fs8.existsSync)(ctx.bundleRoot) || !(0, import_fs8.statSync)(ctx.bundleRoot).isDirectory()) {
     throw new Error(`Bundle root not found or not a directory: ${ctx.bundleRoot}`);
   }
 }
@@ -4332,14 +4673,66 @@ var fetch_factory_default = defineStep({
     if (result.instructionsSnippet) {
       ctx.installed.factoryInstructionsSnippet = result.instructionsSnippet;
     }
+    const record = {
+      bundleName: "factory",
+      filesCreated: result.filesCreated,
+      filesPatched: result.filesPatched,
+      markerBlockFiles: result.markerBlockFiles
+    };
     if (!result.success) {
-      return { status: "failed", detail: result.failureReason };
+      return { status: "failed", detail: result.failureReason, record };
+    }
+    return { status: "success", message: result.filesInstalled.join(", "), record };
+  },
+  inverse: {
+    label: "Removing Factory framework",
+    execute: async (raw, ctx) => {
+      const rec = raw ?? {};
+      const bundle = rec.bundleName ?? "factory";
+      const projectPath = ctx.config.projectPath;
+      const summary = [];
+      for (const rel of rec.filesPatched ?? []) {
+        const abs = resolveProjectPath(rel, projectPath);
+        if (stripBundleOwnerFromJsonFile(abs, bundle)) summary.push(`stripped ${rel}`);
+        deleteJsonIfEffectivelyEmpty(abs);
+      }
+      for (const rel of rec.markerBlockFiles ?? []) {
+        const abs = resolveProjectPath(rel, projectPath);
+        if (rel === ".gitignore") {
+          removeMarkerBlock(abs, `# ${bundle}:start`, `# ${bundle}:end`);
+        } else {
+          removeMarkerBlock(abs, `<!-- ${bundle}:start -->`, `<!-- ${bundle}:end -->`);
+        }
+      }
+      const sortedCreated = [...rec.filesCreated ?? []].sort(
+        (a, b) => a.length - b.length
+      );
+      for (const rel of sortedCreated) {
+        const abs = resolveProjectPath(rel, projectPath);
+        if (!(0, import_fs9.existsSync)(abs)) continue;
+        if (isDirectorySafe(abs)) {
+          deleteDirIfExists(abs);
+          summary.push(`removed ${rel}`);
+        } else {
+          deleteFileIfExists(abs);
+          summary.push(`removed ${rel}`);
+        }
+      }
+      return {
+        status: "success",
+        message: summary.length > 0 ? `${summary.length} action(s)` : "nothing to remove"
+      };
     }
-    return { status: "success", message: result.filesInstalled.join(", ") };
   }
 });
 async function fetchFactory(token, repo, targetDir, agent) {
-  const result = { success: false, filesInstalled: [] };
+  const result = {
+    success: false,
+    filesInstalled: [],
+    filesCreated: [],
+    filesPatched: [],
+    markerBlockFiles: []
+  };
   let release;
   try {
     release = await fetchLatestRelease(token, repo);
@@ -4355,15 +4748,15 @@ async function fetchFactory(token, repo, targetDir, agent) {
   let archive = null;
   try {
     archive = await downloadAndExtractAsset(token, asset, targetDir, ".temp-factory-download");
-    const extractedEntries = (0, import_fs7.readdirSync)(archive.extractedRoot);
+    const extractedEntries = (0, import_fs9.readdirSync)(archive.extractedRoot);
     const extractedFolder = extractedEntries.find((e) => e.toLowerCase() === FACTORY_ROOT_FOLDER.toLowerCase());
     if (!extractedFolder) {
       result.failureReason = `No ${FACTORY_ROOT_FOLDER}/ folder in archive`;
       return result;
     }
-    const extractedPath = (0, import_path7.join)(archive.extractedRoot, extractedFolder);
-    const manifestPath = (0, import_path7.join)(extractedPath, "install.json");
-    if (!(0, import_fs7.existsSync)(manifestPath)) {
+    const extractedPath = (0, import_path9.join)(archive.extractedRoot, extractedFolder);
+    const manifestPath = (0, import_path9.join)(extractedPath, "install.json");
+    if (!(0, import_fs9.existsSync)(manifestPath)) {
       result.failureReason = "Factory archive has no install.json \u2014 upgrade Factory or downgrade installer";
       return result;
     }
@@ -4379,7 +4772,7 @@ async function fetchFactory(token, repo, targetDir, agent) {
 async function installViaBundle(manifestPath, extractedPath, targetDir, agent, result) {
   let manifest;
   try {
-    manifest = JSON.parse((0, import_fs7.readFileSync)(manifestPath, "utf-8"));
+    manifest = JSON.parse((0, import_fs9.readFileSync)(manifestPath, "utf-8"));
   } catch (e) {
     throw new Error(`install.json is not valid JSON: ${e instanceof Error ? e.message : String(e)}`);
   }
@@ -4394,11 +4787,14 @@ async function installViaBundle(manifestPath, extractedPath, targetDir, agent, r
   });
   result.instructionsSnippet = runResult.instructionsSnippet;
   result.filesInstalled = runResult.filesTouched;
+  result.filesCreated = runResult.filesCreated;
+  result.filesPatched = runResult.filesPatched;
+  result.markerBlockFiles = runResult.markerBlockFiles;
 }
 
 // src/steps/resources/fetch-abap-hooks.ts
-var import_fs8 = require("fs");
-var import_path8 = require("path");
+var import_fs10 = require("fs");
+var import_path10 = require("path");
 var HOOKS_ASSET_NAME = "sap-hooks.tar.gz";
 var HOOKS_TAG_PREFIX = "hooks-v";
 var HOOKS_ROOT_FOLDER = "hooks";
@@ -4466,14 +4862,58 @@ var fetch_abap_hooks_default = defineStep({
     if (result.instructionsSnippet) {
       ctx.installed.abapHooksInstructionsSnippet = result.instructionsSnippet;
     }
+    const record = {
+      bundleName: "abap-mcp-hooks",
+      filesCreated: result.filesCreated,
+      filesPatched: result.filesPatched,
+      markerBlockFiles: result.markerBlockFiles
+    };
     if (!result.success) {
-      return { status: "failed", detail: result.failureReason };
+      return { status: "failed", detail: result.failureReason, record };
+    }
+    return { status: "success", message: result.filesInstalled.join(", "), record };
+  },
+  inverse: {
+    label: "Removing ABAP MCP hooks",
+    execute: async (raw, ctx) => {
+      const rec = raw ?? {};
+      const bundle = rec.bundleName ?? "abap-mcp-hooks";
+      const projectPath = ctx.config.projectPath;
+      for (const rel of rec.filesPatched ?? []) {
+        const abs = resolveProjectPath(rel, projectPath);
+        stripBundleOwnerFromJsonFile(abs, bundle);
+        deleteJsonIfEffectivelyEmpty(abs);
+      }
+      for (const rel of rec.markerBlockFiles ?? []) {
+        const abs = resolveProjectPath(rel, projectPath);
+        if (rel === ".gitignore") {
+          removeMarkerBlock(abs, `# ${bundle}:start`, `# ${bundle}:end`);
+        } else {
+          removeMarkerBlock(abs, `<!-- ${bundle}:start -->`, `<!-- ${bundle}:end -->`);
+        }
+      }
+      for (const rel of rec.filesCreated ?? []) {
+        const abs = resolveProjectPath(rel, projectPath);
+        if (isDirectorySafe(abs)) deleteDirIfExists(abs);
+        else deleteFileIfExists(abs);
+      }
+      const firstScript = (rec.filesCreated ?? [])[0];
+      if (firstScript) {
+        const abs = resolveProjectPath(firstScript, projectPath);
+        pruneEmptyParents(abs, projectPath, 1);
+      }
+      return { status: "success" };
     }
-    return { status: "success", message: result.filesInstalled.join(", ") };
   }
 });
 async function fetchAbapHooks(token, repo, targetDir, agent) {
-  const result = { success: false, filesInstalled: [] };
+  const result = {
+    success: false,
+    filesInstalled: [],
+    filesCreated: [],
+    filesPatched: [],
+    markerBlockFiles: []
+  };
   let release;
   try {
     release = await fetchLatestReleaseByTagPrefix(token, repo, HOOKS_TAG_PREFIX);
@@ -4489,7 +4929,7 @@ async function fetchAbapHooks(token, repo, targetDir, agent) {
   let archive = null;
   try {
     archive = await downloadAndExtractAsset(token, asset, targetDir, ".temp-abap-hooks-download");
-    const extractedEntries = (0, import_fs8.readdirSync)(archive.extractedRoot);
+    const extractedEntries = (0, import_fs10.readdirSync)(archive.extractedRoot);
     const innerFolder = extractedEntries.find(
       (e) => e.toLowerCase() === HOOKS_ROOT_FOLDER.toLowerCase()
     );
@@ -4497,12 +4937,12 @@ async function fetchAbapHooks(token, repo, targetDir, agent) {
       result.failureReason = `No ${HOOKS_ROOT_FOLDER}/ folder in archive`;
       return result;
     }
-    const bundleRoot = (0, import_path8.join)(archive.extractedRoot, innerFolder);
-    if (!(0, import_fs8.statSync)(bundleRoot).isDirectory()) {
+    const bundleRoot = (0, import_path10.join)(archive.extractedRoot, innerFolder);
+    if (!(0, import_fs10.statSync)(bundleRoot).isDirectory()) {
       result.failureReason = `${HOOKS_ROOT_FOLDER}/ entry is not a directory`;
       return result;
     }
-    const presentDefs = HOOK_DEFINITIONS.filter((d) => (0, import_fs8.existsSync)((0, import_path8.join)(bundleRoot, d.script)));
+    const presentDefs = HOOK_DEFINITIONS.filter((d) => (0, import_fs10.existsSync)((0, import_path10.join)(bundleRoot, d.script)));
     if (presentDefs.length === 0) {
       result.failureReason = "Archive contains no recognized hook scripts";
       return result;
@@ -4542,6 +4982,9 @@ async function fetchAbapHooks(token, repo, targetDir, agent) {
       skipInstructions: true
     });
     result.filesInstalled = runResult.filesTouched;
+    result.filesCreated = runResult.filesCreated;
+    result.filesPatched = runResult.filesPatched;
+    result.markerBlockFiles = runResult.markerBlockFiles;
     result.instructionsSnippet = runResult.instructionsSnippet;
     result.success = true;
   } catch (error) {
@@ -4553,8 +4996,8 @@ async function fetchAbapHooks(token, repo, targetDir, agent) {
 }
 
 // src/steps/setup/write-instructions.ts
-var import_fs9 = require("fs");
-var import_path9 = require("path");
+var import_fs11 = require("fs");
+var import_path11 = require("path");
 
 // src/steps/shared.ts
 var cached = null;
@@ -4589,17 +5032,23 @@ var write_instructions_default = defineStep({
     const projectPath = ctx.config.projectPath;
     const content = buildCombinedInstructions(domains, filteredMcpConfig, agent, projectPath);
     const target = getAgentTarget(agent);
-    const filePath = (0, import_path9.join)(projectPath, target.instructions);
-    const fileDir = (0, import_path9.dirname)(filePath);
-    if (!(0, import_fs9.existsSync)(fileDir)) (0, import_fs9.mkdirSync)(fileDir, { recursive: true });
-    if (agent === "cursor" && !(0, import_fs9.existsSync)(filePath)) {
-      (0, import_fs9.writeFileSync)(filePath, `---
+    const filePath = (0, import_path11.join)(projectPath, target.instructions);
+    const fileDir = (0, import_path11.dirname)(filePath);
+    if (!(0, import_fs11.existsSync)(fileDir)) (0, import_fs11.mkdirSync)(fileDir, { recursive: true });
+    const fileExistedBefore = (0, import_fs11.existsSync)(filePath);
+    let cursorFrontmatterWritten = false;
+    if (agent === "cursor" && !fileExistedBefore) {
+      (0, import_fs11.writeFileSync)(filePath, `---
 description: AI development instructions from One-Shot Installer
 alwaysApply: true
 ---
 
 `, "utf-8");
+      cursorFrontmatterWritten = true;
     }
+    const markerBlocks = [
+      { start: MARKER_START, end: MARKER_END }
+    ];
     upsertMarkerBlock(filePath, MARKER_START, MARKER_END, content, {
       onCorrupt: (file) => {
         const fileName = file.split(/[/\\]/).pop() ?? file;
@@ -4627,6 +5076,7 @@ alwaysApply: true
         "<!-- factory:end -->",
         ctx.installed.factoryInstructionsSnippet
       );
+      markerBlocks.push({ start: "<!-- factory:start -->", end: "<!-- factory:end -->" });
     }
     if (ctx.installed.abapHooksInstructionsSnippet) {
       upsertMarkerBlock(
@@ -4635,21 +5085,50 @@ alwaysApply: true
         "<!-- abap-mcp-hooks:end -->",
         ctx.installed.abapHooksInstructionsSnippet
       );
+      markerBlocks.push({ start: "<!-- abap-mcp-hooks:start -->", end: "<!-- abap-mcp-hooks:end -->" });
+    }
+    const record = {
+      filePath: target.instructions,
+      markerBlocks,
+      fileExistedBefore,
+      cursorFrontmatterWritten
+    };
+    return { status: "success", message: target.instructions, record };
+  },
+  inverse: {
+    label: "Restoring instructions file",
+    execute: async (raw, ctx) => {
+      const rec = raw ?? {};
+      if (!rec.filePath) return { status: "skipped", detail: "no file recorded" };
+      const abs = resolveProjectPath(rec.filePath, ctx.config.projectPath);
+      const blocks = rec.markerBlocks ?? [];
+      const cursorPreambleRe = /^---[\s\S]*?---\s*/;
+      for (let i = 0; i < blocks.length; i++) {
+        const b = blocks[i];
+        const isLast = i === blocks.length - 1;
+        removeMarkerBlock(abs, b.start, b.end, {
+          /* Only attempt to delete the file after the LAST block is
+           * removed — if we delete on the first pass we'd lose later
+           * blocks waiting in the same file. */
+          deleteFileIfEmpty: isLast && !rec.fileExistedBefore,
+          emptyIgnorePattern: rec.cursorFrontmatterWritten ? cursorPreambleRe : void 0
+        });
+      }
+      return { status: "success", message: rec.filePath };
     }
-    return { status: "success", message: target.instructions };
   }
 });
 function collectMdFiles(dir) {
-  if (!(0, import_fs9.existsSync)(dir)) return [];
-  const entries = (0, import_fs9.readdirSync)(dir, { recursive: true });
+  if (!(0, import_fs11.existsSync)(dir)) return [];
+  const entries = (0, import_fs11.readdirSync)(dir, { recursive: true });
   return entries.filter((entry) => {
-    const fullPath = (0, import_path9.join)(dir, entry);
-    return entry.endsWith(".md") && (0, import_fs9.statSync)(fullPath).isFile();
+    const fullPath = (0, import_path11.join)(dir, entry);
+    return entry.endsWith(".md") && (0, import_fs11.statSync)(fullPath).isFile();
   }).map((entry) => entry.replace(/\\/g, "/")).sort();
 }
 function extractFirstHeading(filePath) {
   try {
-    const content = (0, import_fs9.readFileSync)(filePath, "utf-8");
+    const content = (0, import_fs11.readFileSync)(filePath, "utf-8");
     const withoutFrontmatter = content.replace(/^---[\s\S]*?---\s*/, "");
     const match = withoutFrontmatter.match(/^#\s+(.+)/m);
     if (match) {
@@ -4667,16 +5146,16 @@ function formatPathRef(contextPath, description, agent) {
   return `- \`${contextPath}\` \u2014 ${description}`;
 }
 function resolveDomainFolder(domain, contextsDir) {
-  if ((0, import_fs9.existsSync)(contextsDir)) {
+  if ((0, import_fs11.existsSync)(contextsDir)) {
     try {
-      const entries = (0, import_fs9.readdirSync)(contextsDir);
+      const entries = (0, import_fs11.readdirSync)(contextsDir);
       const match = entries.find((e) => e.toLowerCase() === domain.toLowerCase());
-      if (match) return { folderName: match, folderPath: (0, import_path9.join)(contextsDir, match) };
+      if (match) return { folderName: match, folderPath: (0, import_path11.join)(contextsDir, match) };
     } catch {
     }
   }
   const fallback = domain.toUpperCase();
-  return { folderName: fallback, folderPath: (0, import_path9.join)(contextsDir, fallback) };
+  return { folderName: fallback, folderPath: (0, import_path11.join)(contextsDir, fallback) };
 }
 function buildContextRefsSection(domains, agent, contextsDir) {
   const lines2 = [
@@ -4688,34 +5167,34 @@ function buildContextRefsSection(domains, agent, contextsDir) {
   let hasAnyFiles = false;
   for (const domain of domains) {
     const { folderName, folderPath: domainPath } = resolveDomainFolder(domain, contextsDir);
-    if (!(0, import_fs9.existsSync)(domainPath)) continue;
+    if (!(0, import_fs11.existsSync)(domainPath)) continue;
     const domainFiles = [];
-    const ctxInstructions = (0, import_path9.join)(domainPath, "context-instructions.md");
-    if ((0, import_fs9.existsSync)(ctxInstructions)) {
+    const ctxInstructions = (0, import_path11.join)(domainPath, "context-instructions.md");
+    if ((0, import_fs11.existsSync)(ctxInstructions)) {
       const desc = extractFirstHeading(ctxInstructions);
       domainFiles.push(formatPathRef(`_ai-context/${folderName}/context-instructions.md`, desc, agent));
     }
-    const instructionsMd = (0, import_path9.join)(domainPath, "core", "instructions.md");
-    if ((0, import_fs9.existsSync)(instructionsMd)) {
+    const instructionsMd = (0, import_path11.join)(domainPath, "core", "instructions.md");
+    if ((0, import_fs11.existsSync)(instructionsMd)) {
       const desc = extractFirstHeading(instructionsMd);
       domainFiles.push(formatPathRef(`_ai-context/${folderName}/core/instructions.md`, `${desc} (start here)`, agent));
     }
-    const coreDir = (0, import_path9.join)(domainPath, "core");
-    if ((0, import_fs9.existsSync)(coreDir)) {
+    const coreDir = (0, import_path11.join)(domainPath, "core");
+    if ((0, import_fs11.existsSync)(coreDir)) {
       const coreFiles = collectMdFiles(coreDir).filter((f) => f !== "instructions.md" && !f.startsWith("instructions/"));
       for (const file of coreFiles) {
-        const desc = extractFirstHeading((0, import_path9.join)(coreDir, file));
+        const desc = extractFirstHeading((0, import_path11.join)(coreDir, file));
         domainFiles.push(formatPathRef(`_ai-context/${folderName}/core/${file}`, desc, agent));
       }
     }
-    const refDir = (0, import_path9.join)(domainPath, "reference");
-    if ((0, import_fs9.existsSync)(refDir)) {
+    const refDir = (0, import_path11.join)(domainPath, "reference");
+    if ((0, import_fs11.existsSync)(refDir)) {
       const refFiles = collectMdFiles(refDir);
       if (refFiles.length > 0) {
         domainFiles.push(``);
         domainFiles.push(`**Reference & cheat sheets:**`);
         for (const file of refFiles) {
-          const desc = extractFirstHeading((0, import_path9.join)(refDir, file));
+          const desc = extractFirstHeading((0, import_path11.join)(refDir, file));
           domainFiles.push(formatPathRef(`_ai-context/${folderName}/reference/${file}`, desc, agent));
         }
       }
@@ -4746,7 +5225,7 @@ function buildMCPSection(mcpConfig) {
   return lines2.join("\n");
 }
 function buildCombinedInstructions(domains, mcpConfig, agent, projectPath) {
-  const contextsDir = (0, import_path9.join)(projectPath, "_ai-context");
+  const contextsDir = (0, import_path11.join)(projectPath, "_ai-context");
   const lines2 = [`# AI Development Instructions`, ``, `> Generated by One-Shot Installer`, ``];
   lines2.push(buildContextRefsSection(domains, agent, contextsDir));
   if (Object.keys(mcpConfig).length > 0) lines2.push(buildMCPSection(mcpConfig));
@@ -4754,8 +5233,8 @@ function buildCombinedInstructions(domains, mcpConfig, agent, projectPath) {
 }
 
 // src/steps/setup/write-mcp-config.ts
-var import_fs10 = require("fs");
-var import_path10 = require("path");
+var import_fs12 = require("fs");
+var import_path12 = require("path");
 var red2 = (text) => `\x1B[31m${text}\x1B[0m`;
 var write_mcp_config_default = defineStep({
   name: "write-mcp-config",
@@ -4764,15 +5243,16 @@ var write_mcp_config_default = defineStep({
   execute: async (ctx) => {
     const filteredMcpConfig = getFilteredMcpConfig(ctx);
     const target = getAgentTarget(ctx.config.agent);
-    const mcpJsonPath = (0, import_path10.join)(ctx.config.projectPath, target.mcpConfig);
+    const mcpJsonPath = (0, import_path12.join)(ctx.config.projectPath, target.mcpConfig);
+    const fileExistedBefore = (0, import_fs12.existsSync)(mcpJsonPath);
     if (target.mcpDir) {
-      const dir = (0, import_path10.join)(ctx.config.projectPath, target.mcpDir);
-      if (!(0, import_fs10.existsSync)(dir)) (0, import_fs10.mkdirSync)(dir, { recursive: true });
+      const dir = (0, import_path12.join)(ctx.config.projectPath, target.mcpDir);
+      if (!(0, import_fs12.existsSync)(dir)) (0, import_fs12.mkdirSync)(dir, { recursive: true });
     }
     let existingFile = {};
-    if ((0, import_fs10.existsSync)(mcpJsonPath)) {
+    if ((0, import_fs12.existsSync)(mcpJsonPath)) {
       try {
-        existingFile = JSON.parse((0, import_fs10.readFileSync)(mcpJsonPath, "utf-8"));
+        existingFile = JSON.parse((0, import_fs12.readFileSync)(mcpJsonPath, "utf-8"));
       } catch {
         const box = [
           "",
@@ -4798,12 +5278,35 @@ var write_mcp_config_default = defineStep({
     }
     const mergedServers = { ...existingServers, ...newServers };
     const outputFile = { ...existingFile, [target.mcpRootKey]: mergedServers };
-    (0, import_fs10.writeFileSync)(mcpJsonPath, JSON.stringify(outputFile, null, 2), "utf-8");
+    (0, import_fs12.writeFileSync)(mcpJsonPath, JSON.stringify(outputFile, null, 2), "utf-8");
     ctx.installed.mcpServersAdded = addedServers;
+    const record = {
+      filePath: target.mcpConfig,
+      rootKey: target.mcpRootKey,
+      serversAdded: addedServers,
+      fileExistedBefore
+    };
     return {
       status: "success",
-      message: addedServers.length > 0 ? addedServers.join(", ") : void 0
+      message: addedServers.length > 0 ? addedServers.join(", ") : void 0,
+      record
     };
+  },
+  inverse: {
+    label: "Restoring MCP configuration",
+    execute: async (raw, ctx) => {
+      const rec = raw ?? {};
+      if (!rec.filePath || !rec.rootKey) return { status: "skipped" };
+      const abs = resolveProjectPath(rec.filePath, ctx.config.projectPath);
+      const { changed, rootEmpty } = stripMcpServers(abs, rec.rootKey, rec.serversAdded ?? []);
+      if (rootEmpty && !rec.fileExistedBefore) {
+        deleteFileIfExists(abs);
+      }
+      return {
+        status: "success",
+        message: changed ? rec.filePath : "no changes needed"
+      };
+    }
   }
 });
 
@@ -4844,21 +5347,54 @@ var run_mcp_install_commands_default = defineStep({
         failed.push({ name, reason });
       }
     }
+    const record = { registeredServers: succeeded };
     if (failed.length === 0) {
       return {
         status: "success",
-        message: succeeded.length > 0 ? succeeded.join(", ") : void 0
+        message: succeeded.length > 0 ? succeeded.join(", ") : void 0,
+        record
       };
     }
     const failedSummary = failed.map((f) => `${f.name} (${f.reason})`).join("; ");
     if (succeeded.length === 0) {
-      return { status: "failed", detail: failedSummary };
+      return { status: "failed", detail: failedSummary, record };
     }
     return {
       status: "success",
       message: `${succeeded.join(", ")}; failed: ${failed.map((f) => f.name).join(", ")}`,
-      detail: `Some registrations failed: ${failedSummary}`
+      detail: `Some registrations failed: ${failedSummary}`,
+      record
     };
+  },
+  inverse: {
+    label: "Unregistering MCP servers from Claude Code",
+    execute: async (raw) => {
+      const rec = raw ?? {};
+      const servers = rec.registeredServers ?? [];
+      if (servers.length === 0) return { status: "skipped", detail: "nothing was registered" };
+      if (!isClaudeCliAvailable()) {
+        return {
+          status: "skipped",
+          detail: "`claude` CLI not found \u2014 leftover global registrations: " + servers.join(", ")
+        };
+      }
+      const removed = [];
+      const failed = [];
+      for (const name of servers) {
+        const r = (0, import_child_process3.spawnSync)(`claude mcp remove ${name}`, {
+          shell: true,
+          stdio: "pipe",
+          encoding: "utf-8"
+        });
+        if (r.status === 0) removed.push(name);
+        else failed.push(name);
+      }
+      return {
+        status: "success",
+        message: removed.length > 0 ? removed.join(", ") : "none",
+        ...failed.length > 0 ? { detail: `also tried (already removed?): ${failed.join(", ")}` } : {}
+      };
+    }
   }
 });
 function isClaudeCliAvailable() {
@@ -4867,7 +5403,8 @@ function isClaudeCliAvailable() {
 }
 
 // src/steps/setup/update-gitignore.ts
-var import_path11 = require("path");
+var import_fs13 = require("fs");
+var import_path13 = require("path");
 var MARKER_START2 = "# one-shot-installer:start";
 var MARKER_END2 = "# one-shot-installer:end";
 var CORE_GITIGNORE_ENTRIES = [
@@ -4888,15 +5425,37 @@ var update_gitignore_default = defineStep({
   name: "update-gitignore",
   label: "Updating .gitignore",
   execute: async (ctx) => {
-    const gitignorePath = (0, import_path11.join)(ctx.config.projectPath, ".gitignore");
+    const gitignorePath = (0, import_path13.join)(ctx.config.projectPath, ".gitignore");
+    const fileExistedBefore = (0, import_fs13.existsSync)(gitignorePath);
     upsertMarkerBlock(gitignorePath, MARKER_START2, MARKER_END2, CORE_GITIGNORE_ENTRIES.join("\n"));
-    return { status: "success" };
+    const record = {
+      filePath: ".gitignore",
+      start: MARKER_START2,
+      end: MARKER_END2,
+      fileExistedBefore
+    };
+    return { status: "success", record };
+  },
+  inverse: {
+    label: "Restoring .gitignore",
+    execute: async (raw, ctx) => {
+      const rec = raw ?? {};
+      const filePath = rec.filePath ?? ".gitignore";
+      const abs = resolveProjectPath(filePath, ctx.config.projectPath);
+      removeMarkerBlock(
+        abs,
+        rec.start ?? MARKER_START2,
+        rec.end ?? MARKER_END2,
+        { deleteFileIfEmpty: !rec.fileExistedBefore }
+      );
+      return { status: "success" };
+    }
   }
 });
 
 // src/steps/setup/write-state.ts
-var import_fs11 = require("fs");
-var import_path12 = require("path");
+var import_fs14 = require("fs");
+var import_path14 = require("path");
 var import_os2 = require("os");
 
 // package.json
@@ -4930,7 +5489,7 @@ var write_state_default = defineStep({
   name: "write-state",
   label: "Saving installation state",
   execute: async (ctx) => {
-    const statePath = (0, import_path12.join)(ctx.config.projectPath, ".one-shot-state.json");
+    const statePath = (0, import_path14.join)(ctx.config.projectPath, ".one-shot-state.json");
     const mcpServersAdded = ctx.installed.mcpServersAdded ?? [];
     const filteredMcpConfig = Object.fromEntries(
       Object.entries(ctx.config.mcpConfig).filter(([name]) => mcpServersAdded.includes(name))
@@ -4955,45 +5514,233 @@ var write_state_default = defineStep({
         contexts: "_ai-context/",
         factory: ctx.installed.factoryInstalled ? "factory/" : null,
         abapHooks: ctx.installed.abapHooksInstalled ? ".claude/hooks/" : null,
-        globalConfig: (0, import_path12.join)((0, import_os2.homedir)(), ".one-shot-installer")
+        globalConfig: (0, import_path14.join)((0, import_os2.homedir)(), ".one-shot-installer")
       }
     };
-    (0, import_fs11.writeFileSync)(statePath, JSON.stringify(state, null, 2), "utf-8");
+    if (ctx.journal) {
+      ctx.journal.setSummary(state);
+    } else {
+      (0, import_fs14.writeFileSync)(statePath, JSON.stringify(state, null, 2), "utf-8");
+    }
     return { status: "success" };
+  },
+  inverse: {
+    label: "Clearing installation state",
+    /* No-op during journal walk. The journal IS the state file, so
+     * deleting it here would yank the rug from under runRollback's
+     * own iteration. The uninstall orchestrator deletes the file as
+     * the FINAL action, after all other inverses have completed. */
+    execute: async () => ({ status: "skipped", detail: "handled by uninstall orchestrator" })
   }
 });
 
+// src/uninstall.ts
+var import_fs15 = require("fs");
+var import_readline = require("readline");
+var import_path15 = require("path");
+var dim = (text) => `\x1B[2m${text}\x1B[0m`;
+var yellow = (text) => `\x1B[33m${text}\x1B[0m`;
+var red3 = (text) => `\x1B[31m${text}\x1B[0m`;
+var green = (text) => `\x1B[32m${text}\x1B[0m`;
+function waitForEnter() {
+  const rl = (0, import_readline.createInterface)({ input: process.stdin, output: process.stdout });
+  return new Promise((resolve6) => {
+    rl.question("  Press Enter to close...", () => {
+      rl.close();
+      resolve6();
+    });
+  });
+}
+async function uninstall() {
+  console.clear();
+  console.log("One-Shot Setup Uninstaller\n");
+  try {
+    const projectInput = await esm_default4({
+      message: "Project directory to uninstall from:",
+      default: (0, import_path15.resolve)(process.cwd())
+    });
+    const projectPath = (0, import_path15.resolve)(projectInput);
+    const statePath = (0, import_path15.join)(projectPath, ".one-shot-state.json");
+    if (!(0, import_fs15.existsSync)(statePath)) {
+      console.log("");
+      console.log(red3("  No .one-shot-state.json found at:"));
+      console.log(`    ${statePath}`);
+      console.log("");
+      console.log(dim("  Nothing to uninstall \u2014 either this directory is not an installer"));
+      console.log(dim("  target, or the state file has already been removed."));
+      console.log("");
+      await waitForEnter();
+      return;
+    }
+    const journal = new Journal(statePath);
+    journal.load();
+    const entries = journal.getEntries();
+    if (entries.length === 0) {
+      console.log("");
+      console.log(yellow("  State file found, but its rollback journal is empty."));
+      console.log(dim("  This file was likely written by an older installer version that"));
+      console.log(dim("  did not yet emit a journal. Manual cleanup is required."));
+      console.log("");
+      const proceed2 = await esm_default3({
+        message: "Delete the state file anyway?",
+        default: false
+      });
+      if (proceed2) {
+        (0, import_fs15.unlinkSync)(statePath);
+        console.log("  Removed .one-shot-state.json");
+      }
+      await waitForEnter();
+      return;
+    }
+    const summary = readSummary(statePath);
+    printPreview(projectPath, summary, entries.length);
+    const proceed = await esm_default3({
+      message: "Proceed with uninstall?",
+      default: false
+    });
+    if (!proceed) {
+      console.log("\nNo changes made.");
+      await waitForEnter();
+      return;
+    }
+    const ctx = {
+      config: {
+        technologies: [],
+        agent: typeof summary?.agent === "string" ? summary.agent : "claude-code",
+        azureDevOpsOrg: "",
+        projectPath,
+        baseMcpServers: [],
+        mcpConfig: {},
+        releaseVersion: "",
+        installFactory: false,
+        installAbapHooks: false
+      },
+      token: "",
+      repo: "",
+      contextRepo: null,
+      factoryRepo: null,
+      abapHooksRepo: null,
+      installed: {},
+      journal
+    };
+    const stepList = Object.values(steps_exports);
+    console.log("");
+    const result = await runRollback(stepList, ctx);
+    try {
+      if ((0, import_fs15.existsSync)(statePath)) (0, import_fs15.unlinkSync)(statePath);
+    } catch {
+    }
+    printSummary(result);
+    await waitForEnter();
+  } catch (error) {
+    console.error("\n[ERROR]", error instanceof Error ? error.message : String(error));
+    await waitForEnter();
+  }
+}
+function readSummary(statePath) {
+  try {
+    const raw = JSON.parse((0, import_fs15.readFileSync)(statePath, "utf-8"));
+    return raw;
+  } catch {
+    return {};
+  }
+}
+function asArray(v) {
+  return Array.isArray(v) ? v.filter((s) => typeof s === "string") : [];
+}
+function printPreview(projectPath, summary, entryCount) {
+  const agent = typeof summary.agent === "string" ? summary.agent : "unknown";
+  const domains = asArray(summary.domains);
+  const mcpServers = asArray(summary.mcpServers);
+  const factoryInstalled = summary.factoryInstalled === true;
+  const abapHooksInstalled = summary.abapHooksInstalled === true;
+  const files = summary.files ?? {};
+  console.log("\n" + "\u2500".repeat(48));
+  console.log("  Ready to uninstall");
+  console.log("\u2500".repeat(48) + "\n");
+  console.log(`  Directory    ${projectPath}`);
+  console.log(`  Agent        ${agent}`);
+  console.log(`  Journal      ${entryCount} recorded step(s)`);
+  console.log("");
+  console.log(`  ${dim("Will remove:")}`);
+  if (domains.length > 0) {
+    console.log(`    _ai-context/    ${yellow(domains.join(", "))}`);
+  }
+  if (factoryInstalled && typeof files.factory === "string") {
+    console.log(`    ${files.factory.padEnd(16)}${yellow("remove")}`);
+  }
+  if (abapHooksInstalled && typeof files.abapHooks === "string") {
+    console.log(`    ${files.abapHooks.padEnd(16)}${yellow("strip our scripts")}`);
+  }
+  if (typeof files.instructions === "string") {
+    console.log(`    ${files.instructions.padEnd(16)}${yellow("remove our markers")}`);
+  }
+  if (typeof files.mcpConfig === "string" && mcpServers.length > 0) {
+    console.log(`    ${files.mcpConfig.padEnd(16)}${yellow(`remove ${mcpServers.length} server(s)`)}`);
+  }
+  console.log(`    ${".gitignore".padEnd(16)}${yellow("remove our markers")}`);
+  console.log(`    ${".one-shot-state.json".padEnd(16)}${yellow("delete")}`);
+  if (mcpServers.length > 0) {
+    console.log("");
+    console.log(`  ${dim("MCP servers being removed:")}`);
+    console.log(`    ${mcpServers.join(", ")}`);
+  }
+  console.log("\n" + dim("  User-edited files outside our marker blocks will be preserved."));
+  console.log(dim("  Files we created from scratch will be deleted; files we modified"));
+  console.log(dim("  will have only our changes stripped."));
+  console.log("\n" + "\u2500".repeat(48));
+}
+function printSummary(result) {
+  const failed = result.entries.filter((e) => e.result.status === "failed");
+  const succeeded = result.entries.filter((e) => e.result.status === "success");
+  const skipped = result.entries.filter((e) => e.result.status === "skipped");
+  console.log("\u2500".repeat(48));
+  console.log(failed.length > 0 ? "  Done (with errors).\n" : "  Done.\n");
+  for (const entry of succeeded) {
+    const msg = entry.result.message ? `  ${dim(entry.result.message)}` : "";
+    console.log(`  ${green("\u2713")} ${entry.label}${msg}`);
+  }
+  for (const entry of skipped) {
+    const detail = entry.result.detail ? `  ${dim(entry.result.detail)}` : "";
+    console.log(`  ${dim("\u2014")} ${entry.label}${detail}`);
+  }
+  for (const entry of failed) {
+    console.log(`  ${red3("\u2717")} ${entry.label}: ${entry.result.detail ?? "unknown"}`);
+  }
+  console.log("\n" + "\u2500".repeat(48) + "\n");
+}
+
 // src/index.ts
 function formatMCPCommand(server) {
   if (server.url) return server.url;
   if (server.command) return `${server.command} ${(server.args ?? []).join(" ")}`.trimEnd();
   return "";
 }
-var dim = (text) => `\x1B[2m${text}\x1B[0m`;
-var yellow = (text) => `\x1B[33m${text}\x1B[0m`;
-var green = (text) => `\x1B[32m${text}\x1B[0m`;
+var dim2 = (text) => `\x1B[2m${text}\x1B[0m`;
+var yellow2 = (text) => `\x1B[33m${text}\x1B[0m`;
+var green2 = (text) => `\x1B[32m${text}\x1B[0m`;
 function detectMarkerFileMode(filePath, markerStart) {
-  if (!(0, import_fs12.existsSync)(filePath)) return green("create");
-  const content = (0, import_fs12.readFileSync)(filePath, "utf-8");
-  if (content.includes(markerStart)) return yellow("update");
-  return yellow("append");
+  if (!(0, import_fs16.existsSync)(filePath)) return green2("create");
+  const content = (0, import_fs16.readFileSync)(filePath, "utf-8");
+  if (content.includes(markerStart)) return yellow2("update");
+  return yellow2("append");
 }
 function detectMCPFileMode(filePath) {
-  if (!(0, import_fs12.existsSync)(filePath)) return green("create");
-  return yellow("merge");
+  if (!(0, import_fs16.existsSync)(filePath)) return green2("create");
+  return yellow2("merge");
 }
 function detectContextMode(projectPath, domain) {
-  const contextDir = (0, import_path13.join)(projectPath, "_ai-context", domain.toUpperCase());
-  const contextDirLower = (0, import_path13.join)(projectPath, "_ai-context", domain);
-  if ((0, import_fs12.existsSync)(contextDir) || (0, import_fs12.existsSync)(contextDirLower)) return yellow("overwrite");
-  return green("create");
+  const contextDir = (0, import_path16.join)(projectPath, "_ai-context", domain.toUpperCase());
+  const contextDirLower = (0, import_path16.join)(projectPath, "_ai-context", domain);
+  if ((0, import_fs16.existsSync)(contextDir) || (0, import_fs16.existsSync)(contextDirLower)) return yellow2("overwrite");
+  return green2("create");
 }
-function waitForEnter() {
-  const rl = (0, import_readline.createInterface)({ input: process.stdin, output: process.stdout });
-  return new Promise((resolve4) => {
+function waitForEnter2() {
+  const rl = (0, import_readline2.createInterface)({ input: process.stdin, output: process.stdout });
+  return new Promise((resolve6) => {
     rl.question("  Press Enter to close...", () => {
       rl.close();
-      resolve4();
+      resolve6();
     });
   });
 }
@@ -5022,15 +5769,18 @@ async function main() {
     const options = await loadWizardOptions(token, repo);
     const config = await collectInputs(options, options.releaseVersion, !!factoryRepo, !!abapHooksRepo);
     if (!config) {
-      await waitForEnter();
+      await waitForEnter2();
       return;
     }
     const proceed = await previewAndConfirm(config, options);
     if (!proceed) {
       console.log("\nNo changes made.");
-      await waitForEnter();
+      await waitForEnter2();
       return;
     }
+    const statePath = (0, import_path16.join)(config.projectPath, ".one-shot-state.json");
+    const journal = new Journal(statePath);
+    journal.startFresh();
     const ctx = {
       config,
       token,
@@ -5038,16 +5788,17 @@ async function main() {
       contextRepo,
       factoryRepo,
       abapHooksRepo,
-      installed: {}
+      installed: {},
+      journal
     };
     const stepList = Object.values(steps_exports);
     console.log("");
     const result = await runPipeline(stepList, ctx);
-    printSummary(result, config);
+    printSummary2(result, config);
     return;
   } catch (error) {
     console.error("\n[ERROR]", error instanceof Error ? error.message : String(error));
-    await waitForEnter();
+    await waitForEnter2();
   }
 }
 async function collectInputs(options, releaseVersion, factoryAvailable = false, abapHooksAvailable = false) {
@@ -5090,7 +5841,7 @@ async function collectInputs(options, releaseVersion, factoryAvailable = false,
   }
   const projectInput = await esm_default4({
     message: "Project directory:",
-    default: (0, import_path13.resolve)(process.cwd())
+    default: (0, import_path16.resolve)(process.cwd())
   });
   const isAbapSelected = selectedTechnologies.some((t) => t.domains.includes("ABAP"));
   const installAbapHooks = abapHooksAvailable && agent === "claude-code" && isAbapSelected;
@@ -5098,7 +5849,7 @@ async function collectInputs(options, releaseVersion, factoryAvailable = false,
     technologies: selectedTechnologies,
     agent,
     azureDevOpsOrg,
-    projectPath: (0, import_path13.resolve)(projectInput),
+    projectPath: (0, import_path16.resolve)(projectInput),
     baseMcpServers: options.baseMcpServers,
     mcpConfig,
     releaseVersion,
@@ -5113,9 +5864,9 @@ async function previewAndConfirm(config, options) {
   const instructionFile = target.instructions;
   const mcpConfigFile = target.mcpConfig;
   const serverEntries = Object.entries(config.mcpConfig);
-  const instructionFilePath = (0, import_path13.join)(config.projectPath, instructionFile);
-  const mcpConfigFilePath = (0, import_path13.join)(config.projectPath, mcpConfigFile);
-  const gitignorePath = (0, import_path13.join)(config.projectPath, ".gitignore");
+  const instructionFilePath = (0, import_path16.join)(config.projectPath, instructionFile);
+  const mcpConfigFilePath = (0, import_path16.join)(config.projectPath, mcpConfigFile);
+  const gitignorePath = (0, import_path16.join)(config.projectPath, ".gitignore");
   const instructionMode = detectMarkerFileMode(instructionFilePath, "<!-- one-shot-installer:start -->");
   const mcpMode = detectMCPFileMode(mcpConfigFilePath);
   const gitignoreMode = detectMarkerFileMode(gitignorePath, "# one-shot-installer:start");
@@ -5133,7 +5884,7 @@ async function previewAndConfirm(config, options) {
   console.log(`  ABAP hooks   ${config.installAbapHooks ? "yes" : "no"}`);
   console.log(`  Directory    ${config.projectPath}`);
   console.log("");
-  console.log(`  ${dim("File actions:")}`);
+  console.log(`  ${dim2("File actions:")}`);
   const domainColWidth = Math.max(...domainModes.map((d) => d.domain.length), 6) + 2;
   for (const { domain, mode } of domainModes) {
     console.log(`    _ai-context/${domain.padEnd(domainColWidth)}${mode}`);
@@ -5142,18 +5893,18 @@ async function previewAndConfirm(config, options) {
   console.log(`    ${mcpConfigFile.padEnd(domainColWidth + 14)}${mcpMode}`);
   console.log(`    ${".gitignore".padEnd(domainColWidth + 14)}${gitignoreMode}`);
   if (config.installFactory) {
-    const factoryExists = (0, import_fs12.existsSync)((0, import_path13.join)(config.projectPath, "factory"));
-    const factoryMode = factoryExists ? yellow("overwrite") : green("create");
+    const factoryExists = (0, import_fs16.existsSync)((0, import_path16.join)(config.projectPath, "factory"));
+    const factoryMode = factoryExists ? yellow2("overwrite") : green2("create");
     console.log(`    ${"factory/".padEnd(domainColWidth + 14)}${factoryMode}`);
   }
   if (config.installAbapHooks) {
-    const hooksDir = (0, import_path13.join)(config.projectPath, ".claude", "hooks");
-    const hooksMode = (0, import_fs12.existsSync)(hooksDir) ? yellow("merge") : green("create");
+    const hooksDir = (0, import_path16.join)(config.projectPath, ".claude", "hooks");
+    const hooksMode = (0, import_fs16.existsSync)(hooksDir) ? yellow2("merge") : green2("create");
     console.log(`    ${".claude/hooks/".padEnd(domainColWidth + 14)}${hooksMode}`);
   }
   if (serverEntries.length > 0) {
     console.log("");
-    console.log(`  ${dim("MCP servers:")}`);
+    console.log(`  ${dim2("MCP servers:")}`);
     const maxLen = Math.max(...serverEntries.map(([name]) => name.length));
     for (const [name, server] of serverEntries) {
       const cmd = formatMCPCommand(server);
@@ -5163,7 +5914,7 @@ async function previewAndConfirm(config, options) {
   console.log("\n" + "\u2500".repeat(48));
   return esm_default3({ message: "Proceed?", default: true });
 }
-function printSummary(result, config) {
+function printSummary2(result, config) {
   const failed = result.entries.filter((e) => e.result.status === "failed");
   const succeeded = result.entries.filter((e) => e.result.status === "success");
   const skipped = result.entries.filter((e) => e.result.status === "skipped");
@@ -5191,7 +5942,34 @@ function printSummary(result, config) {
   }
   console.log("\n" + "\u2500".repeat(48) + "\n");
 }
-main().catch((error) => {
+function printHelp() {
+  console.log("");
+  console.log("Usage:");
+  console.log("  npx dlw-machine-setup            Install the toolchain (wizard).");
+  console.log("  npx dlw-machine-setup uninstall  Remove a previous install (wizard).");
+  console.log("  npx dlw-machine-setup --help     Show this help.");
+  console.log("");
+}
+async function dispatch() {
+  const subcommand = process.argv[2];
+  switch (subcommand) {
+    case void 0:
+    case "":
+      return main();
+    case "uninstall":
+      return uninstall();
+    case "help":
+    case "--help":
+    case "-h":
+      printHelp();
+      return;
+    default:
+      console.error(`Unknown subcommand: ${subcommand}`);
+      printHelp();
+      process.exit(1);
+  }
+}
+dispatch().catch((error) => {
   console.error("\n[ERROR]", error instanceof Error ? error.message : String(error));
   process.exit(1);
 });