dlw-machine-setup 0.5.17 → 0.6.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 resolve5;
     let reject;
     const promise = new Promise((res, rej) => {
-      resolve4 = res;
+      resolve5 = res;
       reject = rej;
     });
-    return { promise, resolve: resolve4, reject };
+    return { promise, resolve: resolve5, reject };
   }
 };
 
@@ -2776,7 +2776,7 @@ function createPrompt(view) {
       output
     });
     const screen = new ScreenManager(rl);
-    const { promise, resolve: resolve4, reject } = PromisePolyfill.withResolver();
+    const { promise, resolve: resolve5, 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(() => resolve5(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_fs8 = require("fs");
+var import_fs9 = require("fs");
 var import_readline = require("readline");
-var import_path8 = require("path");
+var import_path9 = require("path");
 
 // src/utils/fetch.ts
 var DEFAULT_TIMEOUT_MS = 3e4;
@@ -3283,7 +3283,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((resolve5) => setTimeout(resolve5, delay));
     }
   }
   throw lastError || new Error("Failed after maximum retries");
@@ -3451,7 +3451,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((resolve5) => setTimeout(resolve5, interval * 1e3));
     const response = await fetchWithTimeout(GITHUB_TOKEN_URL, {
       method: "POST",
       headers: {
@@ -3577,6 +3577,31 @@ function buildMCPConfiguration(selectedItems, baseMcpServers, allMcpServers) {
   return config;
 }
 
+// src/utils/agent-targets.ts
+var AGENT_TARGETS = {
+  "claude-code": {
+    instructions: "CLAUDE.md",
+    mcpConfig: ".mcp.json",
+    mcpRootKey: "mcpServers",
+    mcpDir: null
+  },
+  "github-copilot": {
+    instructions: ".github/copilot-instructions.md",
+    mcpConfig: ".vscode/mcp.json",
+    mcpRootKey: "servers",
+    mcpDir: ".vscode"
+  },
+  "cursor": {
+    instructions: ".cursor/rules/instructions.mdc",
+    mcpConfig: ".cursor/mcp.json",
+    mcpRootKey: "mcpServers",
+    mcpDir: ".cursor"
+  }
+};
+function getAgentTarget(agent) {
+  return AGENT_TARGETS[agent] ?? AGENT_TARGETS["claude-code"];
+}
+
 // src/utils/mod.ts
 async function loadWizardOptions(token, repo) {
   const remote = await fetchWizardOptions(token, repo);
@@ -3638,6 +3663,7 @@ var steps_exports = {};
 __export(steps_exports, {
   fetchContexts: () => fetch_contexts_default,
   fetchFactory: () => fetch_factory_default,
+  runMcpInstallCommands: () => run_mcp_install_commands_default,
   updateGitignore: () => update_gitignore_default,
   writeInstructions: () => write_instructions_default,
   writeMcpConfig: () => write_mcp_config_default,
@@ -3810,9 +3836,204 @@ function getReadableError(status) {
 }
 
 // src/steps/resources/fetch-factory.ts
+var import_fs4 = require("fs");
+var import_path4 = require("path");
+var import_child_process3 = require("child_process");
+
+// src/bundles/run-bundle.ts
 var import_fs3 = require("fs");
 var import_path3 = require("path");
-var import_child_process3 = require("child_process");
+
+// src/bundles/types.ts
+var SCHEMA_VERSION = 1;
+
+// src/bundles/run-bundle.ts
+var OWNER_KEY = "_bundleOwner";
+async function runBundle(manifest, ctx) {
+  assertSchemaCompatible(manifest);
+  assertBundleRootExists(ctx);
+  const result = {
+    name: manifest.name,
+    opsExecuted: 0,
+    filesTouched: []
+  };
+  const ops = manifest.targets?.[ctx.agent] ?? [];
+  for (const op of ops) {
+    executeOp(op, manifest.name, ctx, result);
+    result.opsExecuted++;
+  }
+  if (manifest.gitignore?.length) {
+    upsertMarkerBlock(
+      (0, import_path3.join)(ctx.projectPath, ".gitignore"),
+      `# ${manifest.name}:start`,
+      `# ${manifest.name}:end`,
+      manifest.gitignore.join("\n")
+    );
+    result.filesTouched.push(".gitignore");
+  }
+  const snippet = manifest.instructions?.[ctx.agent];
+  if (snippet) {
+    result.instructionsSnippet = snippet;
+    if (!ctx.skipInstructions) {
+      upsertMarkerBlock(
+        (0, import_path3.join)(ctx.projectPath, ctx.instructionsFile),
+        `<!-- ${manifest.name}:start -->`,
+        `<!-- ${manifest.name}:end -->`,
+        snippet
+      );
+      result.filesTouched.push(ctx.instructionsFile);
+    }
+  }
+  return result;
+}
+function executeOp(op, owner, ctx, result) {
+  switch (op.op) {
+    case "copy":
+      return runCopy(op, ctx, result);
+    case "merge-json":
+      return runMergeJson(op, owner, ctx, result);
+    default: {
+      const unknown = op.op;
+      throw new Error(
+        `Bundle "${owner}" uses unknown op "${unknown}". Installer supports: copy, merge-json. Upgrade the installer or check the bundle's schemaVersion.`
+      );
+    }
+  }
+}
+function runCopy(op, ctx, result) {
+  const source = resolveBundlePath(op.from, ctx);
+  const target = resolveProjectPath(op.to, ctx);
+  if (!(0, import_fs3.existsSync)(source)) return;
+  if ((0, import_fs3.statSync)(source).isDirectory()) {
+    copyDirectory2(source, target);
+  } else {
+    (0, import_fs3.mkdirSync)((0, import_path3.dirname)(target), { recursive: true });
+    (0, import_fs3.copyFileSync)(source, target);
+  }
+  result.filesTouched.push(op.to);
+}
+function runMergeJson(op, owner, ctx, result) {
+  const filePath = resolveProjectPath(op.file, ctx);
+  const existing = readJsonOrEmpty(filePath);
+  const stripped = stripOwnedEntries(existing, owner);
+  const tagged = tagEntries(op.patch, owner);
+  const merged = deepMerge2(stripped, tagged);
+  (0, import_fs3.mkdirSync)((0, import_path3.dirname)(filePath), { recursive: true });
+  (0, import_fs3.writeFileSync)(filePath, JSON.stringify(merged, null, 2) + "\n", "utf-8");
+  result.filesTouched.push(op.file);
+}
+function readJsonOrEmpty(path) {
+  if (!(0, import_fs3.existsSync)(path)) return {};
+  try {
+    return JSON.parse((0, import_fs3.readFileSync)(path, "utf-8"));
+  } catch {
+    return {};
+  }
+}
+function isPlainObject2(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
+    );
+  }
+  if (isPlainObject2(value)) {
+    return Object.fromEntries(
+      Object.entries(value).map(([k, v]) => [k, tagEntries(v, owner)])
+    );
+  }
+  return value;
+}
+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 deepMerge2(a, b) {
+  if (isPlainObject2(a) && isPlainObject2(b)) {
+    const out = { ...a };
+    for (const [k, v] of Object.entries(b)) {
+      out[k] = k in a ? deepMerge2(a[k], v) : v;
+    }
+    return out;
+  }
+  if (Array.isArray(a) && Array.isArray(b)) {
+    return [...a, ...b];
+  }
+  return b;
+}
+function upsertMarkerBlock(filePath, startMarker, endMarker, body) {
+  const block = `${startMarker}
+${body}
+${endMarker}`;
+  (0, import_fs3.mkdirSync)((0, import_path3.dirname)(filePath), { recursive: true });
+  if (!(0, import_fs3.existsSync)(filePath)) {
+    (0, import_fs3.writeFileSync)(filePath, block + "\n", "utf-8");
+    return;
+  }
+  const existing = (0, import_fs3.readFileSync)(filePath, "utf-8");
+  const s = existing.indexOf(startMarker);
+  const e = existing.indexOf(endMarker);
+  if (s !== -1 && e !== -1 && e > s) {
+    const updated = existing.slice(0, s) + block + existing.slice(e + endMarker.length);
+    (0, import_fs3.writeFileSync)(filePath, updated, "utf-8");
+  } else {
+    const joiner = existing.endsWith("\n") ? "\n" : "\n\n";
+    (0, import_fs3.writeFileSync)(filePath, existing + joiner + block + "\n", "utf-8");
+  }
+}
+function resolveBundlePath(rel, ctx) {
+  const base = (0, import_path3.resolve)(ctx.bundleRoot);
+  const full = (0, import_path3.resolve)((0, import_path3.join)(base, rel));
+  if (full !== base && !full.startsWith(base + import_path3.sep)) {
+    throw new Error(`Bundle op "from" escapes bundle root: ${rel}`);
+  }
+  return full;
+}
+function resolveProjectPath(rel, ctx) {
+  const base = (0, import_path3.resolve)(ctx.projectPath);
+  const full = (0, import_path3.resolve)((0, import_path3.join)(base, rel));
+  if (full !== base && !full.startsWith(base + import_path3.sep)) {
+    throw new Error(`Bundle op "to" escapes project path: ${rel}`);
+  }
+  return full;
+}
+function assertSchemaCompatible(manifest) {
+  if (manifest.schemaVersion !== SCHEMA_VERSION) {
+    throw new Error(
+      `Bundle "${manifest.name}" declares schemaVersion ${manifest.schemaVersion}, installer supports ${SCHEMA_VERSION}. Upgrade the installer or re-pin the bundle.`
+    );
+  }
+  if (!manifest.name || !/^[a-z][a-z0-9-]*$/.test(manifest.name)) {
+    throw new Error(
+      `Bundle name must match /^[a-z][a-z0-9-]*$/: got "${manifest.name}"`
+    );
+  }
+}
+function assertBundleRootExists(ctx) {
+  if (!(0, import_fs3.existsSync)(ctx.bundleRoot) || !(0, import_fs3.statSync)(ctx.bundleRoot).isDirectory()) {
+    throw new Error(`Bundle root not found or not a directory: ${ctx.bundleRoot}`);
+  }
+}
+function copyDirectory2(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 (entry.isDirectory()) copyDirectory2(s, t);
+    else (0, import_fs3.copyFileSync)(s, t);
+  }
+}
+
+// src/steps/resources/fetch-factory.ts
 var MIN_FILE_SIZE2 = 1024;
 function getFactoryAsset(agent) {
   switch (agent) {
@@ -3829,10 +4050,17 @@ var fetch_factory_default = defineStep({
   execute: async (ctx) => {
     const result = await fetchFactory(ctx.token, ctx.factoryRepo, ctx.config.projectPath, ctx.config.agent);
     ctx.installed.factoryInstalled = result.success;
+    ctx.installed.factoryBundleManaged = result.bundleManaged ?? false;
+    if (result.instructionsSnippet) {
+      const stash = ctx.installed.bundleInstructions ?? {};
+      stash["factory"] = result.instructionsSnippet;
+      ctx.installed.bundleInstructions = stash;
+    }
     if (!result.success) {
       return { status: "failed", detail: result.failureReason };
     }
-    return { status: "success", message: result.filesInstalled.join(", ") };
+    const tag = result.bundleManaged ? " (bundle)" : "";
+    return { status: "success", message: result.filesInstalled.join(", ") + tag };
   }
 });
 async function fetchFactory(token, repo, targetDir, agent) {
@@ -3861,10 +4089,10 @@ async function fetchFactory(token, repo, targetDir, agent) {
     result.failureReason = `${assetName} not found in release`;
     return result;
   }
-  const tempDir = (0, import_path3.join)(targetDir, ".temp-factory-download");
+  const tempDir = (0, import_path4.join)(targetDir, ".temp-factory-download");
   try {
-    if ((0, import_fs3.existsSync)(tempDir)) (0, import_fs3.rmSync)(tempDir, { recursive: true, force: true });
-    (0, import_fs3.mkdirSync)(tempDir, { recursive: true });
+    if ((0, import_fs4.existsSync)(tempDir)) (0, import_fs4.rmSync)(tempDir, { recursive: true, force: true });
+    (0, import_fs4.mkdirSync)(tempDir, { recursive: true });
     const response = await fetchWithRetry(asset.url, {
       headers: { "Accept": "application/octet-stream", "Authorization": `Bearer ${token}` }
     });
@@ -3872,10 +4100,10 @@ async function fetchFactory(token, repo, targetDir, agent) {
       result.failureReason = `Download failed (${response.status})`;
       return result;
     }
-    const archivePath = (0, import_path3.join)(tempDir, assetName);
+    const archivePath = (0, import_path4.join)(tempDir, assetName);
     const arrayBuffer = await response.arrayBuffer();
-    (0, import_fs3.writeFileSync)(archivePath, Buffer.from(arrayBuffer));
-    const stats = (0, import_fs3.statSync)(archivePath);
+    (0, import_fs4.writeFileSync)(archivePath, Buffer.from(arrayBuffer));
+    const stats = (0, import_fs4.statSync)(archivePath);
     if (stats.size < MIN_FILE_SIZE2) {
       result.failureReason = "Downloaded file corrupted (too small)";
       return result;
@@ -3885,10 +4113,10 @@ async function fetchFactory(token, repo, targetDir, agent) {
       result.failureReason = "Failed to read archive contents";
       return result;
     }
-    const resolvedTempDir = (0, import_path3.resolve)(tempDir);
+    const resolvedTempDir = (0, import_path4.resolve)(tempDir);
     for (const entry of listResult.stdout.split("\n").filter(Boolean)) {
-      const entryPath = (0, import_path3.resolve)((0, import_path3.join)(tempDir, entry.replace(/\/$/, "")));
-      if (!entryPath.startsWith(resolvedTempDir + import_path3.sep)) {
+      const entryPath = (0, import_path4.resolve)((0, import_path4.join)(tempDir, entry.replace(/\/$/, "")));
+      if (!entryPath.startsWith(resolvedTempDir + import_path4.sep)) {
         result.failureReason = `Archive contains unsafe path: ${entry}`;
         return result;
       }
@@ -3898,14 +4126,17 @@ async function fetchFactory(token, repo, targetDir, agent) {
       result.failureReason = "Archive extraction failed";
       return result;
     }
-    const extractedEntries = (0, import_fs3.readdirSync)(tempDir);
+    const extractedEntries = (0, import_fs4.readdirSync)(tempDir);
     const extractedFolder = extractedEntries.find((e) => e.toLowerCase() === rootFolder.toLowerCase());
     if (!extractedFolder) {
       result.failureReason = `No ${rootFolder}/ folder in archive`;
       return result;
     }
-    const extractedPath = (0, import_path3.join)(tempDir, extractedFolder);
-    if (agent === "github-copilot") {
+    const extractedPath = (0, import_path4.join)(tempDir, extractedFolder);
+    const manifestPath = (0, import_path4.join)(extractedPath, "install.json");
+    if ((0, import_fs4.existsSync)(manifestPath)) {
+      await installViaBundle(manifestPath, extractedPath, targetDir, agent, result);
+    } else if (agent === "github-copilot") {
       installCopilotFactory(extractedPath, targetDir, result);
     } else {
       installClaudeFactory(extractedPath, targetDir, result);
@@ -3914,53 +4145,73 @@ async function fetchFactory(token, repo, targetDir, agent) {
   } catch (error) {
     result.failureReason = error instanceof Error ? error.message : String(error);
   } finally {
-    if ((0, import_fs3.existsSync)(tempDir)) {
+    if ((0, import_fs4.existsSync)(tempDir)) {
       try {
-        (0, import_fs3.rmSync)(tempDir, { recursive: true, force: true });
+        (0, import_fs4.rmSync)(tempDir, { recursive: true, force: true });
       } catch {
       }
     }
   }
   return result;
 }
+async function installViaBundle(manifestPath, extractedPath, targetDir, agent, result) {
+  let manifest;
+  try {
+    manifest = JSON.parse((0, import_fs4.readFileSync)(manifestPath, "utf-8"));
+  } catch (e) {
+    throw new Error(`install.json is not valid JSON: ${e instanceof Error ? e.message : String(e)}`);
+  }
+  const target = getAgentTarget(agent);
+  const runResult = await runBundle(manifest, {
+    bundleRoot: extractedPath,
+    projectPath: targetDir,
+    agent,
+    instructionsFile: target.instructions,
+    skipInstructions: true
+    // write-instructions.ts commits the snippet for correct ordering
+  });
+  result.bundleManaged = true;
+  result.instructionsSnippet = runResult.instructionsSnippet;
+  result.filesInstalled = runResult.filesTouched;
+}
 function installClaudeFactory(extractedPath, targetDir, result) {
-  const claudeDir = (0, import_path3.join)(targetDir, ".claude");
-  const factoryDir = (0, import_path3.join)(targetDir, "factory");
-  const agentsSrc = (0, import_path3.join)(extractedPath, "agents");
-  if ((0, import_fs3.existsSync)(agentsSrc)) {
-    copyDirectory2(agentsSrc, (0, import_path3.join)(claudeDir, "agents"));
+  const claudeDir = (0, import_path4.join)(targetDir, ".claude");
+  const factoryDir = (0, import_path4.join)(targetDir, "factory");
+  const agentsSrc = (0, import_path4.join)(extractedPath, "agents");
+  if ((0, import_fs4.existsSync)(agentsSrc)) {
+    copyDirectory3(agentsSrc, (0, import_path4.join)(claudeDir, "agents"));
     result.filesInstalled.push(".claude/agents/");
   }
-  const hooksSrc = (0, import_path3.join)(extractedPath, "hooks");
-  if ((0, import_fs3.existsSync)(hooksSrc)) {
-    copyDirectory2(hooksSrc, (0, import_path3.join)(claudeDir, "hooks"));
+  const hooksSrc = (0, import_path4.join)(extractedPath, "hooks");
+  if ((0, import_fs4.existsSync)(hooksSrc)) {
+    copyDirectory3(hooksSrc, (0, import_path4.join)(claudeDir, "hooks"));
     result.filesInstalled.push(".claude/hooks/");
   }
-  const skillsSrc = (0, import_path3.join)(extractedPath, "skills");
-  if ((0, import_fs3.existsSync)(skillsSrc)) {
-    copyDirectory2(skillsSrc, (0, import_path3.join)(claudeDir, "skills"));
+  const skillsSrc = (0, import_path4.join)(extractedPath, "skills");
+  if ((0, import_fs4.existsSync)(skillsSrc)) {
+    copyDirectory3(skillsSrc, (0, import_path4.join)(claudeDir, "skills"));
     result.filesInstalled.push(".claude/skills/");
   }
-  const workflowSrc = (0, import_path3.join)(extractedPath, "workflow");
-  if ((0, import_fs3.existsSync)(workflowSrc)) {
-    copyDirectory2(workflowSrc, (0, import_path3.join)(factoryDir, "workflow"));
+  const workflowSrc = (0, import_path4.join)(extractedPath, "workflow");
+  if ((0, import_fs4.existsSync)(workflowSrc)) {
+    copyDirectory3(workflowSrc, (0, import_path4.join)(factoryDir, "workflow"));
     result.filesInstalled.push("factory/workflow/");
   }
-  const utilsSrc = (0, import_path3.join)(extractedPath, "utils");
-  if ((0, import_fs3.existsSync)(utilsSrc)) {
-    copyDirectory2(utilsSrc, (0, import_path3.join)(factoryDir, "utils"));
+  const utilsSrc = (0, import_path4.join)(extractedPath, "utils");
+  if ((0, import_fs4.existsSync)(utilsSrc)) {
+    copyDirectory3(utilsSrc, (0, import_path4.join)(factoryDir, "utils"));
     result.filesInstalled.push("factory/utils/");
   }
-  const docsSrc = (0, import_path3.join)(extractedPath, "docs");
-  if ((0, import_fs3.existsSync)(docsSrc)) {
-    copyDirectory2(docsSrc, (0, import_path3.join)(factoryDir, "docs"));
+  const docsSrc = (0, import_path4.join)(extractedPath, "docs");
+  if ((0, import_fs4.existsSync)(docsSrc)) {
+    copyDirectory3(docsSrc, (0, import_path4.join)(factoryDir, "docs"));
     result.filesInstalled.push("factory/docs/");
   }
-  const rootEntries = (0, import_fs3.readdirSync)(extractedPath, { withFileTypes: true });
+  const rootEntries = (0, import_fs4.readdirSync)(extractedPath, { withFileTypes: true });
   for (const entry of rootEntries) {
     if (entry.isFile()) {
-      if (!(0, import_fs3.existsSync)(factoryDir)) (0, import_fs3.mkdirSync)(factoryDir, { recursive: true });
-      (0, import_fs3.copyFileSync)((0, import_path3.join)(extractedPath, entry.name), (0, import_path3.join)(factoryDir, entry.name));
+      if (!(0, import_fs4.existsSync)(factoryDir)) (0, import_fs4.mkdirSync)(factoryDir, { recursive: true });
+      (0, import_fs4.copyFileSync)((0, import_path4.join)(extractedPath, entry.name), (0, import_path4.join)(factoryDir, entry.name));
       result.filesInstalled.push(`factory/${entry.name}`);
     }
   }
@@ -3968,9 +4219,9 @@ function installClaudeFactory(extractedPath, targetDir, result) {
   result.filesInstalled.push(".claude/settings.json");
 }
 function installCopilotFactory(extractedPath, targetDir, result) {
-  const factoryDir = (0, import_path3.join)(targetDir, "factory");
-  copyDirectory2(extractedPath, factoryDir);
-  const entries = (0, import_fs3.readdirSync)(extractedPath, { withFileTypes: true });
+  const factoryDir = (0, import_path4.join)(targetDir, "factory");
+  copyDirectory3(extractedPath, factoryDir);
+  const entries = (0, import_fs4.readdirSync)(extractedPath, { withFileTypes: true });
   for (const entry of entries) {
     if (entry.isDirectory()) {
       result.filesInstalled.push(`factory/${entry.name}/`);
@@ -3980,11 +4231,11 @@ function installCopilotFactory(extractedPath, targetDir, result) {
   }
 }
 function configureSettings(claudeDir) {
-  const settingsPath = (0, import_path3.join)(claudeDir, "settings.json");
+  const settingsPath = (0, import_path4.join)(claudeDir, "settings.json");
   let settings = {};
-  if ((0, import_fs3.existsSync)(settingsPath)) {
+  if ((0, import_fs4.existsSync)(settingsPath)) {
     try {
-      settings = JSON.parse((0, import_fs3.readFileSync)(settingsPath, "utf8"));
+      settings = JSON.parse((0, import_fs4.readFileSync)(settingsPath, "utf8"));
     } catch {
     }
   }
@@ -4035,26 +4286,26 @@ function configureSettings(claudeDir) {
     if (!hasMonitor) settings.hooks.UserPromptSubmit.push(contextMonitorHook);
   }
   settings.statusLine = { type: "command", command: "node .claude/hooks/factory-statusline.cjs" };
-  if (!(0, import_fs3.existsSync)(claudeDir)) (0, import_fs3.mkdirSync)(claudeDir, { recursive: true });
-  (0, import_fs3.writeFileSync)(settingsPath, JSON.stringify(settings, null, 2) + "\n");
+  if (!(0, import_fs4.existsSync)(claudeDir)) (0, import_fs4.mkdirSync)(claudeDir, { recursive: true });
+  (0, import_fs4.writeFileSync)(settingsPath, JSON.stringify(settings, null, 2) + "\n");
 }
-function copyDirectory2(source, target) {
-  if (!(0, import_fs3.existsSync)(target)) (0, import_fs3.mkdirSync)(target, { recursive: true });
-  const entries = (0, import_fs3.readdirSync)(source, { withFileTypes: true });
+function copyDirectory3(source, target) {
+  if (!(0, import_fs4.existsSync)(target)) (0, import_fs4.mkdirSync)(target, { recursive: true });
+  const entries = (0, import_fs4.readdirSync)(source, { withFileTypes: true });
   for (const entry of entries) {
-    const sourcePath = (0, import_path3.join)(source, entry.name);
-    const targetPath = (0, import_path3.join)(target, entry.name);
+    const sourcePath = (0, import_path4.join)(source, entry.name);
+    const targetPath = (0, import_path4.join)(target, entry.name);
     if (entry.isDirectory()) {
-      copyDirectory2(sourcePath, targetPath);
+      copyDirectory3(sourcePath, targetPath);
     } else {
-      (0, import_fs3.copyFileSync)(sourcePath, targetPath);
+      (0, import_fs4.copyFileSync)(sourcePath, targetPath);
     }
   }
 }
 
 // src/steps/setup/write-instructions.ts
-var import_fs4 = require("fs");
-var import_path4 = require("path");
+var import_fs5 = require("fs");
+var import_path5 = require("path");
 
 // src/steps/shared.ts
 function getFilteredMcpConfig(ctx) {
@@ -4078,65 +4329,45 @@ var red = (text) => `\x1B[31m${text}\x1B[0m`;
 var write_instructions_default = defineStep({
   name: "write-instructions",
   label: "Writing instruction file",
-  when: (ctx) => (ctx.installed.domainsInstalled?.length ?? 0) > 0 || Object.keys(ctx.config.mcpConfig).length > 0 || ctx.installed.factoryInstalled,
+  when: (ctx) => (ctx.installed.domainsInstalled?.length ?? 0) > 0 || Object.keys(ctx.config.mcpConfig).length > 0 || ctx.installed.factoryInstalled || Object.keys(ctx.installed.bundleInstructions ?? {}).length > 0,
   execute: async (ctx) => {
     const filteredMcpConfig = getFilteredMcpConfig(ctx);
     const domains = ctx.installed.domainsInstalled ?? [];
     const agent = ctx.config.agent;
     const projectPath = ctx.config.projectPath;
     const factoryInstalled = ctx.installed.factoryInstalled ?? false;
-    const content = buildCombinedInstructions(domains, filteredMcpConfig, agent, projectPath, factoryInstalled);
-    switch (agent) {
-      case "claude-code": {
-        upsertBlock((0, import_path4.join)(projectPath, "CLAUDE.md"), content);
-        break;
-      }
-      case "github-copilot": {
-        const githubDir = (0, import_path4.join)(projectPath, ".github");
-        if (!(0, import_fs4.existsSync)(githubDir)) (0, import_fs4.mkdirSync)(githubDir, { recursive: true });
-        upsertBlock((0, import_path4.join)(githubDir, "copilot-instructions.md"), content);
-        break;
-      }
-      case "cursor": {
-        const cursorDir = (0, import_path4.join)(projectPath, ".cursor", "rules");
-        if (!(0, import_fs4.existsSync)(cursorDir)) (0, import_fs4.mkdirSync)(cursorDir, { recursive: true });
-        const filePath = (0, import_path4.join)(cursorDir, "instructions.mdc");
-        if (!(0, import_fs4.existsSync)(filePath)) {
-          (0, import_fs4.writeFileSync)(filePath, `---
+    const factoryBundleManaged = ctx.installed.factoryBundleManaged ?? false;
+    const includeFactorySection = factoryInstalled && !factoryBundleManaged;
+    const content = buildCombinedInstructions(domains, filteredMcpConfig, agent, projectPath, includeFactorySection);
+    const target = getAgentTarget(agent);
+    const filePath = (0, import_path5.join)(projectPath, target.instructions);
+    const fileDir = (0, import_path5.dirname)(filePath);
+    if (!(0, import_fs5.existsSync)(fileDir)) (0, import_fs5.mkdirSync)(fileDir, { recursive: true });
+    if (agent === "cursor" && !(0, import_fs5.existsSync)(filePath)) {
+      (0, import_fs5.writeFileSync)(filePath, `---
 description: AI development instructions from One-Shot Installer
 alwaysApply: true
 ---
 
 `, "utf-8");
-        }
-        upsertBlock(filePath, content);
-        break;
-      }
     }
-    return { status: "success", message: getInstructionFilePath(agent) };
+    upsertBlock(filePath, content);
+    const bundleSnippets = ctx.installed.bundleInstructions ?? {};
+    for (const bundleName of Object.keys(bundleSnippets).sort()) {
+      upsertBundleBlock(filePath, bundleName, bundleSnippets[bundleName]);
+    }
+    return { status: "success", message: target.instructions };
   }
 });
-function getInstructionFilePath(agent) {
-  switch (agent) {
-    case "claude-code":
-      return "CLAUDE.md";
-    case "github-copilot":
-      return ".github/copilot-instructions.md";
-    case "cursor":
-      return ".cursor/rules/instructions.mdc";
-    default:
-      return "CLAUDE.md";
-  }
-}
 function upsertBlock(filePath, block) {
   const marked = `${MARKER_START}
 ${block}
 ${MARKER_END}`;
-  if (!(0, import_fs4.existsSync)(filePath)) {
-    (0, import_fs4.writeFileSync)(filePath, marked, "utf-8");
+  if (!(0, import_fs5.existsSync)(filePath)) {
+    (0, import_fs5.writeFileSync)(filePath, marked, "utf-8");
     return;
   }
-  const existing = (0, import_fs4.readFileSync)(filePath, "utf-8");
+  const existing = (0, import_fs5.readFileSync)(filePath, "utf-8");
   const start = existing.indexOf(MARKER_START);
   const end = existing.indexOf(MARKER_END);
   const hasStart = start !== -1;
@@ -4161,23 +4392,44 @@ ${MARKER_END}`;
   }
   if (hasStart && hasEnd) {
     const updated = existing.slice(0, start) + marked + existing.slice(end + MARKER_END.length);
-    (0, import_fs4.writeFileSync)(filePath, updated, "utf-8");
+    (0, import_fs5.writeFileSync)(filePath, updated, "utf-8");
   } else {
     const separator = existing.endsWith("\n") ? "\n" : "\n\n";
-    (0, import_fs4.writeFileSync)(filePath, existing + separator + marked, "utf-8");
+    (0, import_fs5.writeFileSync)(filePath, existing + separator + marked, "utf-8");
+  }
+}
+function upsertBundleBlock(filePath, bundleName, snippet) {
+  const startMarker = `<!-- ${bundleName}:start -->`;
+  const endMarker = `<!-- ${bundleName}:end -->`;
+  const block = `${startMarker}
+${snippet}
+${endMarker}`;
+  if (!(0, import_fs5.existsSync)(filePath)) {
+    (0, import_fs5.writeFileSync)(filePath, block + "\n", "utf-8");
+    return;
+  }
+  const existing = (0, import_fs5.readFileSync)(filePath, "utf-8");
+  const s = existing.indexOf(startMarker);
+  const e = existing.indexOf(endMarker);
+  if (s !== -1 && e !== -1 && e > s) {
+    const updated = existing.slice(0, s) + block + existing.slice(e + endMarker.length);
+    (0, import_fs5.writeFileSync)(filePath, updated, "utf-8");
+  } else {
+    const separator = existing.endsWith("\n") ? "\n" : "\n\n";
+    (0, import_fs5.writeFileSync)(filePath, existing + separator + block + "\n", "utf-8");
   }
 }
 function collectMdFiles(dir) {
-  if (!(0, import_fs4.existsSync)(dir)) return [];
-  const entries = (0, import_fs4.readdirSync)(dir, { recursive: true });
+  if (!(0, import_fs5.existsSync)(dir)) return [];
+  const entries = (0, import_fs5.readdirSync)(dir, { recursive: true });
   return entries.filter((entry) => {
-    const fullPath = (0, import_path4.join)(dir, entry);
-    return entry.endsWith(".md") && (0, import_fs4.statSync)(fullPath).isFile();
+    const fullPath = (0, import_path5.join)(dir, entry);
+    return entry.endsWith(".md") && (0, import_fs5.statSync)(fullPath).isFile();
   }).map((entry) => entry.replace(/\\/g, "/")).sort();
 }
 function extractFirstHeading(filePath) {
   try {
-    const content = (0, import_fs4.readFileSync)(filePath, "utf-8");
+    const content = (0, import_fs5.readFileSync)(filePath, "utf-8");
     const withoutFrontmatter = content.replace(/^---[\s\S]*?---\s*/, "");
     const match = withoutFrontmatter.match(/^#\s+(.+)/m);
     if (match) {
@@ -4195,16 +4447,16 @@ function formatPathRef(contextPath, description, agent) {
   return `- \`${contextPath}\` \u2014 ${description}`;
 }
 function resolveDomainFolder(domain, contextsDir) {
-  if ((0, import_fs4.existsSync)(contextsDir)) {
+  if ((0, import_fs5.existsSync)(contextsDir)) {
     try {
-      const entries = (0, import_fs4.readdirSync)(contextsDir);
+      const entries = (0, import_fs5.readdirSync)(contextsDir);
       const match = entries.find((e) => e.toLowerCase() === domain.toLowerCase());
-      if (match) return { folderName: match, folderPath: (0, import_path4.join)(contextsDir, match) };
+      if (match) return { folderName: match, folderPath: (0, import_path5.join)(contextsDir, match) };
     } catch {
     }
   }
   const fallback = domain.toUpperCase();
-  return { folderName: fallback, folderPath: (0, import_path4.join)(contextsDir, fallback) };
+  return { folderName: fallback, folderPath: (0, import_path5.join)(contextsDir, fallback) };
 }
 function buildContextRefsSection(domains, agent, contextsDir) {
   const lines2 = [
@@ -4216,34 +4468,34 @@ function buildContextRefsSection(domains, agent, contextsDir) {
   let hasAnyFiles = false;
   for (const domain of domains) {
     const { folderName, folderPath: domainPath } = resolveDomainFolder(domain, contextsDir);
-    if (!(0, import_fs4.existsSync)(domainPath)) continue;
+    if (!(0, import_fs5.existsSync)(domainPath)) continue;
     const domainFiles = [];
-    const ctxInstructions = (0, import_path4.join)(domainPath, "context-instructions.md");
-    if ((0, import_fs4.existsSync)(ctxInstructions)) {
+    const ctxInstructions = (0, import_path5.join)(domainPath, "context-instructions.md");
+    if ((0, import_fs5.existsSync)(ctxInstructions)) {
       const desc = extractFirstHeading(ctxInstructions);
       domainFiles.push(formatPathRef(`_ai-context/${folderName}/context-instructions.md`, desc, agent));
     }
-    const instructionsMd = (0, import_path4.join)(domainPath, "core", "instructions.md");
-    if ((0, import_fs4.existsSync)(instructionsMd)) {
+    const instructionsMd = (0, import_path5.join)(domainPath, "core", "instructions.md");
+    if ((0, import_fs5.existsSync)(instructionsMd)) {
       const desc = extractFirstHeading(instructionsMd);
       domainFiles.push(formatPathRef(`_ai-context/${folderName}/core/instructions.md`, `${desc} (start here)`, agent));
     }
-    const coreDir = (0, import_path4.join)(domainPath, "core");
-    if ((0, import_fs4.existsSync)(coreDir)) {
+    const coreDir = (0, import_path5.join)(domainPath, "core");
+    if ((0, import_fs5.existsSync)(coreDir)) {
       const coreFiles = collectMdFiles(coreDir).filter((f) => f !== "instructions.md" && !f.startsWith("instructions/"));
       for (const file of coreFiles) {
-        const desc = extractFirstHeading((0, import_path4.join)(coreDir, file));
+        const desc = extractFirstHeading((0, import_path5.join)(coreDir, file));
         domainFiles.push(formatPathRef(`_ai-context/${folderName}/core/${file}`, desc, agent));
       }
     }
-    const refDir = (0, import_path4.join)(domainPath, "reference");
-    if ((0, import_fs4.existsSync)(refDir)) {
+    const refDir = (0, import_path5.join)(domainPath, "reference");
+    if ((0, import_fs5.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_path4.join)(refDir, file));
+          const desc = extractFirstHeading((0, import_path5.join)(refDir, file));
           domainFiles.push(formatPathRef(`_ai-context/${folderName}/reference/${file}`, desc, agent));
         }
       }
@@ -4321,7 +4573,7 @@ function buildFactorySection(agent) {
   ].join("\n");
 }
 function buildCombinedInstructions(domains, mcpConfig, agent, projectPath, factoryInstalled) {
-  const contextsDir = (0, import_path4.join)(projectPath, "_ai-context");
+  const contextsDir = (0, import_path5.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));
@@ -4330,8 +4582,8 @@ function buildCombinedInstructions(domains, mcpConfig, agent, projectPath, facto
 }
 
 // src/steps/setup/write-mcp-config.ts
-var import_fs5 = require("fs");
-var import_path5 = require("path");
+var import_fs6 = require("fs");
+var import_path6 = require("path");
 var red2 = (text) => `\x1B[31m${text}\x1B[0m`;
 var write_mcp_config_default = defineStep({
   name: "write-mcp-config",
@@ -4339,23 +4591,23 @@ var write_mcp_config_default = defineStep({
   when: (ctx) => Object.keys(ctx.config.mcpConfig).length > 0,
   execute: async (ctx) => {
     const filteredMcpConfig = getFilteredMcpConfig(ctx);
-    const target = getAgentMCPTarget(ctx.config.agent);
-    const mcpJsonPath = (0, import_path5.join)(ctx.config.projectPath, target.filePath);
-    if (target.dir) {
-      const dir = (0, import_path5.join)(ctx.config.projectPath, target.dir);
-      if (!(0, import_fs5.existsSync)(dir)) (0, import_fs5.mkdirSync)(dir, { recursive: true });
+    const target = getAgentTarget(ctx.config.agent);
+    const mcpJsonPath = (0, import_path6.join)(ctx.config.projectPath, target.mcpConfig);
+    if (target.mcpDir) {
+      const dir = (0, import_path6.join)(ctx.config.projectPath, target.mcpDir);
+      if (!(0, import_fs6.existsSync)(dir)) (0, import_fs6.mkdirSync)(dir, { recursive: true });
     }
     let existingFile = {};
-    if ((0, import_fs5.existsSync)(mcpJsonPath)) {
+    if ((0, import_fs6.existsSync)(mcpJsonPath)) {
       try {
-        existingFile = JSON.parse((0, import_fs5.readFileSync)(mcpJsonPath, "utf-8"));
+        existingFile = JSON.parse((0, import_fs6.readFileSync)(mcpJsonPath, "utf-8"));
       } catch {
         const box = [
           "",
           red2("  \u2554\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2557"),
           red2("  \u2551  \u26A0  MCP CONFIG HAS INVALID JSON                 \u2551"),
           red2("  \u2551                                                  \u2551"),
-          red2(`  \u2551  ${target.filePath} could not be parsed.`.padEnd(52) + "\u2551"),
+          red2(`  \u2551  ${target.mcpConfig} could not be parsed.`.padEnd(52) + "\u2551"),
           red2("  \u2551  Existing MCP servers may be lost.               \u2551"),
           red2("  \u2551  Check the file after installation completes.    \u2551"),
           red2("  \u255A\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u255D"),
@@ -4365,16 +4617,16 @@ var write_mcp_config_default = defineStep({
       }
     }
     const addedServers = [];
-    const existingServers = existingFile[target.rootKey] ?? {};
+    const existingServers = existingFile[target.mcpRootKey] ?? {};
     const newServers = {};
     for (const [serverName, serverConfig] of Object.entries(filteredMcpConfig)) {
-      const { description, useWhen, active, ...mcpFields } = serverConfig;
+      const { description, useWhen, active, installCommand, ...mcpFields } = serverConfig;
       newServers[serverName] = mcpFields;
       addedServers.push(serverName);
     }
     const mergedServers = { ...existingServers, ...newServers };
-    const outputFile = { ...existingFile, [target.rootKey]: mergedServers };
-    (0, import_fs5.writeFileSync)(mcpJsonPath, JSON.stringify(outputFile, null, 2), "utf-8");
+    const outputFile = { ...existingFile, [target.mcpRootKey]: mergedServers };
+    (0, import_fs6.writeFileSync)(mcpJsonPath, JSON.stringify(outputFile, null, 2), "utf-8");
     ctx.installed.mcpServersAdded = addedServers;
     return {
       status: "success",
@@ -4382,24 +4634,73 @@ var write_mcp_config_default = defineStep({
     };
   }
 });
-function getAgentMCPTarget(agent) {
-  switch (agent) {
-    case "claude-code":
-      return { filePath: ".mcp.json", rootKey: "mcpServers", dir: null };
-    case "cursor":
-      return { filePath: ".cursor/mcp.json", rootKey: "mcpServers", dir: ".cursor" };
-    case "github-copilot":
-    default:
-      return { filePath: ".vscode/mcp.json", rootKey: "servers", dir: ".vscode" };
+
+// src/steps/setup/run-mcp-install-commands.ts
+var import_child_process4 = require("child_process");
+var run_mcp_install_commands_default = defineStep({
+  name: "run-mcp-install-commands",
+  label: "Registering MCP servers with Claude Code",
+  when: (ctx) => {
+    if (ctx.config.agent !== "claude-code") return false;
+    const filtered = getFilteredMcpConfig(ctx);
+    return Object.values(filtered).some((s) => typeof s.installCommand === "string" && s.installCommand.length > 0);
+  },
+  execute: async (ctx) => {
+    if (!isClaudeCliAvailable()) {
+      return {
+        status: "skipped",
+        detail: "`claude` CLI not found on PATH \u2014 skipping CLI registration (project .mcp.json was still written)"
+      };
+    }
+    const filtered = getFilteredMcpConfig(ctx);
+    const succeeded = [];
+    const failed = [];
+    for (const [name, cfg] of Object.entries(filtered)) {
+      const cmd = cfg.installCommand;
+      if (typeof cmd !== "string" || cmd.length === 0) continue;
+      const result = (0, import_child_process4.spawnSync)(cmd, {
+        shell: true,
+        stdio: "pipe",
+        encoding: "utf-8",
+        cwd: ctx.config.projectPath
+      });
+      if (result.status === 0) {
+        succeeded.push(name);
+      } else {
+        const stderr = (result.stderr ?? "").trim();
+        const reason = stderr.length > 0 ? stderr.split("\n")[0] : `exit ${result.status}`;
+        failed.push({ name, reason });
+      }
+    }
+    ctx.installed.mcpInstallCommandsRun = { succeeded, failed };
+    if (failed.length === 0) {
+      return {
+        status: "success",
+        message: succeeded.length > 0 ? succeeded.join(", ") : void 0
+      };
+    }
+    const failedSummary = failed.map((f) => `${f.name} (${f.reason})`).join("; ");
+    if (succeeded.length === 0) {
+      return { status: "failed", detail: failedSummary };
+    }
+    return {
+      status: "success",
+      message: `${succeeded.join(", ")}; failed: ${failed.map((f) => f.name).join(", ")}`,
+      detail: `Some registrations failed: ${failedSummary}`
+    };
   }
+});
+function isClaudeCliAvailable() {
+  const check2 = (0, import_child_process4.spawnSync)("claude --version", { shell: true, stdio: "ignore" });
+  return check2.status === 0;
 }
 
 // src/steps/setup/update-gitignore.ts
-var import_fs6 = require("fs");
-var import_path6 = require("path");
+var import_fs7 = require("fs");
+var import_path7 = require("path");
 var MARKER_START2 = "# one-shot-installer:start";
 var MARKER_END2 = "# one-shot-installer:end";
-var GITIGNORE_ENTRIES = [
+var CORE_GITIGNORE_ENTRIES = [
   "# One-Shot installer generated files",
   ".one-shot-state.json",
   ".mcp.json",
@@ -4411,8 +4712,9 @@ var GITIGNORE_ENTRIES = [
   ".claude/agents/",
   ".claude/agent-memory/",
   ".claude/plans/",
-  ".claude/settings.local.json",
-  "",
+  ".claude/settings.local.json"
+];
+var LEGACY_FACTORY_GITIGNORE_ENTRIES = [
   "# Factory runtime state (generated by workflow, not committed)",
   "factory/STATE.md",
   "factory/PROJECT.md",
@@ -4430,40 +4732,45 @@ var update_gitignore_default = defineStep({
   name: "update-gitignore",
   label: "Updating .gitignore",
   execute: async (ctx) => {
-    const gitignorePath = (0, import_path6.join)(ctx.config.projectPath, ".gitignore");
-    const block = [MARKER_START2, ...GITIGNORE_ENTRIES, MARKER_END2].join("\n");
-    if (!(0, import_fs6.existsSync)(gitignorePath)) {
-      (0, import_fs6.writeFileSync)(gitignorePath, block + "\n", "utf-8");
+    const gitignorePath = (0, import_path7.join)(ctx.config.projectPath, ".gitignore");
+    const factoryInstalled = ctx.installed.factoryInstalled ?? false;
+    const factoryBundleManaged = ctx.installed.factoryBundleManaged ?? false;
+    const includeLegacyFactory = factoryInstalled && !factoryBundleManaged;
+    const entries = includeLegacyFactory ? [...CORE_GITIGNORE_ENTRIES, "", ...LEGACY_FACTORY_GITIGNORE_ENTRIES] : CORE_GITIGNORE_ENTRIES;
+    const block = [MARKER_START2, ...entries, MARKER_END2].join("\n");
+    if (!(0, import_fs7.existsSync)(gitignorePath)) {
+      (0, import_fs7.writeFileSync)(gitignorePath, block + "\n", "utf-8");
       return { status: "success" };
     }
-    const existing = (0, import_fs6.readFileSync)(gitignorePath, "utf-8");
+    const existing = (0, import_fs7.readFileSync)(gitignorePath, "utf-8");
     const start = existing.indexOf(MARKER_START2);
     const end = existing.indexOf(MARKER_END2);
     if (start !== -1 && end !== -1 && end > start) {
       const updated = existing.slice(0, start) + block + existing.slice(end + MARKER_END2.length);
-      (0, import_fs6.writeFileSync)(gitignorePath, updated, "utf-8");
+      (0, import_fs7.writeFileSync)(gitignorePath, updated, "utf-8");
     } else {
       const separator = existing.endsWith("\n") ? "\n" : "\n\n";
-      (0, import_fs6.writeFileSync)(gitignorePath, existing + separator + block + "\n", "utf-8");
+      (0, import_fs7.writeFileSync)(gitignorePath, existing + separator + block + "\n", "utf-8");
     }
     return { status: "success" };
   }
 });
 
 // src/steps/setup/write-state.ts
-var import_fs7 = require("fs");
-var import_path7 = require("path");
+var import_fs8 = require("fs");
+var import_path8 = require("path");
 var import_os2 = require("os");
-var INSTALLER_VERSION = "0.5.17";
+var INSTALLER_VERSION = "0.6.0";
 var write_state_default = defineStep({
   name: "write-state",
   label: "Saving installation state",
   execute: async (ctx) => {
-    const statePath = (0, import_path7.join)(ctx.config.projectPath, ".one-shot-state.json");
+    const statePath = (0, import_path8.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))
     );
+    const target = getAgentTarget(ctx.config.agent);
     const state = {
       installedAt: (/* @__PURE__ */ new Date()).toISOString(),
       installerVersion: INSTALLER_VERSION,
@@ -4477,65 +4784,19 @@ var write_state_default = defineStep({
       mcpConfigs: filteredMcpConfig,
       factoryInstalled: ctx.installed.factoryInstalled ?? false,
       files: {
-        instructions: getInstructionFilePath2(ctx.config.agent),
-        mcpConfig: getMCPConfigPath(ctx.config.agent),
+        instructions: target.instructions,
+        mcpConfig: target.mcpConfig,
         contexts: "_ai-context/",
         factory: ctx.installed.factoryInstalled ? "factory/" : null,
-        globalConfig: (0, import_path7.join)((0, import_os2.homedir)(), ".one-shot-installer")
+        globalConfig: (0, import_path8.join)((0, import_os2.homedir)(), ".one-shot-installer")
       }
     };
-    (0, import_fs7.writeFileSync)(statePath, JSON.stringify(state, null, 2), "utf-8");
+    (0, import_fs8.writeFileSync)(statePath, JSON.stringify(state, null, 2), "utf-8");
     return { status: "success" };
   }
 });
-function getInstructionFilePath2(agent) {
-  switch (agent) {
-    case "claude-code":
-      return "CLAUDE.md";
-    case "github-copilot":
-      return ".github/copilot-instructions.md";
-    case "cursor":
-      return ".cursor/rules/instructions.mdc";
-    default:
-      return "CLAUDE.md";
-  }
-}
-function getMCPConfigPath(agent) {
-  switch (agent) {
-    case "claude-code":
-      return ".mcp.json";
-    case "cursor":
-      return ".cursor/mcp.json";
-    case "github-copilot":
-    default:
-      return ".vscode/mcp.json";
-  }
-}
 
 // src/index.ts
-function getInstructionFilePath3(agent) {
-  switch (agent) {
-    case "claude-code":
-      return "CLAUDE.md";
-    case "github-copilot":
-      return ".github/copilot-instructions.md";
-    case "cursor":
-      return ".cursor/rules/instructions.mdc";
-    default:
-      return "CLAUDE.md";
-  }
-}
-function getMCPConfigPath2(agent) {
-  switch (agent) {
-    case "claude-code":
-      return ".mcp.json";
-    case "cursor":
-      return ".cursor/mcp.json";
-    case "github-copilot":
-    default:
-      return ".vscode/mcp.json";
-  }
-}
 function formatMCPCommand(server) {
   if (server.url) return server.url;
   if (server.command) return `${server.command} ${(server.args ?? []).join(" ")}`.trimEnd();
@@ -4545,27 +4806,27 @@ var dim = (text) => `\x1B[2m${text}\x1B[0m`;
 var yellow = (text) => `\x1B[33m${text}\x1B[0m`;
 var green = (text) => `\x1B[32m${text}\x1B[0m`;
 function detectMarkerFileMode(filePath, markerStart) {
-  if (!(0, import_fs8.existsSync)(filePath)) return green("create");
-  const content = (0, import_fs8.readFileSync)(filePath, "utf-8");
+  if (!(0, import_fs9.existsSync)(filePath)) return green("create");
+  const content = (0, import_fs9.readFileSync)(filePath, "utf-8");
   if (content.includes(markerStart)) return yellow("update");
   return yellow("append");
 }
 function detectMCPFileMode(filePath) {
-  if (!(0, import_fs8.existsSync)(filePath)) return green("create");
+  if (!(0, import_fs9.existsSync)(filePath)) return green("create");
   return yellow("merge");
 }
 function detectContextMode(projectPath, domain) {
-  const contextDir = (0, import_path8.join)(projectPath, "_ai-context", domain.toUpperCase());
-  const contextDirLower = (0, import_path8.join)(projectPath, "_ai-context", domain);
-  if ((0, import_fs8.existsSync)(contextDir) || (0, import_fs8.existsSync)(contextDirLower)) return yellow("overwrite");
+  const contextDir = (0, import_path9.join)(projectPath, "_ai-context", domain.toUpperCase());
+  const contextDirLower = (0, import_path9.join)(projectPath, "_ai-context", domain);
+  if ((0, import_fs9.existsSync)(contextDir) || (0, import_fs9.existsSync)(contextDirLower)) return yellow("overwrite");
   return green("create");
 }
 function waitForEnter() {
   const rl = (0, import_readline.createInterface)({ input: process.stdin, output: process.stdout });
-  return new Promise((resolve4) => {
+  return new Promise((resolve5) => {
     rl.question("  Press Enter to close...", () => {
       rl.close();
-      resolve4();
+      resolve5();
     });
   });
 }
@@ -4648,17 +4909,20 @@ async function collectInputs(options, releaseVersion, factoryAvailable = false)
       mcpConfig["azure-devops"].args = mcpConfig["azure-devops"].args?.map(
         (arg) => arg === "__AZURE_ORG__" ? azureDevOpsOrg : arg
       );
+      if (mcpConfig["azure-devops"].installCommand) {
+        mcpConfig["azure-devops"].installCommand = mcpConfig["azure-devops"].installCommand.replace(/__AZURE_ORG__/g, azureDevOpsOrg);
+      }
     }
   }
   const projectInput = await esm_default4({
     message: "Project directory:",
-    default: (0, import_path8.resolve)(process.cwd())
+    default: (0, import_path9.resolve)(process.cwd())
   });
   return {
     technologies: selectedTechnologies,
     agent,
     azureDevOpsOrg,
-    projectPath: (0, import_path8.resolve)(projectInput),
+    projectPath: (0, import_path9.resolve)(projectInput),
     baseMcpServers: options.baseMcpServers,
     mcpConfig,
     releaseVersion,
@@ -4668,12 +4932,13 @@ async function collectInputs(options, releaseVersion, factoryAvailable = false)
 async function previewAndConfirm(config, options) {
   const technologyNames = config.technologies.length > 0 ? config.technologies.map((p) => p.name.replace(/ Developer$/, "")).join(", ") : "None";
   const agentDisplay = options.agents.find((a) => a.value === config.agent)?.name ?? config.agent;
-  const instructionFile = getInstructionFilePath3(config.agent);
-  const mcpConfigFile = getMCPConfigPath2(config.agent);
+  const target = getAgentTarget(config.agent);
+  const instructionFile = target.instructions;
+  const mcpConfigFile = target.mcpConfig;
   const serverEntries = Object.entries(config.mcpConfig);
-  const instructionFilePath = (0, import_path8.join)(config.projectPath, instructionFile);
-  const mcpConfigFilePath = (0, import_path8.join)(config.projectPath, mcpConfigFile);
-  const gitignorePath = (0, import_path8.join)(config.projectPath, ".gitignore");
+  const instructionFilePath = (0, import_path9.join)(config.projectPath, instructionFile);
+  const mcpConfigFilePath = (0, import_path9.join)(config.projectPath, mcpConfigFile);
+  const gitignorePath = (0, import_path9.join)(config.projectPath, ".gitignore");
   const instructionMode = detectMarkerFileMode(instructionFilePath, "<!-- one-shot-installer:start -->");
   const mcpMode = detectMCPFileMode(mcpConfigFilePath);
   const gitignoreMode = detectMarkerFileMode(gitignorePath, "# one-shot-installer:start");
@@ -4699,7 +4964,7 @@ 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_fs8.existsSync)((0, import_path8.join)(config.projectPath, "factory"));
+    const factoryExists = (0, import_fs9.existsSync)((0, import_path9.join)(config.projectPath, "factory"));
     const factoryMode = factoryExists ? yellow("overwrite") : green("create");
     console.log(`    ${"factory/".padEnd(domainColWidth + 14)}${factoryMode}`);
   }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dlw-machine-setup",
-  "version": "0.5.17",
+  "version": "0.6.0",
   "description": "One-shot installer for The Machine toolchain",
   "bin": {
     "dlw-machine-setup": "bin/installer.js"