kiro-kit 0.2.2 → 0.3.0

package/dist/index.js

@@ -6,10 +6,10 @@ import process13 from "process";
 import { Command } from "commander";
 
 // src/commands/init.ts
-import fs10 from "fs";
-import path9 from "path";
+import fs14 from "fs";
+import path13 from "path";
 import process5 from "process";
-import readline from "readline";
+import readline2 from "readline";
 import crypto3 from "crypto";
 
 // src/core/PresetLoader.ts
@@ -81,7 +81,8 @@ var ArtifactTypeSchema = z.enum([
   "docs",
   "doc",
   "config",
-  "other"
+  "other",
+  "powers"
 ]);
 var PresetNameSchema = z.enum([
   "frontend",
@@ -484,7 +485,7 @@ function read2(workspaceRoot) {
   }
 }
 function mergePresets(existing, newPresets) {
-  const merged = [...existing.presets];
+  const merged = [...existing.presets || []];
   for (const p of newPresets) {
     const idx = merged.findIndex((m) => m.name === p.name);
     if (idx >= 0) {
@@ -665,6 +666,564 @@ function safePathInside(workspaceRoot, target) {
   return resolved.startsWith(root + path8.sep) || resolved === root;
 }
 
+// src/core/PowersLoader.ts
+import fs10 from "fs";
+import path9 from "path";
+import { z as z2 } from "zod";
+var PowerTierSchema = z2.enum(["essential", "recommended", "optional"]);
+var PowerEntrySchema = z2.object({
+  name: z2.string().min(1),
+  url: z2.string().url(),
+  description: z2.string().min(1),
+  tier: PowerTierSchema
+});
+var PowersConfigSchema = z2.object({
+  powers: z2.array(PowerEntrySchema)
+});
+var POWERS_FILENAME = "powers.json";
+var TIER_PRIORITY = {
+  essential: 0,
+  recommended: 1,
+  optional: 2
+};
+function loadPowers(presetDir) {
+  const filePath = path9.join(presetDir, POWERS_FILENAME);
+  if (!fs10.existsSync(filePath)) {
+    return { ok: true, powers: [] };
+  }
+  let raw;
+  try {
+    raw = fs10.readFileSync(filePath, "utf-8");
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    return { ok: false, powers: [], error: `Failed to read ${POWERS_FILENAME}: ${message}` };
+  }
+  let parsed;
+  try {
+    parsed = JSON.parse(raw);
+  } catch {
+    return { ok: false, powers: [], error: `${POWERS_FILENAME} is not valid JSON.` };
+  }
+  const result = PowersConfigSchema.safeParse(parsed);
+  if (!result.success) {
+    const issues = result.error.issues.map((i) => `${i.path.join(".")}: ${i.message}`).join("; ");
+    return { ok: false, powers: [], error: `${POWERS_FILENAME} schema validation failed: ${issues}` };
+  }
+  return { ok: true, powers: result.data.powers };
+}
+function mergePowers(configs) {
+  const seen = /* @__PURE__ */ new Map();
+  for (const entries of configs) {
+    for (const entry of entries) {
+      const existing = seen.get(entry.name);
+      if (!existing) {
+        seen.set(entry.name, entry);
+      } else if (TIER_PRIORITY[entry.tier] < TIER_PRIORITY[existing.tier]) {
+        seen.set(entry.name, entry);
+      }
+    }
+  }
+  return Array.from(seen.values());
+}
+function filterByTier(powers, tiers) {
+  const tierSet = new Set(tiers);
+  return powers.filter((p) => tierSet.has(p.tier));
+}
+
+// src/core/MCPConfigurator.ts
+import fs11 from "fs";
+import path10 from "path";
+var MCP_FILENAME = ".mcp.json";
+var SERVER_DEFINITIONS = {
+  filesystem: {
+    command: "npx",
+    args: ["-y", "@modelcontextprotocol/server-filesystem", "."],
+    requiresCredentials: false
+  },
+  git: {
+    command: "npx",
+    args: ["-y", "@modelcontextprotocol/server-git", "--repository", "."],
+    requiresCredentials: false
+  },
+  fetch: {
+    command: "npx",
+    args: ["-y", "@modelcontextprotocol/server-fetch"],
+    requiresCredentials: false
+  },
+  playwright: {
+    command: "npx",
+    args: ["-y", "@modelcontextprotocol/server-playwright"],
+    requiresCredentials: false
+  },
+  postgres: {
+    command: "npx",
+    args: ["-y", "@modelcontextprotocol/server-postgres"],
+    env: { POSTGRES_URL: "${POSTGRES_URL}" },
+    requiresCredentials: true,
+    credentialEnvVars: ["POSTGRES_URL"]
+  },
+  docker: {
+    command: "npx",
+    args: ["-y", "@modelcontextprotocol/server-docker"],
+    env: { DOCKER_HOST: "${DOCKER_HOST}" },
+    requiresCredentials: true,
+    credentialEnvVars: ["DOCKER_HOST"]
+  }
+};
+var PRESET_SERVERS = {
+  frontend: { default: ["filesystem", "git", "fetch", "playwright"], optional: [] },
+  backend: { default: ["filesystem", "git", "fetch"], optional: ["postgres", "docker"] },
+  fullstack: { default: ["filesystem", "git", "fetch", "playwright"], optional: ["postgres", "docker"] },
+  mobile: { default: ["filesystem", "git", "fetch"], optional: [] },
+  devops: { default: ["filesystem", "git", "fetch"], optional: ["docker", "postgres"] },
+  "data-ai": { default: ["filesystem", "git", "fetch"], optional: ["postgres"] }
+};
+function getMCPConfig(presetName) {
+  const mapping = PRESET_SERVERS[presetName];
+  if (!mapping) {
+    return { servers: {} };
+  }
+  const servers = {};
+  for (const name of mapping.default) {
+    const def = SERVER_DEFINITIONS[name];
+    if (def) {
+      servers[name] = { ...def };
+    }
+  }
+  for (const name of mapping.optional) {
+    const def = SERVER_DEFINITIONS[name];
+    if (def) {
+      servers[name] = { ...def };
+    }
+  }
+  return { servers };
+}
+function mergeMCPConfig(existing, incoming) {
+  const existingServers = existing && typeof existing === "object" && existing !== null ? existing.mcpServers ?? {} : {};
+  const merged = { ...existingServers };
+  for (const [name, entry] of Object.entries(incoming.servers)) {
+    const outputKey = entry.requiresCredentials ? `_disabled_${name}` : name;
+    if (merged[name] !== void 0 || merged[`_disabled_${name}`] !== void 0) {
+      continue;
+    }
+    const serverObj = { command: entry.command };
+    if (entry.args && entry.args.length > 0) {
+      serverObj.args = entry.args;
+    }
+    if (entry.env && Object.keys(entry.env).length > 0) {
+      serverObj.env = entry.env;
+    }
+    if (entry.requiresCredentials) {
+      serverObj._comment = `Requires ${entry.credentialEnvVars?.join(", ") ?? "credentials"} environment variable. Remove '_disabled_' prefix to enable.`;
+    }
+    merged[outputKey] = serverObj;
+  }
+  const result = { ...existing ?? {} };
+  result.mcpServers = merged;
+  return result;
+}
+function writeMCPConfig(workspaceRoot, config) {
+  const filePath = path10.join(workspaceRoot, MCP_FILENAME);
+  const content = JSON.stringify(config, null, 2) + "\n";
+  try {
+    fs11.writeFileSync(filePath, content, "utf-8");
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    throw new KKError(
+      ErrorCodes.MCP_MERGE_CONFLICT,
+      `Failed to write ${MCP_FILENAME}: ${message}`,
+      "Check file permissions and ensure the directory exists."
+    );
+  }
+}
+
+// src/core/SetupGuideGenerator.ts
+import fs12 from "fs";
+import path11 from "path";
+var SETUP_GUIDE_FILENAME = "POWERS-SETUP.md";
+var KIRO_DIR = ".kiro";
+var TIER_ORDER = [
+  { tier: "essential", heading: "Essential Powers (install these first)" },
+  { tier: "recommended", heading: "Recommended Powers" },
+  { tier: "optional", heading: "Optional Powers" }
+];
+function generateSetupGuide(options) {
+  const { powers, presetNames, mcpServers } = options;
+  const lines = [];
+  lines.push("# Kiro Powers Setup Guide");
+  lines.push("");
+  lines.push(`## Presets: ${presetNames.join(", ")}`);
+  lines.push("");
+  let counter = 0;
+  for (const { tier, heading } of TIER_ORDER) {
+    const tierPowers = powers.filter((p) => p.tier === tier);
+    if (tierPowers.length === 0) {
+      continue;
+    }
+    lines.push(`## ${heading}`);
+    lines.push("");
+    for (const power of tierPowers) {
+      counter += 1;
+      lines.push(`### ${counter}. ${power.name}`);
+      lines.push(`- URL: ${power.url}`);
+      lines.push(`- Description: ${power.description}`);
+      lines.push(`- How to install: Open Kiro IDE > Powers panel > Search "${power.name}" > Click Install`);
+      lines.push("");
+    }
+  }
+  const serverNames = Object.keys(mcpServers);
+  if (serverNames.length > 0) {
+    lines.push("## MCP Servers (auto-configured)");
+    lines.push("");
+    lines.push("The following MCP servers have been configured in `.mcp.json`:");
+    lines.push("");
+    for (const name of serverNames) {
+      const entry = mcpServers[name];
+      if (entry.requiresCredentials) {
+        lines.push(`- **${name}** (disabled, requires credentials)`);
+      } else {
+        lines.push(`- **${name}** (enabled)`);
+      }
+    }
+    lines.push("");
+    lines.push("To enable disabled servers, set the required environment variables");
+    lines.push("and remove the `_disabled_` prefix from the server key in `.mcp.json`.");
+    lines.push("");
+  }
+  return lines.join("\n");
+}
+function writeSetupGuide(workspaceRoot, content) {
+  const dirPath = path11.join(workspaceRoot, KIRO_DIR);
+  const filePath = path11.join(dirPath, SETUP_GUIDE_FILENAME);
+  try {
+    if (!fs12.existsSync(dirPath)) {
+      fs12.mkdirSync(dirPath, { recursive: true });
+    }
+    fs12.writeFileSync(filePath, content, "utf-8");
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    throw new KKError(
+      ErrorCodes.MCP_MERGE_CONFLICT,
+      `Failed to write ${SETUP_GUIDE_FILENAME}: ${message}`,
+      "Check file permissions and ensure the .kiro directory is writable."
+    );
+  }
+}
+
+// src/core/EnvTemplateGenerator.ts
+import fs13 from "fs";
+import path12 from "path";
+var ENV_FILENAME = ".env.example";
+function collectEnvVars(mcpConfig, powers) {
+  const vars = [];
+  for (const [name, entry] of Object.entries(mcpConfig.servers)) {
+    if (!entry.requiresCredentials) {
+      continue;
+    }
+    const envVars = entry.credentialEnvVars ?? [];
+    const envMap = entry.env ?? {};
+    for (const key of envVars) {
+      const placeholder = envMap[key] ?? `your-${key.toLowerCase().replace(/_/g, "-")}`;
+      vars.push({
+        key,
+        placeholder,
+        comment: `Required by ${name} MCP server`,
+        service: `${name} MCP Server`
+      });
+    }
+  }
+  for (const power of powers) {
+    if (power.tier === "essential" || power.tier === "recommended") {
+      const knownPowerEnvVars = getKnownPowerEnvVars(power.name);
+      for (const envVar of knownPowerEnvVars) {
+        vars.push(envVar);
+      }
+    }
+  }
+  return vars;
+}
+function parseExistingEnv(content) {
+  const keys = /* @__PURE__ */ new Set();
+  for (const line of content.split("\n")) {
+    const trimmed = line.trim();
+    if (trimmed === "" || trimmed.startsWith("#")) {
+      continue;
+    }
+    const match = trimmed.match(/^#?\s*([A-Z_][A-Z0-9_]*)=/);
+    if (match) {
+      keys.add(match[1]);
+    }
+  }
+  return keys;
+}
+function generateEnvTemplate(existing, newVars) {
+  const existingKeys = existing ? parseExistingEnv(existing) : /* @__PURE__ */ new Set();
+  const varsToAdd = newVars.filter((v) => !existingKeys.has(v.key));
+  if (varsToAdd.length === 0) {
+    return existing ?? "";
+  }
+  const grouped = /* @__PURE__ */ new Map();
+  for (const v of varsToAdd) {
+    const group = grouped.get(v.service) ?? [];
+    group.push(v);
+    grouped.set(v.service, group);
+  }
+  const lines = [];
+  for (const [service, vars] of grouped) {
+    lines.push(`# ${service}`);
+    for (const v of vars) {
+      lines.push(`# ${v.comment}`);
+      lines.push(`# ${v.key}=${v.placeholder}`);
+    }
+    lines.push("");
+  }
+  const newContent = lines.join("\n");
+  if (!existing || existing.trim() === "") {
+    return newContent;
+  }
+  const separator = existing.endsWith("\n") ? "" : "\n";
+  return existing + separator + "\n" + newContent;
+}
+function readExistingEnv(workspaceRoot) {
+  const filePath = path12.join(workspaceRoot, ENV_FILENAME);
+  try {
+    return fs13.readFileSync(filePath, "utf-8");
+  } catch {
+    return null;
+  }
+}
+function writeEnvTemplate(workspaceRoot, content) {
+  const filePath = path12.join(workspaceRoot, ENV_FILENAME);
+  try {
+    fs13.writeFileSync(filePath, content, "utf-8");
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    throw new KKError(
+      ErrorCodes.MCP_MERGE_CONFLICT,
+      `Failed to write ${ENV_FILENAME}: ${message}`,
+      "Check file permissions or create the file manually."
+    );
+  }
+}
+function getKnownPowerEnvVars(powerName) {
+  const mapping = {
+    Supabase: [
+      {
+        key: "SUPABASE_URL",
+        placeholder: "https://your-project.supabase.co",
+        comment: "Supabase project URL",
+        service: "Supabase Power"
+      },
+      {
+        key: "SUPABASE_ANON_KEY",
+        placeholder: "your-anon-key",
+        comment: "Supabase anonymous key",
+        service: "Supabase Power"
+      }
+    ],
+    Firebase: [
+      {
+        key: "FIREBASE_PROJECT_ID",
+        placeholder: "your-project-id",
+        comment: "Firebase project ID",
+        service: "Firebase Power"
+      }
+    ],
+    Stripe: [
+      {
+        key: "STRIPE_SECRET_KEY",
+        placeholder: "sk_test_your-key",
+        comment: "Stripe secret key",
+        service: "Stripe Power"
+      }
+    ],
+    Datadog: [
+      {
+        key: "DD_API_KEY",
+        placeholder: "your-datadog-api-key",
+        comment: "Datadog API key",
+        service: "Datadog Power"
+      }
+    ],
+    Neon: [
+      {
+        key: "NEON_DATABASE_URL",
+        placeholder: "postgresql://user:password@host/dbname",
+        comment: "Neon database connection string",
+        service: "Neon Power"
+      }
+    ]
+  };
+  return mapping[powerName] ?? [];
+}
+
+// src/prompts/PowersPrompter.ts
+import readline from "readline";
+var TIER_ORDER2 = ["essential", "recommended", "optional"];
+var TIER_LABELS = {
+  essential: "Essential",
+  recommended: "Recommended",
+  optional: "Optional"
+};
+var TIER_OPTIONS = [
+  { label: "Essential only", tiers: ["essential"] },
+  { label: "Essential + Recommended", tiers: ["essential", "recommended"] },
+  { label: "All (Essential + Recommended + Optional)", tiers: ["essential", "recommended", "optional"] },
+  { label: "None (skip Powers)", tiers: [] }
+];
+async function promptPowersTier(powers, flags) {
+  if (powers.length === 0) {
+    return { selectedTiers: [], confirmMCP: false };
+  }
+  if (flags.powersFlag === "none") {
+    return { selectedTiers: [], confirmMCP: false };
+  }
+  if (flags.powersFlag === "all") {
+    return { selectedTiers: ["essential", "recommended", "optional"], confirmMCP: true };
+  }
+  if (flags.yes === true) {
+    return { selectedTiers: ["essential", "recommended"], confirmMCP: true };
+  }
+  return interactiveTierPrompt(powers);
+}
+function displayPowersRecommendations(powers, quiet) {
+  if (quiet || powers.length === 0) {
+    return;
+  }
+  process.stdout.write("\n");
+  process.stdout.write(color.bold("Recommended Kiro Powers:") + "\n");
+  for (const tier of TIER_ORDER2) {
+    const tierPowers = powers.filter((p) => p.tier === tier);
+    if (tierPowers.length === 0) continue;
+    process.stdout.write("\n");
+    process.stdout.write(`  ${color.cyan(TIER_LABELS[tier])}:
+`);
+    for (const power of tierPowers) {
+      process.stdout.write(`    ${color.bold(power.name)} - ${power.description}
+`);
+      process.stdout.write(`      ${color.dim(power.url)}
+`);
+    }
+  }
+  const counts = countByTier(powers);
+  const parts = [];
+  if (counts.essential > 0) parts.push(`${counts.essential} essential`);
+  if (counts.recommended > 0) parts.push(`${counts.recommended} recommended`);
+  if (counts.optional > 0) parts.push(`${counts.optional} optional`);
+  process.stdout.write("\n");
+  process.stdout.write(color.dim(`${parts.join(", ")} Powers recommended`) + "\n");
+}
+function countByTier(powers) {
+  const counts = { essential: 0, recommended: 0, optional: 0 };
+  for (const p of powers) {
+    counts[p.tier]++;
+  }
+  return counts;
+}
+async function interactiveTierPrompt(powers) {
+  if (!process.stdin.isTTY) {
+    return { selectedTiers: ["essential", "recommended"], confirmMCP: true };
+  }
+  return new Promise((resolve2, reject) => {
+    let cursor = 1;
+    let rendered = false;
+    const rl = readline.createInterface({
+      input: process.stdin,
+      output: process.stdout,
+      terminal: false
+    });
+    const render = () => {
+      if (rendered) {
+        process.stdout.write("\x1B[u");
+      } else {
+        process.stdout.write("\x1B[s");
+      }
+      rendered = true;
+      process.stdout.write("\x1B[J");
+      process.stdout.write(
+        color.bold("? Which Powers tiers to include in setup guide?") + color.dim(" (Arrow keys to select, Enter to confirm)") + "\n"
+      );
+      for (let i = 0; i < TIER_OPTIONS.length; i++) {
+        const marker = cursor === i ? color.cyan(">") : " ";
+        const label = cursor === i ? color.cyan(TIER_OPTIONS[i].label) : TIER_OPTIONS[i].label;
+        process.stdout.write(`  ${marker} ${label}
+`);
+      }
+    };
+    render();
+    process.stdin.setRawMode(true);
+    process.stdin.resume();
+    process.stdin.setEncoding("utf-8");
+    let escBuffer = "";
+    const handleArrow = (seq) => {
+      if (seq === "\x1B[A" || seq === "\x1BOA") {
+        cursor = (cursor - 1 + TIER_OPTIONS.length) % TIER_OPTIONS.length;
+        render();
+        return true;
+      }
+      if (seq === "\x1B[B" || seq === "\x1BOB") {
+        cursor = (cursor + 1) % TIER_OPTIONS.length;
+        render();
+        return true;
+      }
+      return false;
+    };
+    const cleanup = () => {
+      process.stdin.setRawMode(false);
+      process.stdin.removeListener("data", onData);
+      process.stdin.pause();
+      rl.close();
+    };
+    const onData = (key) => {
+      if (escBuffer.length > 0) {
+        escBuffer += key;
+        if (escBuffer.length >= 3) {
+          const seq = escBuffer;
+          escBuffer = "";
+          handleArrow(seq);
+        }
+        return;
+      }
+      if (key.length >= 3 && key.startsWith("\x1B")) {
+        handleArrow(key);
+        return;
+      }
+      if (key === "\x1B") {
+        escBuffer = key;
+        setTimeout(() => {
+          if (escBuffer.length > 0) {
+            escBuffer = "";
+          }
+        }, 50);
+        return;
+      }
+      if (key === "") {
+        cleanup();
+        reject(new Error("SIGINT"));
+        return;
+      }
+      if (key === "\r" || key === "\n") {
+        cleanup();
+        const selected = TIER_OPTIONS[cursor];
+        const confirmMCP = selected.tiers.length > 0;
+        resolve2({ selectedTiers: selected.tiers, confirmMCP });
+        return;
+      }
+      if (key === "k") {
+        cursor = (cursor - 1 + TIER_OPTIONS.length) % TIER_OPTIONS.length;
+        render();
+        return;
+      }
+      if (key === "j") {
+        cursor = (cursor + 1) % TIER_OPTIONS.length;
+        render();
+        return;
+      }
+    };
+    process.stdin.on("data", onData);
+  });
+}
+
 // src/commands/init.ts
 function setupSigintHandler() {
   process5.on("SIGINT", () => {
@@ -674,7 +1233,7 @@ function setupSigintHandler() {
 async function multiPickPrompt(items) {
   const selected = /* @__PURE__ */ new Set();
   let cursor = 0;
-  const rl = readline.createInterface({
+  const rl = readline2.createInterface({
     input: process5.stdin,
     output: process5.stdout,
     terminal: false
@@ -687,18 +1246,21 @@ async function multiPickPrompt(items) {
     let rendered = false;
     const render = () => {
       if (rendered) {
-        process5.stdout.write(`\x1B[${items.length + 1}A`);
+        process5.stdout.write("\x1B[u");
+      } else {
+        process5.stdout.write("\x1B[s");
       }
       rendered = true;
+      process5.stdout.write("\x1B[J");
       process5.stdout.write(
-        "\x1B[2K" + color.bold("? Select presets to install:") + color.dim(" (Space to select, <a> toggle all, Enter to confirm)") + "\n"
+        color.bold("? Select presets to install:") + color.dim(" (Space to select, <a> toggle all, Enter to confirm)") + "\n"
       );
       for (let i = 0; i < items.length; i++) {
         const marker = cursor === i ? color.cyan(">") : " ";
         const check = selected.has(i) ? color.green("[x]") : "[ ]";
         const name = color.bold(items[i].name.padEnd(12));
         const desc = color.dim(`- ${items[i].description}`);
-        process5.stdout.write(`\x1B[2K  ${marker} ${check} ${name} ${desc}
+        process5.stdout.write(`  ${marker} ${check} ${name} ${desc}
 `);
       }
     };
@@ -795,7 +1357,7 @@ async function multiPickPrompt(items) {
 async function confirmPrompt(message) {
   if (!process5.stdin.isTTY) return true;
   return new Promise((resolve2, reject) => {
-    const rl = readline.createInterface({
+    const rl = readline2.createInterface({
       input: process5.stdin,
       output: process5.stdout
     });
@@ -812,7 +1374,7 @@ async function confirmPrompt(message) {
 }
 async function conflictPrompt(target) {
   if (!process5.stdin.isTTY) return "skip";
-  const relTarget = path9.relative(process5.cwd(), target);
+  const relTarget = path13.relative(process5.cwd(), target);
   process5.stdout.write(
     `
 ${color.yellow("?")} File ${color.bold(relTarget)} already exists with different content.
@@ -823,7 +1385,7 @@ ${color.yellow("?")} File ${color.bold(relTarget)} already exists with different
 `
   );
   return new Promise((resolve2, reject) => {
-    const rl = readline.createInterface({
+    const rl = readline2.createInterface({
       input: process5.stdin,
       output: process5.stdout
     });
@@ -846,7 +1408,7 @@ function sha2562(data) {
   return crypto3.createHash("sha256").update(data).digest("hex");
 }
 function registerInitCommand(program2) {
-  program2.command("init").description("Initialize workspace with selected presets").option("-y, --yes", "Skip confirmation, accept defaults").option("--preset <name>", "Specify preset (repeatable)", collectPreset, []).option("--force", "Overwrite all files (with backup)").option("--skip-existing", "Skip all existing files").option("--no-color", "Disable ANSI colors").action(async (opts) => {
+  program2.command("init").description("Initialize workspace with selected presets").option("-y, --yes", "Skip confirmation, accept defaults").option("--preset <name>", "Specify preset (repeatable)", collectPreset, []).option("--force", "Overwrite all files (with backup)").option("--skip-existing", "Skip all existing files").option("--no-color", "Disable ANSI colors").option("--powers <mode>", "Powers setup mode: none, all, or interactive (default)", "interactive").option("--quiet", "Suppress non-essential output including Powers recommendations").action(async (opts) => {
     setupSigintHandler();
     try {
       await runInit(opts);
@@ -923,18 +1485,18 @@ async function runInit(opts) {
     const settingsFiles = manifest.files.filter((f) => f.type === "settings");
     const statuslineFiles = manifest.files.filter((f) => f.type === "statusline");
     for (const fileEntry of regularFiles) {
-      const sourcePath = path9.join(presetDir, fileEntry.source);
-      const targetPath = path9.resolve(workspaceRoot, fileEntry.target);
+      const sourcePath = path13.join(presetDir, fileEntry.source);
+      const targetPath = path13.resolve(workspaceRoot, fileEntry.target);
       if (!safePathInside(workspaceRoot, fileEntry.target)) {
         logger.warn(`Skipping unsafe path: ${fileEntry.target}`);
         filesSkipped++;
         continue;
       }
-      if (!fs10.existsSync(sourcePath)) {
+      if (!fs14.existsSync(sourcePath)) {
         logger.debug(`Source file missing: ${sourcePath}`);
         continue;
       }
-      const sourceContent = fs10.readFileSync(sourcePath);
+      const sourceContent = fs14.readFileSync(sourcePath);
       const action = await resolve({
         target: targetPath,
         sourceContent,
@@ -945,11 +1507,11 @@ async function runInit(opts) {
       });
       switch (action) {
         case "WRITE_NEW":
-          fs10.mkdirSync(path9.dirname(targetPath), { recursive: true });
+          fs14.mkdirSync(path13.dirname(targetPath), { recursive: true });
           atomicWrite(targetPath, sourceContent.toString("utf-8"));
           if (fileEntry.executable && process5.platform !== "win32") {
             try {
-              fs10.chmodSync(targetPath, 493);
+              fs14.chmodSync(targetPath, 493);
             } catch {
             }
           }
@@ -960,7 +1522,7 @@ async function runInit(opts) {
           atomicWrite(targetPath, sourceContent.toString("utf-8"));
           if (fileEntry.executable && process5.platform !== "win32") {
             try {
-              fs10.chmodSync(targetPath, 493);
+              fs14.chmodSync(targetPath, 493);
             } catch {
             }
           }
@@ -994,54 +1556,147 @@ async function runInit(opts) {
       }
     }
     if (mcpFiles.length > 0 && manifest.mcpServers) {
-      const mcpPath = path9.join(workspaceRoot, ".kiro/settings/mcp.json");
+      const mcpPath = path13.join(workspaceRoot, ".kiro/settings/mcp.json");
       let existingMcp = null;
-      if (fs10.existsSync(mcpPath)) {
+      if (fs14.existsSync(mcpPath)) {
         try {
-          existingMcp = JSON.parse(fs10.readFileSync(mcpPath, "utf-8"));
+          existingMcp = JSON.parse(fs14.readFileSync(mcpPath, "utf-8"));
         } catch {
           existingMcp = null;
         }
       }
       const merged = mergeMCP(existingMcp, manifest.mcpServers, manifest.name);
-      fs10.mkdirSync(path9.dirname(mcpPath), { recursive: true });
+      fs14.mkdirSync(path13.dirname(mcpPath), { recursive: true });
       atomicWrite(mcpPath, JSON.stringify(merged, null, 2) + "\n");
       filesWritten++;
     }
     if (settingsFiles.length > 0) {
-      const settingsPath = path9.join(workspaceRoot, ".kiro/settings.json");
+      const settingsPath = path13.join(workspaceRoot, ".kiro/settings.json");
       let existingSettings = null;
-      if (fs10.existsSync(settingsPath)) {
+      if (fs14.existsSync(settingsPath)) {
         try {
           existingSettings = JSON.parse(
-            fs10.readFileSync(settingsPath, "utf-8")
+            fs14.readFileSync(settingsPath, "utf-8")
           );
         } catch {
           existingSettings = null;
         }
       }
-      const presetSettingsPath = path9.join(presetDir, "settings.json");
-      if (fs10.existsSync(presetSettingsPath)) {
+      const presetSettingsPath = path13.join(presetDir, "settings.json");
+      if (fs14.existsSync(presetSettingsPath)) {
         const presetSettings = JSON.parse(
-          fs10.readFileSync(presetSettingsPath, "utf-8")
+          fs14.readFileSync(presetSettingsPath, "utf-8")
         );
         const resolvedSettings = resolveSettingsCommand(
           presetSettings
         );
         const merged = mergeSettings(existingSettings, resolvedSettings);
-        fs10.mkdirSync(path9.dirname(settingsPath), { recursive: true });
+        fs14.mkdirSync(path13.dirname(settingsPath), { recursive: true });
         atomicWrite(settingsPath, JSON.stringify(merged, null, 2) + "\n");
         filesWritten++;
       }
     }
-    const mcpExampleSource = path9.join(presetDir, ".mcp.json.example");
-    if (fs10.existsSync(mcpExampleSource)) {
-      const mcpExampleTarget = path9.join(workspaceRoot, ".kiro/.mcp.json.example");
-      if (!fs10.existsSync(mcpExampleTarget)) {
-        fs10.mkdirSync(path9.dirname(mcpExampleTarget), { recursive: true });
-        fs10.copyFileSync(mcpExampleSource, mcpExampleTarget);
+    const mcpExampleSource = path13.join(presetDir, ".mcp.json.example");
+    if (fs14.existsSync(mcpExampleSource)) {
+      const mcpExampleTarget = path13.join(workspaceRoot, ".kiro/.mcp.json.example");
+      if (!fs14.existsSync(mcpExampleTarget)) {
+        fs14.mkdirSync(path13.dirname(mcpExampleTarget), { recursive: true });
+        fs14.copyFileSync(mcpExampleSource, mcpExampleTarget);
+      }
+    }
+  }
+  try {
+    if (opts.powers !== "none") {
+      const allPowerEntries = presets.map((p) => {
+        const result = loadPowers(p.dir);
+        if (!result.ok) {
+          logger.warn(`Powers: ${result.error}`);
+        }
+        return result.powers;
+      });
+      const mergedPowers = mergePowers(allPowerEntries);
+      if (mergedPowers.length > 0) {
+        const promptResult = await promptPowersTier(mergedPowers, {
+          powersFlag: opts.powers,
+          yes: opts.yes
+        });
+        const filteredPowers = promptResult.selectedTiers.length > 0 ? filterByTier(mergedPowers, promptResult.selectedTiers) : [];
+        if (promptResult.confirmMCP) {
+          try {
+            const presetMCPConfigs = presets.map((p) => getMCPConfig(p.manifest.name));
+            let combinedMCP = null;
+            const mcpJsonPath = path13.join(workspaceRoot, ".mcp.json");
+            if (fs14.existsSync(mcpJsonPath)) {
+              try {
+                combinedMCP = JSON.parse(fs14.readFileSync(mcpJsonPath, "utf-8"));
+              } catch {
+                logger.warn("Existing .mcp.json is invalid JSON, will create fresh.");
+                combinedMCP = null;
+              }
+            }
+            for (const mcpConfig of presetMCPConfigs) {
+              combinedMCP = mergeMCPConfig(combinedMCP, mcpConfig);
+            }
+            let confirmWrite = true;
+            if (!opts.yes) {
+              confirmWrite = await confirmPrompt(
+                "Configure MCP servers in .mcp.json? (Y/n)"
+              );
+            }
+            if (confirmWrite && combinedMCP) {
+              writeMCPConfig(workspaceRoot, combinedMCP);
+              if (!opts.quiet) {
+                logger.info("MCP servers configured in .mcp.json");
+              }
+            }
+          } catch (err) {
+            logger.warn(`MCP configuration failed: ${err instanceof Error ? err.message : String(err)}`);
+          }
+        }
+        displayPowersRecommendations(filteredPowers, opts.quiet ?? false);
+        try {
+          const mcpServersForGuide = presets.reduce(
+            (acc, p) => ({ ...acc, ...getMCPConfig(p.manifest.name).servers }),
+            {}
+          );
+          const guideContent = generateSetupGuide({
+            powers: filteredPowers,
+            presetNames: selectedNames,
+            mcpServers: mcpServersForGuide
+          });
+          writeSetupGuide(workspaceRoot, guideContent);
+          if (!opts.quiet) {
+            logger.info("Setup guide written to .kiro/POWERS-SETUP.md");
+          }
+        } catch (err) {
+          logger.warn(`Setup guide generation failed: ${err instanceof Error ? err.message : String(err)}`);
+        }
+        try {
+          const mcpConfigForEnv = presets.reduce(
+            (acc, p) => {
+              const cfg = getMCPConfig(p.manifest.name);
+              return { servers: { ...acc.servers, ...cfg.servers } };
+            },
+            { servers: {} }
+          );
+          const envVars = collectEnvVars(mcpConfigForEnv, filteredPowers);
+          if (envVars.length > 0) {
+            const existingEnv = readExistingEnv(workspaceRoot);
+            const envContent = generateEnvTemplate(existingEnv, envVars);
+            if (envContent.trim().length > 0) {
+              writeEnvTemplate(workspaceRoot, envContent);
+              if (!opts.quiet) {
+                logger.info("Environment template updated in .env.example");
+              }
+            }
+          }
+        } catch (err) {
+          logger.warn(`Env template generation failed: ${err instanceof Error ? err.message : String(err)}`);
+        }
       }
     }
+  } catch (err) {
+    logger.warn(`Powers integration failed: ${err instanceof Error ? err.message : String(err)}`);
   }
   const kitVersion = getKitVersion();
   const presetMetas = presets.map((p) => ({
@@ -1091,7 +1746,7 @@ function generateTimestamp2() {
 function getKitVersion() {
   try {
     const pkgPath = new URL("../package.json", import.meta.url);
-    const pkg2 = JSON.parse(fs10.readFileSync(pkgPath, "utf-8"));
+    const pkg2 = JSON.parse(fs14.readFileSync(pkgPath, "utf-8"));
     return pkg2.version;
   } catch {
     return "0.1.0";
@@ -1099,8 +1754,8 @@ function getKitVersion() {
 }
 
 // src/commands/add.ts
-import fs11 from "fs";
-import path10 from "path";
+import fs15 from "fs";
+import path14 from "path";
 import process6 from "process";
 import crypto4 from "crypto";
 function sha2563(data) {
@@ -1120,7 +1775,7 @@ function generateTimestamp3() {
 function getKitVersion2() {
   try {
     const pkgPath = new URL("../../package.json", import.meta.url);
-    const pkg2 = JSON.parse(fs11.readFileSync(pkgPath, "utf-8"));
+    const pkg2 = JSON.parse(fs15.readFileSync(pkgPath, "utf-8"));
     return pkg2.version;
   } catch {
     return "0.1.0";
@@ -1128,8 +1783,8 @@ function getKitVersion2() {
 }
 async function conflictPrompt2(target) {
   if (!process6.stdin.isTTY) return "skip";
-  const { default: readline2 } = await import("readline");
-  const relTarget = path10.relative(process6.cwd(), target);
+  const { default: readline3 } = await import("readline");
+  const relTarget = path14.relative(process6.cwd(), target);
   process6.stdout.write(
     `
 ${color.yellow("?")} File ${color.bold(relTarget)} already exists with different content.
@@ -1140,7 +1795,7 @@ ${color.yellow("?")} File ${color.bold(relTarget)} already exists with different
 `
   );
   return new Promise((resolve2) => {
-    const rl = readline2.createInterface({ input: process6.stdin, output: process6.stdout });
+    const rl = readline3.createInterface({ input: process6.stdin, output: process6.stdout });
     rl.question(`  Choice (overwrite/skip/diff/all): `, (answer) => {
       rl.close();
       const a = answer.trim().toLowerCase();
@@ -1171,9 +1826,9 @@ async function runAdd(presetName, opts) {
     );
     process6.exit(1);
   }
-  const kiroDir = path10.join(workspaceRoot, ".kiro");
-  if (!fs11.existsSync(kiroDir)) {
-    fs11.mkdirSync(kiroDir, { recursive: true });
+  const kiroDir = path14.join(workspaceRoot, ".kiro");
+  if (!fs15.existsSync(kiroDir)) {
+    fs15.mkdirSync(kiroDir, { recursive: true });
     logger.info("Created .kiro/ directory.");
   }
   const preset = load(presetName);
@@ -1192,18 +1847,18 @@ async function runAdd(presetName, opts) {
   );
   const statuslineFiles = manifest.files.filter((f) => f.type === "statusline");
   for (const fileEntry of regularFiles) {
-    const sourcePath = path10.join(presetDir, fileEntry.source);
-    const targetPath = path10.resolve(workspaceRoot, fileEntry.target);
+    const sourcePath = path14.join(presetDir, fileEntry.source);
+    const targetPath = path14.resolve(workspaceRoot, fileEntry.target);
     if (!safePathInside(workspaceRoot, fileEntry.target)) {
       logger.warn(`Skipping unsafe path: ${fileEntry.target}`);
       filesSkipped++;
       continue;
     }
-    if (!fs11.existsSync(sourcePath)) {
+    if (!fs15.existsSync(sourcePath)) {
       logger.debug(`Source file missing: ${sourcePath}`);
       continue;
     }
-    const sourceContent = fs11.readFileSync(sourcePath);
+    const sourceContent = fs15.readFileSync(sourcePath);
     const action = await resolve({
       target: targetPath,
       sourceContent,
@@ -1214,11 +1869,11 @@ async function runAdd(presetName, opts) {
     });
     switch (action) {
       case "WRITE_NEW":
-        fs11.mkdirSync(path10.dirname(targetPath), { recursive: true });
+        fs15.mkdirSync(path14.dirname(targetPath), { recursive: true });
         atomicWrite(targetPath, sourceContent.toString("utf-8"));
         if (fileEntry.executable && process6.platform !== "win32") {
           try {
-            fs11.chmodSync(targetPath, 493);
+            fs15.chmodSync(targetPath, 493);
           } catch {
           }
         }
@@ -1229,7 +1884,7 @@ async function runAdd(presetName, opts) {
         atomicWrite(targetPath, sourceContent.toString("utf-8"));
         if (fileEntry.executable && process6.platform !== "win32") {
           try {
-            fs11.chmodSync(targetPath, 493);
+            fs15.chmodSync(targetPath, 493);
           } catch {
           }
         }
@@ -1263,37 +1918,37 @@ async function runAdd(presetName, opts) {
     }
   }
   if (manifest.mcpServers) {
-    const mcpPath = path10.join(workspaceRoot, ".kiro/settings/mcp.json");
+    const mcpPath = path14.join(workspaceRoot, ".kiro/settings/mcp.json");
     let existingMcp = null;
-    if (fs11.existsSync(mcpPath)) {
+    if (fs15.existsSync(mcpPath)) {
       try {
-        existingMcp = JSON.parse(fs11.readFileSync(mcpPath, "utf-8"));
+        existingMcp = JSON.parse(fs15.readFileSync(mcpPath, "utf-8"));
       } catch {
         existingMcp = null;
       }
     }
     const merged = mergeMCP(existingMcp, manifest.mcpServers, manifest.name);
-    fs11.mkdirSync(path10.dirname(mcpPath), { recursive: true });
+    fs15.mkdirSync(path14.dirname(mcpPath), { recursive: true });
     atomicWrite(mcpPath, JSON.stringify(merged, null, 2) + "\n");
     filesWritten++;
   }
-  const presetSettingsPath = path10.join(presetDir, "settings.json");
-  if (fs11.existsSync(presetSettingsPath)) {
-    const settingsPath = path10.join(workspaceRoot, ".kiro/settings.json");
+  const presetSettingsPath = path14.join(presetDir, "settings.json");
+  if (fs15.existsSync(presetSettingsPath)) {
+    const settingsPath = path14.join(workspaceRoot, ".kiro/settings.json");
     let existingSettings = null;
-    if (fs11.existsSync(settingsPath)) {
+    if (fs15.existsSync(settingsPath)) {
       try {
-        existingSettings = JSON.parse(fs11.readFileSync(settingsPath, "utf-8"));
+        existingSettings = JSON.parse(fs15.readFileSync(settingsPath, "utf-8"));
       } catch {
         existingSettings = null;
       }
     }
-    const presetSettings = JSON.parse(fs11.readFileSync(presetSettingsPath, "utf-8"));
+    const presetSettings = JSON.parse(fs15.readFileSync(presetSettingsPath, "utf-8"));
     const resolvedSettings = resolveSettingsCommand(
       presetSettings
     );
     const merged = mergeSettings(existingSettings, resolvedSettings);
-    fs11.mkdirSync(path10.dirname(settingsPath), { recursive: true });
+    fs15.mkdirSync(path14.dirname(settingsPath), { recursive: true });
     atomicWrite(settingsPath, JSON.stringify(merged, null, 2) + "\n");
     filesWritten++;
   }
@@ -1508,8 +2163,8 @@ ${color.bold(manifest.name)} v${manifest.version}
 }
 
 // src/commands/update.ts
-import fs12 from "fs";
-import path11 from "path";
+import fs16 from "fs";
+import path15 from "path";
 import process9 from "process";
 import crypto5 from "crypto";
 function sha2564(data) {
@@ -1529,7 +2184,7 @@ function generateTimestamp4() {
 function getKitVersion3() {
   try {
     const pkgPath = new URL("../../package.json", import.meta.url);
-    const pkg2 = JSON.parse(fs12.readFileSync(pkgPath, "utf-8"));
+    const pkg2 = JSON.parse(fs16.readFileSync(pkgPath, "utf-8"));
     return pkg2.version;
   } catch {
     return "0.1.0";
@@ -1537,8 +2192,8 @@ function getKitVersion3() {
 }
 async function conflictPrompt3(target) {
   if (!process9.stdin.isTTY) return "skip";
-  const { default: readline2 } = await import("readline");
-  const relTarget = path11.relative(process9.cwd(), target);
+  const { default: readline3 } = await import("readline");
+  const relTarget = path15.relative(process9.cwd(), target);
   process9.stdout.write(
     `
 ${color.yellow("?")} File ${color.bold(relTarget)} has changed in the new version.
@@ -1549,7 +2204,7 @@ ${color.yellow("?")} File ${color.bold(relTarget)} has changed in the new versio
 `
   );
   return new Promise((resolve2) => {
-    const rl = readline2.createInterface({ input: process9.stdin, output: process9.stdout });
+    const rl = readline3.createInterface({ input: process9.stdin, output: process9.stdout });
     rl.question(`  Choice (overwrite/skip/diff/all): `, (answer) => {
       rl.close();
       const a = answer.trim().toLowerCase();
@@ -1606,11 +2261,11 @@ async function runUpdate(opts) {
     const updatedFiles = [];
     for (const fileEntry of bundled.manifest.files) {
       if (["mcp", "settings", "statusline"].includes(fileEntry.type)) continue;
-      const sourcePath = path11.join(presetDir, fileEntry.source);
-      const targetPath = path11.resolve(workspaceRoot, fileEntry.target);
+      const sourcePath = path15.join(presetDir, fileEntry.source);
+      const targetPath = path15.resolve(workspaceRoot, fileEntry.target);
       if (!safePathInside(workspaceRoot, fileEntry.target)) continue;
-      if (!fs12.existsSync(sourcePath)) continue;
-      const sourceContent = fs12.readFileSync(sourcePath);
+      if (!fs16.existsSync(sourcePath)) continue;
+      const sourceContent = fs16.readFileSync(sourcePath);
       const newHash = sha2564(sourceContent);
       const trackedFile = trackedPreset.files.find((f) => f.target === fileEntry.target);
       if (trackedFile && trackedFile.contentHash === newHash) {
@@ -1626,11 +2281,11 @@ async function runUpdate(opts) {
       });
       switch (action) {
         case "WRITE_NEW":
-          fs12.mkdirSync(path11.dirname(targetPath), { recursive: true });
+          fs16.mkdirSync(path15.dirname(targetPath), { recursive: true });
           atomicWrite(targetPath, sourceContent.toString("utf-8"));
           if (fileEntry.executable && process9.platform !== "win32") {
             try {
-              fs12.chmodSync(targetPath, 493);
+              fs16.chmodSync(targetPath, 493);
             } catch {
             }
           }
@@ -1641,7 +2296,7 @@ async function runUpdate(opts) {
           atomicWrite(targetPath, sourceContent.toString("utf-8"));
           if (fileEntry.executable && process9.platform !== "win32") {
             try {
-              fs12.chmodSync(targetPath, 493);
+              fs16.chmodSync(targetPath, 493);
             } catch {
             }
           }
@@ -1729,8 +2384,8 @@ function runRestore(opts) {
 }
 
 // src/commands/doctor.ts
-import fs13 from "fs";
-import path12 from "path";
+import fs17 from "fs";
+import path16 from "path";
 import process11 from "process";
 function registerDoctorCommand(program2) {
   program2.command("doctor").description("Run workspace health checks").option("--fix", "Auto-fix fixable issues").action((opts) => {
@@ -1793,8 +2448,8 @@ function checkNodeVersion() {
   };
 }
 function checkKiroDir(workspaceRoot) {
-  const kiroDir = path12.join(workspaceRoot, ".kiro");
-  if (fs13.existsSync(kiroDir) && fs13.statSync(kiroDir).isDirectory()) {
+  const kiroDir = path16.join(workspaceRoot, ".kiro");
+  if (fs17.existsSync(kiroDir) && fs17.statSync(kiroDir).isDirectory()) {
     return { name: "kiro-dir", result: "PASS", message: ".kiro/ directory exists" };
   }
   return {
@@ -1804,12 +2459,12 @@ function checkKiroDir(workspaceRoot) {
   };
 }
 function checkMcpJson(workspaceRoot) {
-  const mcpPath = path12.join(workspaceRoot, ".kiro/settings/mcp.json");
-  if (!fs13.existsSync(mcpPath)) {
+  const mcpPath = path16.join(workspaceRoot, ".kiro/settings/mcp.json");
+  if (!fs17.existsSync(mcpPath)) {
     return { name: "mcp-json", result: "WARN", message: ".kiro/settings/mcp.json not found (optional)" };
   }
   try {
-    const content = fs13.readFileSync(mcpPath, "utf-8");
+    const content = fs17.readFileSync(mcpPath, "utf-8");
     JSON.parse(content);
     return { name: "mcp-json", result: "PASS", message: ".kiro/settings/mcp.json is valid JSON" };
   } catch {
@@ -1819,19 +2474,19 @@ function checkMcpJson(workspaceRoot) {
       message: ".kiro/settings/mcp.json is not valid JSON",
       fixable: true,
       fixAction: () => {
-        const mcpPath2 = path12.join(workspaceRoot, ".kiro/settings/mcp.json");
-        fs13.writeFileSync(mcpPath2, '{\n  "mcpServers": {}\n}\n', "utf-8");
+        const mcpPath2 = path16.join(workspaceRoot, ".kiro/settings/mcp.json");
+        fs17.writeFileSync(mcpPath2, '{\n  "mcpServers": {}\n}\n', "utf-8");
       }
     };
   }
 }
 function checkTracking(workspaceRoot) {
-  const trackingPath = path12.join(workspaceRoot, ".kiro/.kiro-kit.json");
-  if (!fs13.existsSync(trackingPath)) {
+  const trackingPath = path16.join(workspaceRoot, ".kiro/.kiro-kit.json");
+  if (!fs17.existsSync(trackingPath)) {
     return { name: "tracking", result: "WARN", message: ".kiro/.kiro-kit.json not found (no presets installed)" };
   }
   try {
-    const content = fs13.readFileSync(trackingPath, "utf-8");
+    const content = fs17.readFileSync(trackingPath, "utf-8");
     JSON.parse(content);
     return { name: "tracking", result: "PASS", message: ".kiro/.kiro-kit.json is valid" };
   } catch {
@@ -1855,8 +2510,8 @@ function checkTrackedFiles(workspaceRoot) {
   const missing = [];
   for (const preset of tracking.presets) {
     for (const file of preset.files) {
-      const fullPath = path12.resolve(workspaceRoot, file.target);
-      if (!fs13.existsSync(fullPath)) {
+      const fullPath = path16.resolve(workspaceRoot, file.target);
+      if (!fs17.existsSync(fullPath)) {
         missing.push(file.target);
       }
     }
@@ -1871,20 +2526,20 @@ function checkTrackedFiles(workspaceRoot) {
   };
 }
 function checkSteeringFrontMatter(workspaceRoot) {
-  const steeringDir = path12.join(workspaceRoot, ".kiro/steering");
-  if (!fs13.existsSync(steeringDir)) {
+  const steeringDir = path16.join(workspaceRoot, ".kiro/steering");
+  if (!fs17.existsSync(steeringDir)) {
     return { name: "steering-fm", result: "PASS", message: "No steering files to check" };
   }
   const issues = [];
   const walkDir = (dir) => {
     let entries;
     try {
-      entries = fs13.readdirSync(dir, { withFileTypes: true });
+      entries = fs17.readdirSync(dir, { withFileTypes: true });
     } catch {
       return;
     }
     for (const entry of entries) {
-      const fullPath = path12.join(dir, entry.name);
+      const fullPath = path16.join(dir, entry.name);
       if (entry.isDirectory()) {
         walkDir(fullPath);
       } else if (entry.isFile() && entry.name.endsWith(".md")) {
@@ -1908,7 +2563,7 @@ function checkSteeringFrontMatter(workspaceRoot) {
 }
 function checkSingleSteering(filePath, issues) {
   try {
-    const content = fs13.readFileSync(filePath, "utf-8");
+    const content = fs17.readFileSync(filePath, "utf-8");
     const lines = content.split("\n");
     if (lines[0]?.trim() !== "---") return;
     let endIdx = -1;
@@ -1932,16 +2587,16 @@ function fixSteeringWhitespace(steeringDir) {
   const walkAndFix = (dir) => {
     let entries;
     try {
-      entries = fs13.readdirSync(dir, { withFileTypes: true });
+      entries = fs17.readdirSync(dir, { withFileTypes: true });
     } catch {
       return;
     }
     for (const entry of entries) {
-      const fullPath = path12.join(dir, entry.name);
+      const fullPath = path16.join(dir, entry.name);
       if (entry.isDirectory()) {
         walkAndFix(fullPath);
       } else if (entry.isFile() && entry.name.endsWith(".md")) {
-        const content = fs13.readFileSync(fullPath, "utf-8");
+        const content = fs17.readFileSync(fullPath, "utf-8");
         const lines = content.split("\n");
         if (lines[0]?.trim() !== "---") continue;
         let endIdx = -1;
@@ -1961,7 +2616,7 @@ function fixSteeringWhitespace(steeringDir) {
           }
         }
         if (changed) {
-          fs13.writeFileSync(fullPath, lines.join("\n"), "utf-8");
+          fs17.writeFileSync(fullPath, lines.join("\n"), "utf-8");
         }
       }
     }
@@ -1969,12 +2624,12 @@ function fixSteeringWhitespace(steeringDir) {
   walkAndFix(steeringDir);
 }
 function checkMetadataJson(workspaceRoot) {
-  const metaPath = path12.join(workspaceRoot, ".kiro/metadata.json");
-  if (!fs13.existsSync(metaPath)) {
+  const metaPath = path16.join(workspaceRoot, ".kiro/metadata.json");
+  if (!fs17.existsSync(metaPath)) {
     return { name: "metadata-json", result: "WARN", message: ".kiro/metadata.json not found (optional)" };
   }
   try {
-    const content = fs13.readFileSync(metaPath, "utf-8");
+    const content = fs17.readFileSync(metaPath, "utf-8");
     const parsed = JSON.parse(content);
     if (!parsed.version || !parsed.name) {
       return { name: "metadata-json", result: "FAIL", message: ".kiro/metadata.json missing required fields (version, name)" };
@@ -1988,12 +2643,12 @@ function checkStatuslineExecBit(workspaceRoot) {
   if (process11.platform === "win32") {
     return { name: "statusline-exec", result: "PASS", message: "Statusline exec bit check (skipped on Windows)" };
   }
-  const shPath = path12.join(workspaceRoot, ".kiro/statusline.sh");
-  if (!fs13.existsSync(shPath)) {
+  const shPath = path16.join(workspaceRoot, ".kiro/statusline.sh");
+  if (!fs17.existsSync(shPath)) {
     return { name: "statusline-exec", result: "PASS", message: "No statusline.sh to check" };
   }
   try {
-    const stat = fs13.statSync(shPath);
+    const stat = fs17.statSync(shPath);
     const isExecutable = (stat.mode & 73) !== 0;
     if (isExecutable) {
       return { name: "statusline-exec", result: "PASS", message: "statusline.sh is executable" };
@@ -2004,7 +2659,7 @@ function checkStatuslineExecBit(workspaceRoot) {
       message: "statusline.sh is not executable",
       fixable: true,
       fixAction: () => {
-        fs13.chmodSync(shPath, 493);
+        fs17.chmodSync(shPath, 493);
       }
     };
   } catch {
@@ -2013,24 +2668,24 @@ function checkStatuslineExecBit(workspaceRoot) {
 }
 
 // src/commands/telemetry.ts
-import fs14 from "fs";
-import path13 from "path";
+import fs18 from "fs";
+import path17 from "path";
 import os2 from "os";
 import process12 from "process";
-var CONFIG_DIR = path13.join(os2.homedir(), ".kiro-kit");
-var CONFIG_FILE = path13.join(CONFIG_DIR, "config.json");
+var CONFIG_DIR = path17.join(os2.homedir(), ".kiro-kit");
+var CONFIG_FILE = path17.join(CONFIG_DIR, "config.json");
 function readConfig() {
   try {
-    if (fs14.existsSync(CONFIG_FILE)) {
-      return JSON.parse(fs14.readFileSync(CONFIG_FILE, "utf-8"));
+    if (fs18.existsSync(CONFIG_FILE)) {
+      return JSON.parse(fs18.readFileSync(CONFIG_FILE, "utf-8"));
     }
   } catch {
   }
   return { telemetry: false };
 }
 function writeConfig(config) {
-  fs14.mkdirSync(CONFIG_DIR, { recursive: true });
-  fs14.writeFileSync(CONFIG_FILE, JSON.stringify(config, null, 2) + "\n", "utf-8");
+  fs18.mkdirSync(CONFIG_DIR, { recursive: true });
+  fs18.writeFileSync(CONFIG_FILE, JSON.stringify(config, null, 2) + "\n", "utf-8");
 }
 function registerTelemetryCommand(program2) {
   const telemetry = program2.command("telemetry").description("Manage anonymous usage telemetry");