dlw-machine-setup 0.6.0 → 0.6.2

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 resolve5;
+    let resolve4;
     let reject;
     const promise = new Promise((res, rej) => {
-      resolve5 = res;
+      resolve4 = res;
       reject = rej;
     });
-    return { promise, resolve: resolve5, reject };
+    return { promise, resolve: resolve4, reject };
   }
 };
 
@@ -2776,7 +2776,7 @@ function createPrompt(view) {
       output
     });
     const screen = new ScreenManager(rl);
-    const { promise, resolve: resolve5, reject } = PromisePolyfill.withResolver();
+    const { promise, resolve: resolve4, 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(() => resolve5(value));
+            setImmediate(() => resolve4(value));
           });
           const [content, bottomContent] = typeof nextView === "string" ? [nextView] : nextView;
           screen.render(content, bottomContent);
@@ -3244,14 +3244,32 @@ ${page}${helpTipBottom}${choiceDescription}${import_ansi_escapes3.default.cursor
 });
 
 // src/index.ts
-var import_fs9 = require("fs");
+var import_fs11 = require("fs");
 var import_readline = require("readline");
-var import_path9 = require("path");
+var import_path12 = require("path");
 
 // src/utils/fetch.ts
 var DEFAULT_TIMEOUT_MS = 3e4;
 var DEFAULT_MAX_RETRIES = 3;
 var DEFAULT_RETRY_DELAY_MS = 2e3;
+function getReadableError(status) {
+  switch (status) {
+    case 401:
+      return "Authentication failed. Check your GitHub token.";
+    case 403:
+      return "Access denied. Verify token permissions and rate limits.";
+    case 404:
+      return "Resource not found. Verify the repository and release exist.";
+    case 429:
+      return "Rate limit exceeded. Please wait and try again.";
+    case 500:
+    case 502:
+    case 503:
+      return "GitHub server error. Please try again later.";
+    default:
+      return `Unexpected error (${status})`;
+  }
+}
 async function fetchWithTimeout(url, options = {}, timeoutMs = DEFAULT_TIMEOUT_MS) {
   const controller = new AbortController();
   const timer = setTimeout(() => controller.abort(), timeoutMs);
@@ -3283,40 +3301,102 @@ async function fetchWithRetry(url, options = {}, maxRetries = DEFAULT_MAX_RETRIE
     }
     if (attempt < maxRetries) {
       const delay = retryDelayMs * Math.pow(2, attempt - 1);
-      await new Promise((resolve5) => setTimeout(resolve5, delay));
+      await new Promise((resolve4) => setTimeout(resolve4, delay));
     }
   }
   throw lastError || new Error("Failed after maximum retries");
 }
 
+// src/utils/download-archive.ts
+var import_fs = require("fs");
+var import_path = require("path");
+var import_child_process = require("child_process");
+var MIN_FILE_SIZE = 1024;
+async function fetchLatestRelease(token, repo) {
+  const headers = {
+    "Accept": "application/vnd.github+json",
+    "Authorization": `Bearer ${token}`
+  };
+  const res = await fetchWithRetry(`https://api.github.com/repos/${repo}/releases/latest`, { headers });
+  if (!res.ok) {
+    throw new Error(`GitHub API error (${res.status}): ${getReadableError(res.status)}`);
+  }
+  const data = await res.json();
+  return { tagName: data.tag_name ?? "unknown", assets: data.assets ?? [] };
+}
+async function downloadAndExtractAsset(token, asset, projectPath, tempDirName) {
+  const tarCheck = (0, import_child_process.spawnSync)("tar", ["--version"], { stdio: "ignore" });
+  if (tarCheck.status !== 0) {
+    throw new Error("tar command not found. Please ensure tar is installed and available in your PATH.");
+  }
+  const tempDir = (0, import_path.join)(projectPath, tempDirName);
+  if ((0, import_fs.existsSync)(tempDir)) (0, import_fs.rmSync)(tempDir, { recursive: true, force: true });
+  (0, import_fs.mkdirSync)(tempDir, { recursive: true });
+  const cleanup = () => {
+    if ((0, import_fs.existsSync)(tempDir)) {
+      try {
+        (0, import_fs.rmSync)(tempDir, { recursive: true, force: true });
+      } catch {
+      }
+    }
+  };
+  try {
+    const dlRes = await fetchWithRetry(asset.url, {
+      headers: { "Accept": "application/octet-stream", "Authorization": `Bearer ${token}` }
+    });
+    if (!dlRes.ok) {
+      throw new Error(`Download failed: ${getReadableError(dlRes.status)}`);
+    }
+    const archivePath = (0, import_path.join)(tempDir, asset.name);
+    (0, import_fs.writeFileSync)(archivePath, Buffer.from(await dlRes.arrayBuffer()));
+    if ((0, import_fs.statSync)(archivePath).size < MIN_FILE_SIZE) {
+      throw new Error("File corrupted");
+    }
+    const list = (0, import_child_process.spawnSync)("tar", ["-tzf", archivePath], { encoding: "utf8" });
+    if (list.status !== 0) throw new Error("Failed to read archive contents");
+    const resolvedTemp = (0, import_path.resolve)(tempDir);
+    for (const entry of list.stdout.split("\n").filter(Boolean)) {
+      const path = (0, import_path.resolve)((0, import_path.join)(tempDir, entry.replace(/\/$/, "")));
+      if (!path.startsWith(resolvedTemp + import_path.sep)) {
+        throw new Error(`Archive contains unsafe path: ${entry}`);
+      }
+    }
+    const ex = (0, import_child_process.spawnSync)("tar", ["-xzf", archivePath, "-C", tempDir], { stdio: "ignore" });
+    if (ex.status !== 0) throw new Error("Archive extraction failed");
+    return { extractedRoot: tempDir, cleanup };
+  } catch (err) {
+    cleanup();
+    throw err;
+  }
+}
+
 // src/utils/wizard-options.ts
 async function fetchWizardOptions(token, repo) {
-  try {
-    const headers = {
-      "Accept": "application/vnd.github+json",
+  const release = await fetchLatestRelease(token, repo);
+  const asset = release.assets.find((a) => a.name === "wizard-options.json");
+  if (!asset) {
+    throw new Error("wizard-options.json not present in latest release");
+  }
+  const assetRes = await fetchWithRetry(asset.url, {
+    headers: {
+      "Accept": "application/octet-stream",
       "Authorization": `Bearer ${token}`
-    };
-    const releaseRes = await fetchWithRetry(
-      `https://api.github.com/repos/${repo}/releases/latest`,
-      { headers }
-    );
-    if (!releaseRes.ok) return null;
-    const release = await releaseRes.json();
-    const asset = release.assets?.find((a) => a.name === "wizard-options.json");
-    if (!asset) return null;
-    const assetRes = await fetchWithRetry(asset.url, {
-      headers: { ...headers, "Accept": "application/octet-stream" }
-    });
-    if (!assetRes.ok) return null;
-    const data = await assetRes.json();
-    const techArray = data.personas?.technologies ?? data.personas?.personas;
-    if (!Array.isArray(data.agents) || !Array.isArray(techArray)) {
-      return null;
     }
-    return { options: data, releaseVersion: release.tag_name ?? "unknown" };
-  } catch {
-    return null;
+  });
+  if (!assetRes.ok) {
+    throw new Error(`wizard-options.json download failed: ${getReadableError(assetRes.status)}`);
+  }
+  let data;
+  try {
+    data = await assetRes.json();
+  } catch (e) {
+    throw new Error(`wizard-options.json is not valid JSON: ${e instanceof Error ? e.message : String(e)}`);
+  }
+  const techArray = data.personas?.technologies ?? data.personas?.personas;
+  if (!Array.isArray(data.agents) || !Array.isArray(techArray)) {
+    throw new Error("wizard-options.json is missing required arrays (agents, technologies)");
   }
+  return { options: data, releaseVersion: release.tagName };
 }
 
 // src/utils/discover-repo.ts
@@ -3385,46 +3465,44 @@ async function tryOrgReposList(headers, topic) {
 }
 
 // src/utils/github-auth.ts
-var import_fs = require("fs");
-var import_path = require("path");
+var import_fs2 = require("fs");
+var import_path2 = require("path");
 var import_os = require("os");
-var import_child_process = require("child_process");
+var import_child_process2 = require("child_process");
 var GITHUB_CLIENT_ID = "Ov23liwpMumAhwVufZ7N";
 var GITHUB_DEVICE_CODE_URL = "https://github.com/login/device/code";
 var GITHUB_TOKEN_URL = "https://github.com/login/oauth/access_token";
+var SOFT_TTL_MS = 24 * 60 * 60 * 1e3;
 function getTokenCachePath() {
-  const configDir = (0, import_path.join)((0, import_os.homedir)(), ".one-shot-installer");
-  if (!(0, import_fs.existsSync)(configDir)) {
-    (0, import_fs.mkdirSync)(configDir, { recursive: true });
+  const configDir = (0, import_path2.join)((0, import_os.homedir)(), ".one-shot-installer");
+  if (!(0, import_fs2.existsSync)(configDir)) {
+    (0, import_fs2.mkdirSync)(configDir, { recursive: true });
   }
-  return (0, import_path.join)(configDir, "github-token.json");
+  return (0, import_path2.join)(configDir, "github-token.json");
 }
 function loadCachedToken() {
   const cachePath = getTokenCachePath();
-  if (!(0, import_fs.existsSync)(cachePath)) {
-    return null;
-  }
+  if (!(0, import_fs2.existsSync)(cachePath)) return null;
   try {
-    const data = (0, import_fs.readFileSync)(cachePath, "utf-8");
-    const cached = JSON.parse(data);
-    return cached.access_token;
-  } catch (error) {
+    const data = (0, import_fs2.readFileSync)(cachePath, "utf-8");
+    return JSON.parse(data);
+  } catch {
     return null;
   }
 }
 function saveTokenToCache(token) {
   const cachePath = getTokenCachePath();
-  const cached = {
+  const cached2 = {
     access_token: token,
     created_at: Date.now()
   };
-  (0, import_fs.writeFileSync)(cachePath, JSON.stringify(cached, null, 2), { encoding: "utf-8", mode: 384 });
+  (0, import_fs2.writeFileSync)(cachePath, JSON.stringify(cached2, null, 2), { encoding: "utf-8", mode: 384 });
 }
 function clearTokenCache() {
   const cachePath = getTokenCachePath();
-  if ((0, import_fs.existsSync)(cachePath)) {
+  if ((0, import_fs2.existsSync)(cachePath)) {
     try {
-      (0, import_fs.unlinkSync)(cachePath);
+      (0, import_fs2.unlinkSync)(cachePath);
     } catch (error) {
     }
   }
@@ -3451,7 +3529,7 @@ async function pollForToken(deviceCode, interval) {
   const maxAttempts = 60;
   let attempts = 0;
   while (attempts < maxAttempts) {
-    await new Promise((resolve5) => setTimeout(resolve5, interval * 1e3));
+    await new Promise((resolve4) => setTimeout(resolve4, interval * 1e3));
     const response = await fetchWithTimeout(GITHUB_TOKEN_URL, {
       method: "POST",
       headers: {
@@ -3499,11 +3577,14 @@ async function authenticateWithGitHub() {
     }
     console.log("  GITHUB_TOKEN env var is invalid or expired, falling back to authentication...\n");
   }
-  const cachedToken = loadCachedToken();
-  if (cachedToken) {
-    const isValid = await verifyToken(cachedToken);
+  const cached2 = loadCachedToken();
+  if (cached2) {
+    const fresh = Date.now() - cached2.created_at < SOFT_TTL_MS;
+    if (fresh) return cached2.access_token;
+    const isValid = await verifyToken(cached2.access_token);
     if (isValid) {
-      return cachedToken;
+      saveTokenToCache(cached2.access_token);
+      return cached2.access_token;
     }
     clearTokenCache();
   }
@@ -3516,13 +3597,13 @@ async function authenticateWithGitHub() {
   try {
     const os = (0, import_os.platform)();
     if (os === "win32") {
-      (0, import_child_process.execSync)(`echo ${deviceCodeData.user_code} | clip`, { stdio: "ignore" });
+      (0, import_child_process2.execSync)(`echo ${deviceCodeData.user_code} | clip`, { stdio: "ignore" });
       copied = true;
     } else if (os === "darwin") {
-      (0, import_child_process.execSync)(`echo "${deviceCodeData.user_code}" | pbcopy`, { stdio: "ignore" });
+      (0, import_child_process2.execSync)(`echo "${deviceCodeData.user_code}" | pbcopy`, { stdio: "ignore" });
       copied = true;
     } else {
-      (0, import_child_process.execSync)(`echo "${deviceCodeData.user_code}" | xclip -selection clipboard`, { stdio: "ignore" });
+      (0, import_child_process2.execSync)(`echo "${deviceCodeData.user_code}" | xclip -selection clipboard`, { stdio: "ignore" });
       copied = true;
     }
   } catch {
@@ -3604,11 +3685,7 @@ function getAgentTarget(agent) {
 
 // src/utils/mod.ts
 async function loadWizardOptions(token, repo) {
-  const remote = await fetchWizardOptions(token, repo);
-  if (!remote) {
-    throw new Error("Failed to load configuration from GitHub release. Check your network and token.");
-  }
-  const { options, releaseVersion } = remote;
+  const { options, releaseVersion } = await fetchWizardOptions(token, repo);
   const filteredMcpServers = Object.fromEntries(
     Object.entries(options.mcpServers).filter(([, config]) => config.active !== false)
   );
@@ -3671,10 +3748,23 @@ __export(steps_exports, {
 });
 
 // src/steps/resources/fetch-contexts.ts
-var import_fs2 = require("fs");
-var import_path2 = require("path");
-var import_child_process2 = require("child_process");
-var MIN_FILE_SIZE = 1024;
+var import_fs4 = require("fs");
+var import_path4 = require("path");
+
+// src/utils/fs-copy.ts
+var import_fs3 = require("fs");
+var import_path3 = 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 (entry.isDirectory()) copyDirectory(s, t);
+    else (0, import_fs3.copyFileSync)(s, t);
+  }
+}
+
+// src/steps/resources/fetch-contexts.ts
 var fetch_contexts_default = defineStep({
   name: "fetch-contexts",
   label: "Downloading contexts",
@@ -3683,9 +3773,6 @@ var fetch_contexts_default = defineStep({
     const uniqueDomains = [...new Set(ctx.config.technologies.flatMap((p) => p.domains))];
     const domainValues = uniqueDomains.map((d) => d.toLowerCase());
     if (!ctx.contextRepo) {
-      for (const domain of domainValues) {
-        ctx.installed.domainsFailed = domainValues;
-      }
       return {
         status: "failed",
         detail: "Context repo not found (topic: context-data)"
@@ -3693,8 +3780,6 @@ var fetch_contexts_default = defineStep({
     }
     const downloadResult = await fetchContexts(domainValues, ctx.token, ctx.contextRepo, ctx.config.projectPath);
     ctx.installed.domainsInstalled = downloadResult.successful;
-    ctx.installed.domainsFailed = downloadResult.failed;
-    ctx.installed.failureReasons = downloadResult.failureReasons;
     ctx.installed.contextReleaseVersion = downloadResult.releaseVersion;
     const domainColWidth = Math.max(...domainValues.map((d) => d.length), 8) + 2;
     console.log("");
@@ -3719,24 +3804,9 @@ var fetch_contexts_default = defineStep({
 async function fetchContexts(domains, token, repo, targetDir) {
   const result = { successful: [], failed: [], failureReasons: {} };
   if (domains.length === 0) return result;
-  const tarCheck = (0, import_child_process2.spawnSync)("tar", ["--version"], { stdio: "ignore" });
-  if (tarCheck.status !== 0) {
-    throw new Error("tar command not found. Please ensure tar is installed and available in your PATH.");
-  }
-  const headers = {
-    "Accept": "application/vnd.github+json",
-    "Authorization": `Bearer ${token}`
-  };
-  const releaseResponse = await fetchWithRetry(
-    `https://api.github.com/repos/${repo}/releases/latest`,
-    { headers }
-  );
-  if (!releaseResponse.ok) {
-    throw new Error(`GitHub API error (${releaseResponse.status}): ${getReadableError(releaseResponse.status)}`);
-  }
-  const releaseData = await releaseResponse.json();
-  result.releaseVersion = releaseData.tag_name;
-  const asset = releaseData.assets?.find((a) => a.name.endsWith(".tar.gz"));
+  const release = await fetchLatestRelease(token, repo);
+  result.releaseVersion = release.tagName;
+  const asset = release.assets.find((a) => a.name.endsWith(".tar.gz"));
   if (!asset) {
     for (const domain of domains) {
       result.failed.push(domain);
@@ -3744,39 +3814,11 @@ async function fetchContexts(domains, token, repo, targetDir) {
     }
     return result;
   }
-  const contextsDir = (0, import_path2.join)(targetDir, "_ai-context");
-  const tempDir = (0, import_path2.join)(targetDir, ".temp-download");
+  const contextsDir = (0, import_path4.join)(targetDir, "_ai-context");
+  if (!(0, import_fs4.existsSync)(contextsDir)) (0, import_fs4.mkdirSync)(contextsDir, { recursive: true });
+  const archive = await downloadAndExtractAsset(token, asset, targetDir, ".temp-download");
   try {
-    if (!(0, import_fs2.existsSync)(contextsDir)) (0, import_fs2.mkdirSync)(contextsDir, { recursive: true });
-    if ((0, import_fs2.existsSync)(tempDir)) (0, import_fs2.rmSync)(tempDir, { recursive: true, force: true });
-    (0, import_fs2.mkdirSync)(tempDir, { recursive: true });
-    const downloadHeaders = {
-      "Accept": "application/octet-stream",
-      "Authorization": `Bearer ${token}`
-    };
-    const response = await fetchWithRetry(asset.url, { headers: downloadHeaders });
-    if (!response.ok) {
-      throw new Error(`Download failed: ${getReadableError(response.status)}`);
-    }
-    const archivePath = (0, import_path2.join)(tempDir, asset.name);
-    const arrayBuffer = await response.arrayBuffer();
-    (0, import_fs2.writeFileSync)(archivePath, Buffer.from(arrayBuffer));
-    const stats = (0, import_fs2.statSync)(archivePath);
-    if (stats.size < MIN_FILE_SIZE) {
-      throw new Error("File corrupted");
-    }
-    const listResult = (0, import_child_process2.spawnSync)("tar", ["-tzf", archivePath], { encoding: "utf8" });
-    if (listResult.status !== 0) throw new Error("Failed to read archive contents");
-    const resolvedTempDir = (0, import_path2.resolve)(tempDir);
-    for (const entry of listResult.stdout.split("\n").filter(Boolean)) {
-      const entryPath = (0, import_path2.resolve)((0, import_path2.join)(tempDir, entry.replace(/\/$/, "")));
-      if (!entryPath.startsWith(resolvedTempDir + import_path2.sep)) {
-        throw new Error(`Archive contains unsafe path: ${entry}`);
-      }
-    }
-    const extractResult = (0, import_child_process2.spawnSync)("tar", ["-xzf", archivePath, "-C", tempDir], { stdio: "ignore" });
-    if (extractResult.status !== 0) throw new Error("Archive extraction failed");
-    const extractedFolders = (0, import_fs2.readdirSync)(tempDir, { withFileTypes: true }).filter((e) => e.isDirectory()).map((e) => e.name);
+    const extractedFolders = (0, import_fs4.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());
@@ -3785,8 +3827,8 @@ async function fetchContexts(domains, token, repo, targetDir) {
           result.failureReasons[domain] = "Not found in archive";
           continue;
         }
-        const domainPath = (0, import_path2.join)(contextsDir, domain);
-        copyDirectory((0, import_path2.join)(tempDir, match), domainPath);
+        const domainPath = (0, import_path4.join)(contextsDir, domain);
+        copyDirectory((0, import_path4.join)(archive.extractedRoot, match), domainPath);
         result.successful.push(domain);
       } catch (error) {
         result.failed.push(domain);
@@ -3794,59 +3836,51 @@ async function fetchContexts(domains, token, repo, targetDir) {
       }
     }
   } finally {
-    if ((0, import_fs2.existsSync)(tempDir)) {
-      try {
-        (0, import_fs2.rmSync)(tempDir, { recursive: true, force: true });
-      } catch {
-      }
-    }
+    archive.cleanup();
   }
   return result;
 }
-function copyDirectory(source, target) {
-  if (!(0, import_fs2.existsSync)(target)) (0, import_fs2.mkdirSync)(target, { recursive: true });
-  const entries = (0, import_fs2.readdirSync)(source, { withFileTypes: true });
-  for (const entry of entries) {
-    const sourcePath = (0, import_path2.join)(source, entry.name);
-    const targetPath = (0, import_path2.join)(target, entry.name);
-    if (entry.isDirectory()) {
-      copyDirectory(sourcePath, targetPath);
-    } else {
-      (0, import_fs2.copyFileSync)(sourcePath, targetPath);
-    }
-  }
-}
-function getReadableError(status) {
-  switch (status) {
-    case 401:
-      return "Authentication failed. Check your GitHub token.";
-    case 403:
-      return "Access denied. Verify token permissions and rate limits.";
-    case 404:
-      return "Resource not found. Verify the repository and release exist.";
-    case 429:
-      return "Rate limit exceeded. Please wait and try again.";
-    case 500:
-    case 502:
-    case 503:
-      return "GitHub server error. Please try again later.";
-    default:
-      return `Unexpected error (${status})`;
-  }
-}
 
 // src/steps/resources/fetch-factory.ts
-var import_fs4 = require("fs");
-var import_path4 = require("path");
-var import_child_process3 = require("child_process");
+var import_fs7 = require("fs");
+var import_path7 = require("path");
 
 // src/bundles/run-bundle.ts
-var import_fs3 = require("fs");
-var import_path3 = require("path");
+var import_fs6 = require("fs");
+var import_path6 = require("path");
 
 // src/bundles/types.ts
 var SCHEMA_VERSION = 1;
 
+// src/utils/marker-block.ts
+var import_fs5 = require("fs");
+var import_path5 = 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");
+    return;
+  }
+  const existing = (0, import_fs5.readFileSync)(filePath, "utf-8");
+  const s = existing.indexOf(startMarker);
+  const e = existing.indexOf(endMarker);
+  const hasS = s !== -1;
+  const hasE = e !== -1;
+  if (hasS && !hasE || !hasS && hasE || hasS && hasE && e < s) {
+    opts.onCorrupt?.(filePath, startMarker, 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");
+  } else {
+    const sep3 = existing.endsWith("\n") ? "\n" : "\n\n";
+    (0, import_fs5.writeFileSync)(filePath, existing + sep3 + block + "\n", "utf-8");
+  }
+}
+
 // src/bundles/run-bundle.ts
 var OWNER_KEY = "_bundleOwner";
 async function runBundle(manifest, ctx) {
@@ -3864,7 +3898,7 @@ async function runBundle(manifest, ctx) {
   }
   if (manifest.gitignore?.length) {
     upsertMarkerBlock(
-      (0, import_path3.join)(ctx.projectPath, ".gitignore"),
+      (0, import_path6.join)(ctx.projectPath, ".gitignore"),
       `# ${manifest.name}:start`,
       `# ${manifest.name}:end`,
       manifest.gitignore.join("\n")
@@ -3876,7 +3910,7 @@ async function runBundle(manifest, ctx) {
     result.instructionsSnippet = snippet;
     if (!ctx.skipInstructions) {
       upsertMarkerBlock(
-        (0, import_path3.join)(ctx.projectPath, ctx.instructionsFile),
+        (0, import_path6.join)(ctx.projectPath, ctx.instructionsFile),
         `<!-- ${manifest.name}:start -->`,
         `<!-- ${manifest.name}:end -->`,
         snippet
@@ -3903,12 +3937,12 @@ 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_fs3.existsSync)(source)) return;
-  if ((0, import_fs3.statSync)(source).isDirectory()) {
-    copyDirectory2(source, target);
+  if (!(0, import_fs6.existsSync)(source)) return;
+  if ((0, import_fs6.statSync)(source).isDirectory()) {
+    copyDirectory(source, target);
   } else {
-    (0, import_fs3.mkdirSync)((0, import_path3.dirname)(target), { recursive: true });
-    (0, import_fs3.copyFileSync)(source, target);
+    (0, import_fs6.mkdirSync)((0, import_path6.dirname)(target), { recursive: true });
+    (0, import_fs6.copyFileSync)(source, target);
   }
   result.filesTouched.push(op.to);
 }
@@ -3918,14 +3952,14 @@ function runMergeJson(op, owner, ctx, result) {
   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");
+  (0, import_fs6.mkdirSync)((0, import_path6.dirname)(filePath), { recursive: true });
+  (0, import_fs6.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 {};
+  if (!(0, import_fs6.existsSync)(path)) return {};
   try {
-    return JSON.parse((0, import_fs3.readFileSync)(path, "utf-8"));
+    return JSON.parse((0, import_fs6.readFileSync)(path, "utf-8"));
   } catch {
     return {};
   }
@@ -3970,38 +4004,18 @@ function deepMerge2(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)) {
+  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)) {
     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)) {
+  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)) {
     throw new Error(`Bundle op "to" escapes project path: ${rel}`);
   }
   return full;
@@ -4019,22 +4033,12 @@ function assertSchemaCompatible(manifest) {
   }
 }
 function assertBundleRootExists(ctx) {
-  if (!(0, import_fs3.existsSync)(ctx.bundleRoot) || !(0, import_fs3.statSync)(ctx.bundleRoot).isDirectory()) {
+  if (!(0, import_fs6.existsSync)(ctx.bundleRoot) || !(0, import_fs6.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) {
     case "github-copilot":
@@ -4050,114 +4054,58 @@ 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;
+      ctx.installed.factoryInstructionsSnippet = result.instructionsSnippet;
     }
     if (!result.success) {
       return { status: "failed", detail: result.failureReason };
     }
-    const tag = result.bundleManaged ? " (bundle)" : "";
-    return { status: "success", message: result.filesInstalled.join(", ") + tag };
+    return { status: "success", message: result.filesInstalled.join(", ") };
   }
 });
 async function fetchFactory(token, repo, targetDir, agent) {
   const result = { success: false, filesInstalled: [] };
-  const tarCheck = (0, import_child_process3.spawnSync)("tar", ["--version"], { stdio: "ignore" });
-  if (tarCheck.status !== 0) {
-    result.failureReason = "tar command not found";
-    return result;
-  }
   const { assetName, rootFolder } = getFactoryAsset(agent);
-  const headers = {
-    "Accept": "application/vnd.github+json",
-    "Authorization": `Bearer ${token}`
-  };
-  const releaseResponse = await fetchWithRetry(
-    `https://api.github.com/repos/${repo}/releases/latest`,
-    { headers }
-  );
-  if (!releaseResponse.ok) {
-    result.failureReason = `GitHub API error (${releaseResponse.status})`;
+  let release;
+  try {
+    release = await fetchLatestRelease(token, repo);
+  } catch (err) {
+    result.failureReason = err instanceof Error ? err.message : String(err);
     return result;
   }
-  const releaseData = await releaseResponse.json();
-  const asset = releaseData.assets?.find((a) => a.name === assetName);
+  const asset = release.assets.find((a) => a.name === assetName);
   if (!asset) {
     result.failureReason = `${assetName} not found in release`;
     return result;
   }
-  const tempDir = (0, import_path4.join)(targetDir, ".temp-factory-download");
+  let archive = null;
   try {
-    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}` }
-    });
-    if (!response.ok) {
-      result.failureReason = `Download failed (${response.status})`;
-      return result;
-    }
-    const archivePath = (0, import_path4.join)(tempDir, assetName);
-    const arrayBuffer = await response.arrayBuffer();
-    (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;
-    }
-    const listResult = (0, import_child_process3.spawnSync)("tar", ["-tzf", archivePath], { encoding: "utf8" });
-    if (listResult.status !== 0) {
-      result.failureReason = "Failed to read archive contents";
-      return result;
-    }
-    const resolvedTempDir = (0, import_path4.resolve)(tempDir);
-    for (const entry of listResult.stdout.split("\n").filter(Boolean)) {
-      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;
-      }
-    }
-    const extractResult = (0, import_child_process3.spawnSync)("tar", ["-xzf", archivePath, "-C", tempDir], { stdio: "ignore" });
-    if (extractResult.status !== 0) {
-      result.failureReason = "Archive extraction failed";
-      return result;
-    }
-    const extractedEntries = (0, import_fs4.readdirSync)(tempDir);
+    archive = await downloadAndExtractAsset(token, asset, targetDir, ".temp-factory-download");
+    const extractedEntries = (0, import_fs7.readdirSync)(archive.extractedRoot);
     const extractedFolder = extractedEntries.find((e) => e.toLowerCase() === rootFolder.toLowerCase());
     if (!extractedFolder) {
       result.failureReason = `No ${rootFolder}/ folder in archive`;
       return result;
     }
-    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);
+    const extractedPath = (0, import_path7.join)(archive.extractedRoot, extractedFolder);
+    const manifestPath = (0, import_path7.join)(extractedPath, "install.json");
+    if (!(0, import_fs7.existsSync)(manifestPath)) {
+      result.failureReason = "Factory archive has no install.json \u2014 upgrade Factory or downgrade installer";
+      return result;
     }
+    await installViaBundle(manifestPath, extractedPath, targetDir, agent, result);
     result.success = true;
   } catch (error) {
     result.failureReason = error instanceof Error ? error.message : String(error);
   } finally {
-    if ((0, import_fs4.existsSync)(tempDir)) {
-      try {
-        (0, import_fs4.rmSync)(tempDir, { recursive: true, force: true });
-      } catch {
-      }
-    }
+    archive?.cleanup();
   }
   return result;
 }
 async function installViaBundle(manifestPath, extractedPath, targetDir, agent, result) {
   let manifest;
   try {
-    manifest = JSON.parse((0, import_fs4.readFileSync)(manifestPath, "utf-8"));
+    manifest = JSON.parse((0, import_fs7.readFileSync)(manifestPath, "utf-8"));
   } catch (e) {
     throw new Error(`install.json is not valid JSON: ${e instanceof Error ? e.message : String(e)}`);
   }
@@ -4170,145 +4118,18 @@ async function installViaBundle(manifestPath, extractedPath, targetDir, agent, r
     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_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_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_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_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_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_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_fs4.readdirSync)(extractedPath, { withFileTypes: true });
-  for (const entry of rootEntries) {
-    if (entry.isFile()) {
-      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}`);
-    }
-  }
-  configureSettings(claudeDir);
-  result.filesInstalled.push(".claude/settings.json");
-}
-function installCopilotFactory(extractedPath, targetDir, result) {
-  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}/`);
-    } else {
-      result.filesInstalled.push(`factory/${entry.name}`);
-    }
-  }
-}
-function configureSettings(claudeDir) {
-  const settingsPath = (0, import_path4.join)(claudeDir, "settings.json");
-  let settings = {};
-  if ((0, import_fs4.existsSync)(settingsPath)) {
-    try {
-      settings = JSON.parse((0, import_fs4.readFileSync)(settingsPath, "utf8"));
-    } catch {
-    }
-  }
-  if (!settings.hooks) settings.hooks = {};
-  const welcomeHook = {
-    hooks: [{ type: "command", command: "node .claude/hooks/factory-welcome.cjs" }]
-  };
-  const immutableGuardHook = {
-    matcher: "Write|Edit",
-    hooks: [{ type: "command", command: "node .claude/hooks/factory-immutable-guard.cjs" }]
-  };
-  const stateAdvanceHook = {
-    matcher: "Write|Edit",
-    hooks: [{ type: "command", command: "node .claude/hooks/factory-state-advance.cjs" }]
-  };
-  const contextMonitorHook = {
-    hooks: [{ type: "command", command: "node .claude/hooks/factory-context-monitor.cjs" }]
-  };
-  const stateGuardHook = {
-    hooks: [{ type: "command", command: "node .claude/hooks/factory-state-guard.cjs" }]
-  };
-  for (const event of ["SessionStart", "PreToolUse", "PostToolUse", "UserPromptSubmit"]) {
-    if (settings.hooks[event]) {
-      settings.hooks[event] = settings.hooks[event].filter(
-        (h) => !h.hooks?.some(
-          (hh) => hh.command?.includes("factory-welcome") || hh.command?.includes("factory-immutable-guard") || hh.command?.includes("factory-state-advance") || hh.command?.includes("factory-context-monitor") || hh.command?.includes("factory-state-guard")
-        )
-      );
-      if (settings.hooks[event].length === 0) delete settings.hooks[event];
-    }
-  }
-  if (!settings.hooks.SessionStart) settings.hooks.SessionStart = [];
-  settings.hooks.SessionStart.unshift(welcomeHook);
-  if (!settings.hooks.PreToolUse) settings.hooks.PreToolUse = [];
-  settings.hooks.PreToolUse.unshift(immutableGuardHook);
-  if (!settings.hooks.PostToolUse) settings.hooks.PostToolUse = [];
-  settings.hooks.PostToolUse.unshift(stateAdvanceHook);
-  if (!settings.hooks.UserPromptSubmit) {
-    settings.hooks.UserPromptSubmit = [stateGuardHook, contextMonitorHook];
-  } else {
-    const hasGuard = settings.hooks.UserPromptSubmit.some(
-      (h) => h.hooks?.some((hh) => hh.command?.includes("factory-state-guard"))
-    );
-    if (!hasGuard) settings.hooks.UserPromptSubmit.unshift(stateGuardHook);
-    const hasMonitor = settings.hooks.UserPromptSubmit.some(
-      (h) => h.hooks?.some((hh) => hh.command?.includes("factory-context-monitor"))
-    );
-    if (!hasMonitor) settings.hooks.UserPromptSubmit.push(contextMonitorHook);
-  }
-  settings.statusLine = { type: "command", command: "node .claude/hooks/factory-statusline.cjs" };
-  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 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_path4.join)(source, entry.name);
-    const targetPath = (0, import_path4.join)(target, entry.name);
-    if (entry.isDirectory()) {
-      copyDirectory3(sourcePath, targetPath);
-    } else {
-      (0, import_fs4.copyFileSync)(sourcePath, targetPath);
-    }
-  }
-}
 
 // src/steps/setup/write-instructions.ts
-var import_fs5 = require("fs");
-var import_path5 = require("path");
+var import_fs8 = require("fs");
+var import_path8 = require("path");
 
 // src/steps/shared.ts
+var cached = null;
 function getFilteredMcpConfig(ctx) {
+  if (cached) return cached;
   const successfulDomains = new Set(ctx.installed.domainsInstalled ?? []);
   const successfulTechnologies = ctx.config.technologies.filter(
     (p) => p.domains.every((d) => successfulDomains.has(d.toLowerCase()))
@@ -4317,9 +4138,10 @@ function getFilteredMcpConfig(ctx) {
     ...ctx.config.baseMcpServers,
     ...successfulTechnologies.flatMap((p) => p.mcpServers)
   ]);
-  return Object.fromEntries(
+  cached = Object.fromEntries(
     Object.entries(ctx.config.mcpConfig).filter(([name]) => successfulMcpServers.has(name))
   );
+  return cached;
 }
 
 // src/steps/setup/write-instructions.ts
@@ -4329,107 +4151,67 @@ 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 || Object.keys(ctx.installed.bundleInstructions ?? {}).length > 0,
+  when: (ctx) => (ctx.installed.domainsInstalled?.length ?? 0) > 0 || Object.keys(ctx.config.mcpConfig).length > 0 || !!ctx.installed.factoryInstructionsSnippet,
   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 factoryBundleManaged = ctx.installed.factoryBundleManaged ?? false;
-    const includeFactorySection = factoryInstalled && !factoryBundleManaged;
-    const content = buildCombinedInstructions(domains, filteredMcpConfig, agent, projectPath, includeFactorySection);
+    const content = buildCombinedInstructions(domains, filteredMcpConfig, agent, projectPath);
     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, `---
+    const filePath = (0, import_path8.join)(projectPath, target.instructions);
+    const fileDir = (0, import_path8.dirname)(filePath);
+    if (!(0, import_fs8.existsSync)(fileDir)) (0, import_fs8.mkdirSync)(fileDir, { recursive: true });
+    if (agent === "cursor" && !(0, import_fs8.existsSync)(filePath)) {
+      (0, import_fs8.writeFileSync)(filePath, `---
 description: AI development instructions from One-Shot Installer
 alwaysApply: true
 ---
 
 `, "utf-8");
     }
-    upsertBlock(filePath, content);
-    const bundleSnippets = ctx.installed.bundleInstructions ?? {};
-    for (const bundleName of Object.keys(bundleSnippets).sort()) {
-      upsertBundleBlock(filePath, bundleName, bundleSnippets[bundleName]);
+    upsertMarkerBlock(filePath, MARKER_START, MARKER_END, content, {
+      onCorrupt: (file) => {
+        const fileName = file.split(/[/\\]/).pop() ?? file;
+        const box = [
+          "",
+          red("  \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"),
+          red("  \u2551  \u26A0  INSTRUCTION FILE COULD NOT BE UPDATED       \u2551"),
+          red("  \u2551                                                  \u2551"),
+          red(`  \u2551  ${fileName} has corrupted markers.`.padEnd(52) + "\u2551"),
+          red("  \u2551  Fix: delete the lines containing                \u2551"),
+          red("  \u2551    <!-- one-shot-installer:start -->             \u2551"),
+          red("  \u2551    <!-- one-shot-installer:end -->               \u2551"),
+          red("  \u2551  Then re-run the installer.                      \u2551"),
+          red("  \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"),
+          ""
+        ].join("\n");
+        console.log(box);
+        throw new Error(`Corrupted markers in ${fileName} \u2014 fix manually and re-run`);
+      }
+    });
+    if (ctx.installed.factoryInstructionsSnippet) {
+      upsertMarkerBlock(
+        filePath,
+        "<!-- factory:start -->",
+        "<!-- factory:end -->",
+        ctx.installed.factoryInstructionsSnippet
+      );
     }
     return { status: "success", message: target.instructions };
   }
 });
-function upsertBlock(filePath, block) {
-  const marked = `${MARKER_START}
-${block}
-${MARKER_END}`;
-  if (!(0, import_fs5.existsSync)(filePath)) {
-    (0, import_fs5.writeFileSync)(filePath, marked, "utf-8");
-    return;
-  }
-  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;
-  const hasEnd = end !== -1;
-  if (hasStart && !hasEnd || !hasStart && hasEnd || hasStart && hasEnd && end < start) {
-    const fileName = filePath.split(/[/\\]/).pop() ?? filePath;
-    const box = [
-      "",
-      red("  \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"),
-      red("  \u2551  \u26A0  INSTRUCTION FILE COULD NOT BE UPDATED       \u2551"),
-      red("  \u2551                                                  \u2551"),
-      red(`  \u2551  ${fileName} has corrupted markers.`.padEnd(52) + "\u2551"),
-      red("  \u2551  Fix: delete the lines containing                \u2551"),
-      red("  \u2551    <!-- one-shot-installer:start -->             \u2551"),
-      red("  \u2551    <!-- one-shot-installer:end -->               \u2551"),
-      red("  \u2551  Then re-run the installer.                      \u2551"),
-      red("  \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"),
-      ""
-    ].join("\n");
-    console.log(box);
-    throw new Error(`Corrupted markers in ${fileName} \u2014 fix manually and re-run`);
-  }
-  if (hasStart && hasEnd) {
-    const updated = existing.slice(0, start) + marked + existing.slice(end + MARKER_END.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 + 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_fs5.existsSync)(dir)) return [];
-  const entries = (0, import_fs5.readdirSync)(dir, { recursive: true });
+  if (!(0, import_fs8.existsSync)(dir)) return [];
+  const entries = (0, import_fs8.readdirSync)(dir, { recursive: true });
   return entries.filter((entry) => {
-    const fullPath = (0, import_path5.join)(dir, entry);
-    return entry.endsWith(".md") && (0, import_fs5.statSync)(fullPath).isFile();
+    const fullPath = (0, import_path8.join)(dir, entry);
+    return entry.endsWith(".md") && (0, import_fs8.statSync)(fullPath).isFile();
   }).map((entry) => entry.replace(/\\/g, "/")).sort();
 }
 function extractFirstHeading(filePath) {
   try {
-    const content = (0, import_fs5.readFileSync)(filePath, "utf-8");
+    const content = (0, import_fs8.readFileSync)(filePath, "utf-8");
     const withoutFrontmatter = content.replace(/^---[\s\S]*?---\s*/, "");
     const match = withoutFrontmatter.match(/^#\s+(.+)/m);
     if (match) {
@@ -4447,16 +4229,16 @@ function formatPathRef(contextPath, description, agent) {
   return `- \`${contextPath}\` \u2014 ${description}`;
 }
 function resolveDomainFolder(domain, contextsDir) {
-  if ((0, import_fs5.existsSync)(contextsDir)) {
+  if ((0, import_fs8.existsSync)(contextsDir)) {
     try {
-      const entries = (0, import_fs5.readdirSync)(contextsDir);
+      const entries = (0, import_fs8.readdirSync)(contextsDir);
       const match = entries.find((e) => e.toLowerCase() === domain.toLowerCase());
-      if (match) return { folderName: match, folderPath: (0, import_path5.join)(contextsDir, match) };
+      if (match) return { folderName: match, folderPath: (0, import_path8.join)(contextsDir, match) };
     } catch {
     }
   }
   const fallback = domain.toUpperCase();
-  return { folderName: fallback, folderPath: (0, import_path5.join)(contextsDir, fallback) };
+  return { folderName: fallback, folderPath: (0, import_path8.join)(contextsDir, fallback) };
 }
 function buildContextRefsSection(domains, agent, contextsDir) {
   const lines2 = [
@@ -4468,34 +4250,34 @@ function buildContextRefsSection(domains, agent, contextsDir) {
   let hasAnyFiles = false;
   for (const domain of domains) {
     const { folderName, folderPath: domainPath } = resolveDomainFolder(domain, contextsDir);
-    if (!(0, import_fs5.existsSync)(domainPath)) continue;
+    if (!(0, import_fs8.existsSync)(domainPath)) continue;
     const domainFiles = [];
-    const ctxInstructions = (0, import_path5.join)(domainPath, "context-instructions.md");
-    if ((0, import_fs5.existsSync)(ctxInstructions)) {
+    const ctxInstructions = (0, import_path8.join)(domainPath, "context-instructions.md");
+    if ((0, import_fs8.existsSync)(ctxInstructions)) {
       const desc = extractFirstHeading(ctxInstructions);
       domainFiles.push(formatPathRef(`_ai-context/${folderName}/context-instructions.md`, desc, agent));
     }
-    const instructionsMd = (0, import_path5.join)(domainPath, "core", "instructions.md");
-    if ((0, import_fs5.existsSync)(instructionsMd)) {
+    const instructionsMd = (0, import_path8.join)(domainPath, "core", "instructions.md");
+    if ((0, import_fs8.existsSync)(instructionsMd)) {
       const desc = extractFirstHeading(instructionsMd);
       domainFiles.push(formatPathRef(`_ai-context/${folderName}/core/instructions.md`, `${desc} (start here)`, agent));
     }
-    const coreDir = (0, import_path5.join)(domainPath, "core");
-    if ((0, import_fs5.existsSync)(coreDir)) {
+    const coreDir = (0, import_path8.join)(domainPath, "core");
+    if ((0, import_fs8.existsSync)(coreDir)) {
       const coreFiles = collectMdFiles(coreDir).filter((f) => f !== "instructions.md" && !f.startsWith("instructions/"));
       for (const file of coreFiles) {
-        const desc = extractFirstHeading((0, import_path5.join)(coreDir, file));
+        const desc = extractFirstHeading((0, import_path8.join)(coreDir, file));
         domainFiles.push(formatPathRef(`_ai-context/${folderName}/core/${file}`, desc, agent));
       }
     }
-    const refDir = (0, import_path5.join)(domainPath, "reference");
-    if ((0, import_fs5.existsSync)(refDir)) {
+    const refDir = (0, import_path8.join)(domainPath, "reference");
+    if ((0, import_fs8.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_path5.join)(refDir, file));
+          const desc = extractFirstHeading((0, import_path8.join)(refDir, file));
           domainFiles.push(formatPathRef(`_ai-context/${folderName}/reference/${file}`, desc, agent));
         }
       }
@@ -4517,73 +4299,25 @@ function buildMCPSection(mcpConfig) {
   if (entries.length === 0) return "";
   const lines2 = [`## MCP Servers`, ``, `The following MCP servers are available. Use them proactively when relevant:`, ``];
   for (const [name, config] of entries) {
-    const description = config.description;
-    const useWhen = config.useWhen;
-    if (!description) continue;
+    if (!config.description) continue;
     lines2.push(`### ${name}`);
-    lines2.push(description);
-    if (useWhen) lines2.push(`**Use when**: ${useWhen}`);
+    lines2.push(config.description);
+    if (config.useWhen) lines2.push(`**Use when**: ${config.useWhen}`);
     lines2.push(``);
   }
   return lines2.join("\n");
 }
-function buildFactorySection(agent) {
-  if (agent === "github-copilot") {
-    return [
-      `## Factory Dev Workflow`,
-      ``,
-      `Factory is installed. Skills are in \`factory/skills/\`, templates in \`factory/templates/\`.`,
-      ``,
-      `Read \`factory/README.md\` and \`factory/PROTOCOL.md\` for usage instructions.`,
-      ``,
-      `Available skills:`,
-      `- \`factory-advisor\` \u2014 start or resume the workflow (main entry point)`,
-      `- \`factory-init\` \u2014 initialize project state`,
-      `- \`factory-planner\` \u2014 create story plan`,
-      `- \`factory-executor\` \u2014 execute development tasks`,
-      `- \`factory-verifier\` \u2014 code review`,
-      `- \`factory-completer\` \u2014 finalize and complete work`,
-      ``
-    ].join("\n");
-  }
-  return [
-    `## Factory Dev Workflow`,
-    ``,
-    `Factory is installed. Use \`/factory-advisor\` to start or resume the workflow.`,
-    ``,
-    `Available commands:`,
-    `- \`/factory-advisor\` \u2014 start or resume the workflow (main entry point)`,
-    `- \`/factory-flow\` \u2014 guided workflow execution`,
-    `- \`/factory-feature-dev\` \u2014 add a feature to an existing project`,
-    `- \`/factory-dev\` \u2014 execute development tasks`,
-    `- \`/factory-progress\` \u2014 check status`,
-    `- \`/factory-init-state\` \u2014 initialize state for a brownfield project`,
-    `- \`/factory-analyst\` \u2014 validate requirements`,
-    `- \`/factory-architect\` \u2014 design architecture`,
-    `- \`/factory-planner\` \u2014 create story plan`,
-    `- \`/factory-verifier\` \u2014 code review`,
-    `- \`/factory-security\` \u2014 OWASP security review`,
-    `- \`/factory-test-analyst\` \u2014 test quality review`,
-    `- \`/factory-explorer\` \u2014 explore and understand code`,
-    `- \`/factory-docs\` \u2014 documentation hub`,
-    `- \`/factory-docs-generate\` \u2014 auto-generate documentation`,
-    `- \`/factory-docs-manual\` \u2014 manual documentation workflow`,
-    `- \`/factory-office\` \u2014 office mode discussion`,
-    ``
-  ].join("\n");
-}
-function buildCombinedInstructions(domains, mcpConfig, agent, projectPath, factoryInstalled) {
-  const contextsDir = (0, import_path5.join)(projectPath, "_ai-context");
+function buildCombinedInstructions(domains, mcpConfig, agent, projectPath) {
+  const contextsDir = (0, import_path8.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));
-  if (factoryInstalled) lines2.push(buildFactorySection(agent));
   return lines2.join("\n");
 }
 
 // src/steps/setup/write-mcp-config.ts
-var import_fs6 = require("fs");
-var import_path6 = require("path");
+var import_fs9 = require("fs");
+var import_path9 = require("path");
 var red2 = (text) => `\x1B[31m${text}\x1B[0m`;
 var write_mcp_config_default = defineStep({
   name: "write-mcp-config",
@@ -4592,15 +4326,15 @@ var write_mcp_config_default = defineStep({
   execute: async (ctx) => {
     const filteredMcpConfig = getFilteredMcpConfig(ctx);
     const target = getAgentTarget(ctx.config.agent);
-    const mcpJsonPath = (0, import_path6.join)(ctx.config.projectPath, target.mcpConfig);
+    const mcpJsonPath = (0, import_path9.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 });
+      const dir = (0, import_path9.join)(ctx.config.projectPath, target.mcpDir);
+      if (!(0, import_fs9.existsSync)(dir)) (0, import_fs9.mkdirSync)(dir, { recursive: true });
     }
     let existingFile = {};
-    if ((0, import_fs6.existsSync)(mcpJsonPath)) {
+    if ((0, import_fs9.existsSync)(mcpJsonPath)) {
       try {
-        existingFile = JSON.parse((0, import_fs6.readFileSync)(mcpJsonPath, "utf-8"));
+        existingFile = JSON.parse((0, import_fs9.readFileSync)(mcpJsonPath, "utf-8"));
       } catch {
         const box = [
           "",
@@ -4626,7 +4360,7 @@ var write_mcp_config_default = defineStep({
     }
     const mergedServers = { ...existingServers, ...newServers };
     const outputFile = { ...existingFile, [target.mcpRootKey]: mergedServers };
-    (0, import_fs6.writeFileSync)(mcpJsonPath, JSON.stringify(outputFile, null, 2), "utf-8");
+    (0, import_fs9.writeFileSync)(mcpJsonPath, JSON.stringify(outputFile, null, 2), "utf-8");
     ctx.installed.mcpServersAdded = addedServers;
     return {
       status: "success",
@@ -4636,7 +4370,7 @@ var write_mcp_config_default = defineStep({
 });
 
 // src/steps/setup/run-mcp-install-commands.ts
-var import_child_process4 = require("child_process");
+var import_child_process3 = require("child_process");
 var run_mcp_install_commands_default = defineStep({
   name: "run-mcp-install-commands",
   label: "Registering MCP servers with Claude Code",
@@ -4658,7 +4392,7 @@ var run_mcp_install_commands_default = defineStep({
     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, {
+      const result = (0, import_child_process3.spawnSync)(cmd, {
         shell: true,
         stdio: "pipe",
         encoding: "utf-8",
@@ -4672,7 +4406,6 @@ var run_mcp_install_commands_default = defineStep({
         failed.push({ name, reason });
       }
     }
-    ctx.installed.mcpInstallCommandsRun = { succeeded, failed };
     if (failed.length === 0) {
       return {
         status: "success",
@@ -4691,13 +4424,12 @@ var run_mcp_install_commands_default = defineStep({
   }
 });
 function isClaudeCliAvailable() {
-  const check2 = (0, import_child_process4.spawnSync)("claude --version", { shell: true, stdio: "ignore" });
+  const check2 = (0, import_child_process3.spawnSync)("claude --version", { shell: true, stdio: "ignore" });
   return check2.status === 0;
 }
 
 // src/steps/setup/update-gitignore.ts
-var import_fs7 = require("fs");
-var import_path7 = require("path");
+var import_path10 = require("path");
 var MARKER_START2 = "# one-shot-installer:start";
 var MARKER_END2 = "# one-shot-installer:end";
 var CORE_GITIGNORE_ENTRIES = [
@@ -4714,58 +4446,52 @@ var CORE_GITIGNORE_ENTRIES = [
   ".claude/plans/",
   ".claude/settings.local.json"
 ];
-var LEGACY_FACTORY_GITIGNORE_ENTRIES = [
-  "# Factory runtime state (generated by workflow, not committed)",
-  "factory/STATE.md",
-  "factory/PROJECT.md",
-  "factory/REQUIREMENTS.md",
-  "factory/ARCHITECTURE.md",
-  "factory/ROADMAP.md",
-  "factory/PLAN.md",
-  "factory/GATE-REPORT.md",
-  "factory/VERIFY-REPORT.md",
-  "factory/COMPLETION.md",
-  "factory/summaries/",
-  "factory/ai-context/"
-];
 var update_gitignore_default = defineStep({
   name: "update-gitignore",
   label: "Updating .gitignore",
   execute: async (ctx) => {
-    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_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_fs7.writeFileSync)(gitignorePath, updated, "utf-8");
-    } else {
-      const separator = existing.endsWith("\n") ? "\n" : "\n\n";
-      (0, import_fs7.writeFileSync)(gitignorePath, existing + separator + block + "\n", "utf-8");
-    }
+    const gitignorePath = (0, import_path10.join)(ctx.config.projectPath, ".gitignore");
+    upsertMarkerBlock(gitignorePath, MARKER_START2, MARKER_END2, CORE_GITIGNORE_ENTRIES.join("\n"));
     return { status: "success" };
   }
 });
 
 // src/steps/setup/write-state.ts
-var import_fs8 = require("fs");
-var import_path8 = require("path");
+var import_fs10 = require("fs");
+var import_path11 = require("path");
 var import_os2 = require("os");
-var INSTALLER_VERSION = "0.6.0";
+
+// package.json
+var package_default = {
+  name: "one-shot-setup",
+  version: "0.6.0",
+  description: "One-shot installation tool for The Machine toolchain",
+  type: "module",
+  main: "src/index.ts",
+  scripts: {
+    dev: "tsx src/index.ts",
+    build: 'esbuild src/index.ts --bundle --platform=node --banner:js="#!/usr/bin/env node" --outfile=wrapper/bin/installer.js',
+    "publish:wrapper": "cd wrapper && npm publish"
+  },
+  dependencies: {
+    "@inquirer/prompts": "^5.0.0"
+  },
+  devDependencies: {
+    "@types/node": "^20.11.0",
+    esbuild: "latest",
+    tsx: "latest"
+  },
+  engines: {
+    node: ">=18.0.0"
+  }
+};
+
+// src/steps/setup/write-state.ts
 var write_state_default = defineStep({
   name: "write-state",
   label: "Saving installation state",
   execute: async (ctx) => {
-    const statePath = (0, import_path8.join)(ctx.config.projectPath, ".one-shot-state.json");
+    const statePath = (0, import_path11.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))
@@ -4773,7 +4499,7 @@ var write_state_default = defineStep({
     const target = getAgentTarget(ctx.config.agent);
     const state = {
       installedAt: (/* @__PURE__ */ new Date()).toISOString(),
-      installerVersion: INSTALLER_VERSION,
+      installerVersion: package_default.version,
       releaseVersion: ctx.config.releaseVersion,
       contextReleaseVersion: ctx.installed.contextReleaseVersion ?? null,
       projectPath: ctx.config.projectPath,
@@ -4788,10 +4514,10 @@ var write_state_default = defineStep({
         mcpConfig: target.mcpConfig,
         contexts: "_ai-context/",
         factory: ctx.installed.factoryInstalled ? "factory/" : null,
-        globalConfig: (0, import_path8.join)((0, import_os2.homedir)(), ".one-shot-installer")
+        globalConfig: (0, import_path11.join)((0, import_os2.homedir)(), ".one-shot-installer")
       }
     };
-    (0, import_fs8.writeFileSync)(statePath, JSON.stringify(state, null, 2), "utf-8");
+    (0, import_fs10.writeFileSync)(statePath, JSON.stringify(state, null, 2), "utf-8");
     return { status: "success" };
   }
 });
@@ -4806,27 +4532,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_fs9.existsSync)(filePath)) return green("create");
-  const content = (0, import_fs9.readFileSync)(filePath, "utf-8");
+  if (!(0, import_fs11.existsSync)(filePath)) return green("create");
+  const content = (0, import_fs11.readFileSync)(filePath, "utf-8");
   if (content.includes(markerStart)) return yellow("update");
   return yellow("append");
 }
 function detectMCPFileMode(filePath) {
-  if (!(0, import_fs9.existsSync)(filePath)) return green("create");
+  if (!(0, import_fs11.existsSync)(filePath)) return green("create");
   return yellow("merge");
 }
 function detectContextMode(projectPath, domain) {
-  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");
+  const contextDir = (0, import_path12.join)(projectPath, "_ai-context", domain.toUpperCase());
+  const contextDirLower = (0, import_path12.join)(projectPath, "_ai-context", domain);
+  if ((0, import_fs11.existsSync)(contextDir) || (0, import_fs11.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((resolve5) => {
+  return new Promise((resolve4) => {
     rl.question("  Press Enter to close...", () => {
       rl.close();
-      resolve5();
+      resolve4();
     });
   });
 }
@@ -4916,13 +4642,13 @@ async function collectInputs(options, releaseVersion, factoryAvailable = false)
   }
   const projectInput = await esm_default4({
     message: "Project directory:",
-    default: (0, import_path9.resolve)(process.cwd())
+    default: (0, import_path12.resolve)(process.cwd())
   });
   return {
     technologies: selectedTechnologies,
     agent,
     azureDevOpsOrg,
-    projectPath: (0, import_path9.resolve)(projectInput),
+    projectPath: (0, import_path12.resolve)(projectInput),
     baseMcpServers: options.baseMcpServers,
     mcpConfig,
     releaseVersion,
@@ -4936,9 +4662,9 @@ async function previewAndConfirm(config, options) {
   const instructionFile = target.instructions;
   const mcpConfigFile = target.mcpConfig;
   const serverEntries = Object.entries(config.mcpConfig);
-  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 instructionFilePath = (0, import_path12.join)(config.projectPath, instructionFile);
+  const mcpConfigFilePath = (0, import_path12.join)(config.projectPath, mcpConfigFile);
+  const gitignorePath = (0, import_path12.join)(config.projectPath, ".gitignore");
   const instructionMode = detectMarkerFileMode(instructionFilePath, "<!-- one-shot-installer:start -->");
   const mcpMode = detectMCPFileMode(mcpConfigFilePath);
   const gitignoreMode = detectMarkerFileMode(gitignorePath, "# one-shot-installer:start");
@@ -4964,7 +4690,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_fs9.existsSync)((0, import_path9.join)(config.projectPath, "factory"));
+    const factoryExists = (0, import_fs11.existsSync)((0, import_path12.join)(config.projectPath, "factory"));
     const factoryMode = factoryExists ? yellow("overwrite") : green("create");
     console.log(`    ${"factory/".padEnd(domainColWidth + 14)}${factoryMode}`);
   }
@@ -4983,6 +4709,7 @@ async function previewAndConfirm(config, options) {
 function printSummary(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");
   const hasErrors = failed.length > 0;
   console.log("\u2500".repeat(48));
   console.log(hasErrors ? "  Done (with errors).\n" : "  Done.\n");
@@ -4990,6 +4717,10 @@ function printSummary(result, config) {
     const msg = entry.result.message ? `  ${entry.result.message}` : "";
     console.log(`  ${entry.label}${msg}`);
   }
+  for (const entry of skipped) {
+    const detail = entry.result.detail ? `  ${entry.result.detail}` : "";
+    console.log(`  ${entry.label}  (skipped)${detail}`);
+  }
   if (hasErrors) {
     console.log("\n  What went wrong:");
     for (const entry of failed) {