dlw-machine-setup 0.6.1 → 0.7.1

package/bin/installer.js

@@ -3307,34 +3307,96 @@ async function fetchWithRetry(url, options = {}, maxRetries = DEFAULT_MAX_RETRIE
   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
@@ -3403,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) {
     }
   }
@@ -3517,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();
   }
@@ -3534,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 {
@@ -3622,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)
   );
@@ -3693,78 +3752,15 @@ var import_fs4 = require("fs");
 var import_path4 = require("path");
 
 // src/utils/fs-copy.ts
-var import_fs2 = require("fs");
-var import_path2 = require("path");
-function copyDirectory(source, target) {
-  if (!(0, import_fs2.existsSync)(target)) (0, import_fs2.mkdirSync)(target, { recursive: true });
-  for (const entry of (0, import_fs2.readdirSync)(source, { withFileTypes: true })) {
-    const s = (0, import_path2.join)(source, entry.name);
-    const t = (0, import_path2.join)(target, entry.name);
-    if (entry.isDirectory()) copyDirectory(s, t);
-    else (0, import_fs2.copyFileSync)(s, t);
-  }
-}
-
-// src/utils/download-archive.ts
 var import_fs3 = require("fs");
 var import_path3 = require("path");
-var import_child_process2 = 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_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 tempDir = (0, import_path3.join)(projectPath, tempDirName);
-  if ((0, import_fs3.existsSync)(tempDir)) (0, import_fs3.rmSync)(tempDir, { recursive: true, force: true });
-  (0, import_fs3.mkdirSync)(tempDir, { recursive: true });
-  const cleanup = () => {
-    if ((0, import_fs3.existsSync)(tempDir)) {
-      try {
-        (0, import_fs3.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_path3.join)(tempDir, asset.name);
-    (0, import_fs3.writeFileSync)(archivePath, Buffer.from(await dlRes.arrayBuffer()));
-    if ((0, import_fs3.statSync)(archivePath).size < MIN_FILE_SIZE) {
-      throw new Error("File corrupted");
-    }
-    const list = (0, import_child_process2.spawnSync)("tar", ["-tzf", archivePath], { encoding: "utf8" });
-    if (list.status !== 0) throw new Error("Failed to read archive contents");
-    const resolvedTemp = (0, import_path3.resolve)(tempDir);
-    for (const entry of list.stdout.split("\n").filter(Boolean)) {
-      const path = (0, import_path3.resolve)((0, import_path3.join)(tempDir, entry.replace(/\/$/, "")));
-      if (!path.startsWith(resolvedTemp + import_path3.sep)) {
-        throw new Error(`Archive contains unsafe path: ${entry}`);
-      }
-    }
-    const ex = (0, import_child_process2.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;
+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);
   }
 }
 
@@ -3854,7 +3850,7 @@ var import_fs6 = require("fs");
 var import_path6 = require("path");
 
 // src/bundles/types.ts
-var SCHEMA_VERSION = 1;
+var SUPPORTED_SCHEMA_VERSIONS = [1, 2];
 
 // src/utils/marker-block.ts
 var import_fs5 = require("fs");
@@ -3885,11 +3881,106 @@ ${endMarker}`;
   }
 }
 
+// src/profiles/claude-code.ts
+var claudeCodeProfile = {
+  agent: "claude-code",
+  instructionsFile: "CLAUDE.md",
+  handlers: {
+    agent: {
+      supported: true,
+      destination: (name) => `.claude/agents/${name}.md`
+    },
+    skill: {
+      supported: true,
+      // Claude reads skills from a folder per skill: `.claude/skills/<name>/SKILL.md`.
+      destination: (name) => `.claude/skills/${name}/SKILL.md`
+    },
+    hook: {
+      supported: true,
+      configFile: ".claude/settings.json",
+      configKey: "hooks",
+      scriptDir: ".claude/hooks"
+    },
+    "instructions-snippet": {
+      supported: true
+    }
+  }
+};
+
+// src/profiles/github-copilot.ts
+var githubCopilotProfile = {
+  agent: "github-copilot",
+  instructionsFile: ".github/copilot-instructions.md",
+  handlers: {
+    agent: {
+      supported: true,
+      // TODO(phase-3): verify destination path against Copilot CLI docs.
+      destination: (name) => `.github/agents/${name}.md`
+      // TODO(phase-3): supply frontmatter rewriter that maps Claude's
+      // {name, description, disable-model-invocation, ...} to whatever
+      // Copilot expects ({name, description, category, version, ...}).
+    },
+    skill: {
+      supported: true,
+      // TODO(phase-3): verify destination path against Copilot CLI docs.
+      destination: (name) => `.github/skills/${name}.skill.md`
+      // TODO(phase-3): supply frontmatter rewriter.
+    },
+    hook: {
+      // TODO(phase-3): verify whether Copilot CLI has a hook primitive.
+      // If yes, flip to supported: true and fill in configFile/configKey/scriptDir.
+      // If no, leave as unsupported — assets of type 'hook' are silently skipped.
+      supported: false
+    },
+    "instructions-snippet": {
+      supported: true
+    }
+  }
+};
+
+// src/profiles/cursor.ts
+var cursorProfile = {
+  agent: "cursor",
+  instructionsFile: ".cursor/rules/instructions.mdc",
+  handlers: {
+    agent: { supported: false },
+    skill: { supported: false },
+    hook: { supported: false },
+    "instructions-snippet": { supported: true }
+  }
+};
+
+// src/profiles/index.ts
+var PROFILES = {
+  "claude-code": claudeCodeProfile,
+  "github-copilot": githubCopilotProfile,
+  "cursor": cursorProfile
+};
+function getProfile(agent) {
+  const profile = PROFILES[agent];
+  if (!profile) {
+    const known = Object.keys(PROFILES).map((k) => `"${k}"`).join(", ");
+    throw new Error(
+      `No profile registered for agent "${agent}". Known agents: ${known}. Add src/profiles/${agent}.ts and register it in src/profiles/index.ts.`
+    );
+  }
+  return profile;
+}
+
 // src/bundles/run-bundle.ts
 var OWNER_KEY = "_bundleOwner";
 async function runBundle(manifest, ctx) {
   assertSchemaCompatible(manifest);
+  assertNameValid(manifest);
   assertBundleRootExists(ctx);
+  switch (manifest.schemaVersion) {
+    case 1:
+      return runBundleV1(manifest, ctx);
+    case 2:
+      return runBundleV2(manifest, ctx);
+  }
+}
+function runBundleV1(manifest, ctx) {
   const result = {
     name: manifest.name,
     opsExecuted: 0,
@@ -3900,30 +3991,120 @@ async function runBundle(manifest, ctx) {
     executeOp(op, manifest.name, ctx, result);
     result.opsExecuted++;
   }
-  if (manifest.gitignore?.length) {
-    upsertMarkerBlock(
-      (0, import_path6.join)(ctx.projectPath, ".gitignore"),
-      `# ${manifest.name}:start`,
-      `# ${manifest.name}:end`,
-      manifest.gitignore.join("\n")
-    );
-    result.filesTouched.push(".gitignore");
-  }
+  writeGitignoreBlock(manifest, ctx, result);
   const snippet = manifest.instructions?.[ctx.agent];
   if (snippet) {
     result.instructionsSnippet = snippet;
-    if (!ctx.skipInstructions) {
-      upsertMarkerBlock(
-        (0, import_path6.join)(ctx.projectPath, ctx.instructionsFile),
-        `<!-- ${manifest.name}:start -->`,
-        `<!-- ${manifest.name}:end -->`,
-        snippet
-      );
-      result.filesTouched.push(ctx.instructionsFile);
-    }
+    writeInstructionsBlock(manifest.name, snippet, ctx.instructionsFile, ctx, result);
+  }
+  return result;
+}
+function runBundleV2(manifest, ctx) {
+  const profile = getProfile(ctx.agent);
+  const result = {
+    name: manifest.name,
+    opsExecuted: 0,
+    filesTouched: []
+  };
+  const hookPatches = /* @__PURE__ */ new Map();
+  for (const asset of manifest.assets ?? []) {
+    runAsset(asset, profile, hookPatches, ctx, result);
+    result.opsExecuted++;
+  }
+  for (const [file, patch] of hookPatches) {
+    runMergeJson({ op: "merge-json", file, patch }, manifest.name, ctx, result);
+  }
+  for (const op of manifest.ops ?? []) {
+    executeOp(op, manifest.name, ctx, result);
+    result.opsExecuted++;
+  }
+  writeGitignoreBlock(manifest, ctx, result);
+  const snippet = result.instructionsSnippet;
+  if (snippet) {
+    const instructionsFile = profile.instructionsFile || ctx.instructionsFile;
+    writeInstructionsBlock(manifest.name, snippet, instructionsFile, ctx, result);
   }
   return result;
 }
+function runAsset(asset, profile, hookPatches, ctx, result) {
+  switch (asset.type) {
+    case "agent":
+      runAssetCopy(asset, profile.handlers.agent, ctx, result);
+      return;
+    case "skill":
+      runAssetCopy(asset, profile.handlers.skill, ctx, result);
+      return;
+    case "hook":
+      accumulateHook(asset, profile.handlers.hook, hookPatches, ctx, result);
+      return;
+    case "instructions-snippet":
+      if (profile.handlers["instructions-snippet"].supported) {
+        result.instructionsSnippet = asset.content;
+      }
+      return;
+  }
+}
+function runAssetCopy(asset, handler, ctx, result) {
+  if (!handler.supported || !handler.destination) return;
+  const source = resolveBundlePath(asset.source, ctx);
+  if (!(0, import_fs6.existsSync)(source)) return;
+  const target = resolveProjectPath(handler.destination(asset.name), ctx);
+  if ((0, import_fs6.statSync)(source).isDirectory()) {
+    copyDirectory(source, target);
+  } else {
+    (0, import_fs6.mkdirSync)((0, import_path6.dirname)(target), { recursive: true });
+    (0, import_fs6.copyFileSync)(source, target);
+  }
+  result.filesTouched.push(handler.destination(asset.name));
+}
+function accumulateHook(asset, handler, hookPatches, ctx, result) {
+  if (!handler.supported) return;
+  if (!handler.configFile || !handler.configKey) return;
+  if (asset.script && handler.scriptDir) {
+    const scriptSource = resolveBundlePath(asset.script, ctx);
+    if ((0, import_fs6.existsSync)(scriptSource)) {
+      const scriptName = (0, import_path6.basename)(asset.script);
+      const scriptRelDest = `${handler.scriptDir}/${scriptName}`;
+      const scriptDest = resolveProjectPath(scriptRelDest, ctx);
+      (0, import_fs6.mkdirSync)((0, import_path6.dirname)(scriptDest), { recursive: true });
+      (0, import_fs6.copyFileSync)(scriptSource, scriptDest);
+      result.filesTouched.push(scriptRelDest);
+    }
+  }
+  const command = handler.scriptDir ? asset.command.replace(/\{hookDir\}/g, handler.scriptDir) : asset.command;
+  const entry = {
+    hooks: [{ type: "command", command }]
+  };
+  if (asset.matcher) entry.matcher = asset.matcher;
+  let patch = hookPatches.get(handler.configFile);
+  if (!patch) {
+    patch = {};
+    hookPatches.set(handler.configFile, patch);
+  }
+  const root = patch[handler.configKey] ??= {};
+  const events = root[asset.event] ??= [];
+  events.push(entry);
+}
+function writeGitignoreBlock(manifest, ctx, result) {
+  if (!manifest.gitignore?.length) return;
+  upsertMarkerBlock(
+    (0, import_path6.join)(ctx.projectPath, ".gitignore"),
+    `# ${manifest.name}:start`,
+    `# ${manifest.name}:end`,
+    manifest.gitignore.join("\n")
+  );
+  result.filesTouched.push(".gitignore");
+}
+function writeInstructionsBlock(bundleName, snippet, instructionsFile, ctx, result) {
+  if (ctx.skipInstructions) return;
+  upsertMarkerBlock(
+    (0, import_path6.join)(ctx.projectPath, instructionsFile),
+    `<!-- ${bundleName}:start -->`,
+    `<!-- ${bundleName}:end -->`,
+    snippet
+  );
+  result.filesTouched.push(instructionsFile);
+}
 function executeOp(op, owner, ctx, result) {
   switch (op.op) {
     case "copy":
@@ -4025,11 +4206,14 @@ function resolveProjectPath(rel, ctx) {
   return full;
 }
 function assertSchemaCompatible(manifest) {
-  if (manifest.schemaVersion !== SCHEMA_VERSION) {
+  if (!SUPPORTED_SCHEMA_VERSIONS.includes(manifest.schemaVersion)) {
+    const supported = SUPPORTED_SCHEMA_VERSIONS.join(", ");
     throw new Error(
-      `Bundle "${manifest.name}" declares schemaVersion ${manifest.schemaVersion}, installer supports ${SCHEMA_VERSION}. Upgrade the installer or re-pin the bundle.`
+      `Bundle "${manifest.name}" declares schemaVersion ${manifest.schemaVersion}, installer supports ${supported}. Upgrade the installer or re-pin the bundle.`
     );
   }
+}
+function assertNameValid(manifest) {
   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}"`
@@ -4058,17 +4242,13 @@ 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) {
@@ -4097,13 +4277,11 @@ async function fetchFactory(token, repo, targetDir, agent) {
     }
     const extractedPath = (0, import_path7.join)(archive.extractedRoot, extractedFolder);
     const manifestPath = (0, import_path7.join)(extractedPath, "install.json");
-    if ((0, import_fs7.existsSync)(manifestPath)) {
-      await installViaBundle(manifestPath, extractedPath, targetDir, agent, result);
-    } else if (agent === "github-copilot") {
-      installCopilotFactory(extractedPath, targetDir, result);
-    } else {
-      installClaudeFactory(extractedPath, targetDir, result);
+    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);
@@ -4128,132 +4306,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_path7.join)(targetDir, ".claude");
-  const factoryDir = (0, import_path7.join)(targetDir, "factory");
-  const agentsSrc = (0, import_path7.join)(extractedPath, "agents");
-  if ((0, import_fs7.existsSync)(agentsSrc)) {
-    copyDirectory(agentsSrc, (0, import_path7.join)(claudeDir, "agents"));
-    result.filesInstalled.push(".claude/agents/");
-  }
-  const hooksSrc = (0, import_path7.join)(extractedPath, "hooks");
-  if ((0, import_fs7.existsSync)(hooksSrc)) {
-    copyDirectory(hooksSrc, (0, import_path7.join)(claudeDir, "hooks"));
-    result.filesInstalled.push(".claude/hooks/");
-  }
-  const skillsSrc = (0, import_path7.join)(extractedPath, "skills");
-  if ((0, import_fs7.existsSync)(skillsSrc)) {
-    copyDirectory(skillsSrc, (0, import_path7.join)(claudeDir, "skills"));
-    result.filesInstalled.push(".claude/skills/");
-  }
-  const workflowSrc = (0, import_path7.join)(extractedPath, "workflow");
-  if ((0, import_fs7.existsSync)(workflowSrc)) {
-    copyDirectory(workflowSrc, (0, import_path7.join)(factoryDir, "workflow"));
-    result.filesInstalled.push("factory/workflow/");
-  }
-  const utilsSrc = (0, import_path7.join)(extractedPath, "utils");
-  if ((0, import_fs7.existsSync)(utilsSrc)) {
-    copyDirectory(utilsSrc, (0, import_path7.join)(factoryDir, "utils"));
-    result.filesInstalled.push("factory/utils/");
-  }
-  const docsSrc = (0, import_path7.join)(extractedPath, "docs");
-  if ((0, import_fs7.existsSync)(docsSrc)) {
-    copyDirectory(docsSrc, (0, import_path7.join)(factoryDir, "docs"));
-    result.filesInstalled.push("factory/docs/");
-  }
-  const rootEntries = (0, import_fs7.readdirSync)(extractedPath, { withFileTypes: true });
-  for (const entry of rootEntries) {
-    if (entry.isFile()) {
-      if (!(0, import_fs7.existsSync)(factoryDir)) (0, import_fs7.mkdirSync)(factoryDir, { recursive: true });
-      (0, import_fs7.copyFileSync)((0, import_path7.join)(extractedPath, entry.name), (0, import_path7.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_path7.join)(targetDir, "factory");
-  copyDirectory(extractedPath, factoryDir);
-  const entries = (0, import_fs7.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_path7.join)(claudeDir, "settings.json");
-  let settings = {};
-  if ((0, import_fs7.existsSync)(settingsPath)) {
-    try {
-      settings = JSON.parse((0, import_fs7.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_fs7.existsSync)(claudeDir)) (0, import_fs7.mkdirSync)(claudeDir, { recursive: true });
-  (0, import_fs7.writeFileSync)(settingsPath, JSON.stringify(settings, null, 2) + "\n");
-}
 
 // src/steps/setup/write-instructions.ts
 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()))
@@ -4262,9 +4326,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
@@ -4274,16 +4339,13 @@ 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_path8.join)(projectPath, target.instructions);
     const fileDir = (0, import_path8.dirname)(filePath);
@@ -4316,13 +4378,12 @@ alwaysApply: true
         throw new Error(`Corrupted markers in ${fileName} \u2014 fix manually and re-run`);
       }
     });
-    const bundleSnippets = ctx.installed.bundleInstructions ?? {};
-    for (const bundleName of Object.keys(bundleSnippets).sort()) {
+    if (ctx.installed.factoryInstructionsSnippet) {
       upsertMarkerBlock(
         filePath,
-        `<!-- ${bundleName}:start -->`,
-        `<!-- ${bundleName}:end -->`,
-        bundleSnippets[bundleName]
+        "<!-- factory:start -->",
+        "<!-- factory:end -->",
+        ctx.installed.factoryInstructionsSnippet
       );
     }
     return { status: "success", message: target.instructions };
@@ -4346,8 +4407,8 @@ function extractFirstHeading(filePath) {
     }
   } catch {
   }
-  const basename = filePath.split(/[/\\]/).pop() ?? "";
-  return basename.replace(/\.md$/i, "").replace(/[-_]+/g, " ");
+  const basename2 = filePath.split(/[/\\]/).pop() ?? "";
+  return basename2.replace(/\.md$/i, "").replace(/[-_]+/g, " ");
 }
 function formatPathRef(contextPath, description, agent) {
   if (agent === "github-copilot") {
@@ -4426,67 +4487,19 @@ 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) {
+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");
 }
 
@@ -4621,30 +4634,12 @@ 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_path10.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;
-    upsertMarkerBlock(gitignorePath, MARKER_START2, MARKER_END2, entries.join("\n"));
+    upsertMarkerBlock(gitignorePath, MARKER_START2, MARKER_END2, CORE_GITIGNORE_ENTRIES.join("\n"));
     return { status: "success" };
   }
 });
@@ -4664,6 +4659,7 @@ var package_default = {
   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',
+    "build:all": "npm run build",
     "publish:wrapper": "cd wrapper && npm publish"
   },
   dependencies: {

package/package.json

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