@fenglimg/fabric-cli 1.3.0 → 1.4.0

package/dist/{init-BZ73IUHH.js → init-QC2MLFHR.js}

@@ -1,25 +1,29 @@
 #!/usr/bin/env node
 import {
+  buildFabricBootstrapGuide,
   installBootstrap
-} from "./chunk-RUQCZA2Q.js";
+} from "./chunk-XQYY2U2C.js";
 import {
-  createScanReport,
   detectFramework
-} from "./chunk-N4DCTOXW.js";
+} from "./chunk-AZRKMFRY.js";
 import {
   installMcpClients
-} from "./chunk-TO5RUB4R.js";
-import "./chunk-VMYPJPKV.js";
+} from "./chunk-BVTMVW5M.js";
+import {
+  detectClientSupports
+} from "./chunk-BEKSXO5N.js";
 import {
   installHooks
 } from "./chunk-YDZJRLHL.js";
-import {
-  paint
-} from "./chunk-WWNXR34K.js";
 import {
   createDebugLogger,
   resolveDevMode
 } from "./chunk-AEOYCVBG.js";
+import {
+  displayWidth,
+  padEnd,
+  paint
+} from "./chunk-WWNXR34K.js";
 import {
   t
 } from "./chunk-6ICJICVU.js";
@@ -30,6 +34,7 @@ import * as childProcess from "child_process";
 import { chmodSync, copyFileSync, existsSync as existsSync2, mkdirSync, readFileSync as readFileSync2, renameSync, rmSync, statSync as statSync2, writeFileSync } from "fs";
 import { dirname, isAbsolute as isAbsolute2, join as join2, parse, resolve as resolve2 } from "path";
 import { fileURLToPath } from "url";
+import { cancel, confirm, group, intro, isCancel, log, note, outro, select } from "@clack/prompts";
 import { defineCommand } from "citty";
 
 // src/scanner/forensic.ts
@@ -852,7 +857,7 @@ function readProjectName(target) {
   return basename(target);
 }
 function getCliVersion() {
-  return true ? "1.3.0" : "unknown";
+  return true ? "1.4.0" : "unknown";
 }
 function sortRecord(record) {
   return Object.fromEntries(Object.entries(record).sort(([left], [right]) => left.localeCompare(right)));
@@ -862,16 +867,17 @@ function toPosixPath(path) {
 }
 
 // src/commands/init.ts
-var AGENTS_TEMPLATE_BY_FRAMEWORK = {
-  "cocos-creator": "templates/agents-md/variants/cocos.md",
-  vite: "templates/agents-md/variants/vite.md",
-  next: "templates/agents-md/variants/next.md"
-};
 var CLAUDE_INIT_SKILL_TEMPLATE = "templates/claude-skills/agents-md-init/SKILL.md";
 var CLAUDE_INIT_REMINDER_HOOK_TEMPLATE = "templates/claude-hooks/agents-md-init-reminder.cjs";
 var CLAUDE_INIT_REMINDER_COMMAND = ".claude/hooks/agents-md-init-reminder.cjs";
+var CODEX_INIT_SKILL_TEMPLATE = "templates/codex-skills/fabric-init/SKILL.md";
+var CODEX_SESSION_START_HOOK_TEMPLATE = "templates/codex-hooks/fabric-session-start.cjs";
+var CODEX_STOP_HOOK_TEMPLATE = "templates/codex-hooks/fabric-stop-reminder.cjs";
+var CODEX_SESSION_START_COMMAND = ".codex/hooks/fabric-session-start.cjs";
+var CODEX_STOP_COMMAND = ".codex/hooks/fabric-stop-reminder.cjs";
 var LOCAL_FABRIC_SERVER_PATH = join2("node_modules", "@fenglimg", "fabric-server", "dist", "index.js");
 var FABRIC_SERVER_PACKAGE = "@fenglimg/fabric-server";
+var INIT_WIZARD_GROUP_CANCELLED = /* @__PURE__ */ Symbol("init-wizard-group-cancelled");
 var initCommand = defineCommand({
   meta: {
     name: "init",
@@ -892,6 +898,21 @@ var initCommand = defineCommand({
       description: t("cli.init.args.force.description"),
       default: false
     },
+    yes: {
+      type: "boolean",
+      description: t("cli.init.args.yes.description"),
+      default: false
+    },
+    plan: {
+      type: "boolean",
+      description: t("cli.init.args.plan.description"),
+      default: false
+    },
+    reapply: {
+      type: "boolean",
+      description: t("cli.init.args.reapply.description"),
+      default: false
+    },
     bootstrap: {
       type: "boolean",
       default: true,
@@ -907,6 +928,11 @@ var initCommand = defineCommand({
       default: true,
       negativeDescription: t("cli.init.args.no-hooks.description")
     },
+    interactive: {
+      type: "boolean",
+      description: t("cli.init.args.interactive.description"),
+      default: true
+    },
     "mcp-install": {
       type: "string",
       default: "global",
@@ -914,176 +940,726 @@ var initCommand = defineCommand({
     }
   },
   async run({ args }) {
-    const logger = createDebugLogger(args.debug);
-    const resolution = resolveDevMode(args.target, process.cwd());
-    const target = normalizeTarget2(resolution.target);
-    const mcpInstallMode = resolveMcpInstallMode(args["mcp-install"]);
-    const options = {
-      force: args.force,
-      skipBootstrap: args.bootstrap === false ? true : args.skipBootstrap,
-      skipMcp: args.mcp === false ? true : args.skipMcp,
-      skipHooks: args.hooks === false ? true : args.skipHooks
+    await runInitCommand(args);
+  }
+});
+var init_default = initCommand;
+async function runInitCommand(args) {
+  const logger = createDebugLogger(args.debug);
+  const resolution = resolveDevMode(args.target, process.cwd());
+  const intent = resolveInitCliIntent(args, resolution.target);
+  logger(`init target source: ${resolution.source}`);
+  for (const step of resolution.chain) {
+    logger(step);
+  }
+  if (intent.options.planOnly) {
+    writeStderr(t("cli.init.compat.plan"));
+  }
+  if (args.interactive === false) {
+    writeStderr(t("cli.init.compat.interactive"));
+  }
+  if (args.bootstrap === false || args.mcp === false || args.hooks === false) {
+    writeStderr(t("cli.init.compat.legacy-stage-flags"));
+  }
+  const supports = detectClientSupports(intent.target);
+  const basePlan = buildInitExecutionPlan({
+    target: intent.target,
+    options: intent.options,
+    mcpInstallMode: intent.mcpInstallMode,
+    interactive: intent.interactiveSummary && !intent.wizardEnabled,
+    supports
+  });
+  const plan = intent.wizardEnabled ? await resolveInitExecutionPlanWithWizard(basePlan, args, createDefaultInitWizardAdapter()) : basePlan;
+  if (plan === null) {
+    writeStderr(t("cli.init.wizard.cancelled"));
+    throw new Error(t("cli.init.wizard.cancelled"));
+  }
+  return executeInitExecutionPlan(plan);
+}
+function resolveInitCliIntent(args, targetInput) {
+  const target = normalizeTarget2(targetInput);
+  const mcpInstallMode = resolveMcpInstallMode(args["mcp-install"]);
+  const terminalInteractive = isInteractiveInit();
+  const planOnly = args.plan === true;
+  const reapply = args.reapply === true;
+  const options = {
+    force: reapply ? true : args.force,
+    skipBootstrap: args.bootstrap === false ? true : args.skipBootstrap,
+    skipMcp: args.mcp === false ? true : args.skipMcp,
+    skipHooks: args.hooks === false ? true : args.skipHooks,
+    planOnly,
+    reapply
+  };
+  return {
+    target,
+    options,
+    mcpInstallMode,
+    interactiveSummary: args.interactive !== false && terminalInteractive,
+    wizardEnabled: shouldUseInitWizard(args, terminalInteractive) && !planOnly
+  };
+}
+function buildInitExecutionPlan(input) {
+  const options = input.options ?? {};
+  const scaffold = buildInitFabricPlan(input.target, options);
+  const supports = input.supports ?? detectClientSupports(input.target);
+  const mcpInstallMode = input.mcpInstallMode ?? "global";
+  const stages = [
+    { name: "bootstrap", skipped: Boolean(options.skipBootstrap) },
+    {
+      name: "mcp",
+      skipped: Boolean(options.skipMcp),
+      installMode: mcpInstallMode,
+      localServerPath: mcpInstallMode === "local" ? LOCAL_FABRIC_SERVER_PATH : void 0,
+      packageManager: mcpInstallMode === "local" ? detectPackageManager(input.target) : void 0
+    },
+    { name: "hooks", skipped: Boolean(options.skipHooks) }
+  ];
+  return {
+    target: input.target,
+    options,
+    mcpInstallMode,
+    interactive: input.interactive ?? false,
+    supports,
+    scaffold,
+    stages,
+    steps: [
+      { name: "preflight" },
+      { name: "scaffold" },
+      ...stages.map((stage) => ({ name: stage.name, skipped: stage.skipped })),
+      { name: "post-setup" }
+    ]
+  };
+}
+async function executeInitExecutionPlan(plan) {
+  if (plan.options.force) {
+    writeStderr(t("cli.init.force.warning", { path: plan.target }));
+  }
+  if (plan.options.reapply && !plan.options.planOnly && !plan.interactive) {
+    writeStderr(formatInitModeBanner(plan.options));
+  }
+  if (plan.interactive) {
+    printInitPlanSummary(plan.target, plan.options, plan.mcpInstallMode, plan.supports);
+  }
+  if (plan.options.planOnly) {
+    printInitPlanPreview(plan);
+    return {
+      plan,
+      created: buildPlanOnlyScaffoldResult(plan.scaffold),
+      stageResults: plan.stages.map((stage) => ({ name: stage.name, disposition: "skipped" })),
+      finalSupports: plan.supports
     };
-    logger(`init target source: ${resolution.source}`);
-    for (const step of resolution.chain) {
-      logger(step);
-    }
-    if (options.force) {
-      writeStderr(t("cli.init.force.warning", { path: target }));
+  }
+  let created = null;
+  const stageResults = [];
+  let finalSupports = plan.supports;
+  for (const step of plan.steps) {
+    switch (step.name) {
+      case "preflight":
+        break;
+      case "scaffold":
+        created = executeInitFabricPlan(plan.scaffold);
+        printInitScaffoldResult(created);
+        break;
+      case "bootstrap":
+      case "mcp":
+      case "hooks":
+        stageResults.push(await executeInitStagePlan(plan, step.name));
+        break;
+      case "post-setup":
+        finalSupports = detectClientSupports(plan.target);
+        printInitPostSetup(plan, stageResults, finalSupports);
+        break;
+      default:
+        exhaustiveInitExecutionStep(step);
     }
-    const created = initFabric(target, options);
-    console.log(formatInitPathAction(created.agentsPath, created.agentsAction));
-    console.log(formatInitPathAction(created.metaPath, created.metaAction));
-    console.log(formatInitPathAction(created.humanLockPath, created.humanLockAction));
-    console.log(formatInitPathAction(created.forensicPath, created.forensicAction));
-    writeStderr(
-      formatOptionalInitPathAction(created.claudeSkillPath, created.claudeSkillAction)
-    );
-    writeStderr(
-      formatOptionalInitPathAction(created.claudeHookPath, created.claudeHookAction)
+  }
+  return {
+    plan,
+    created: created ?? unreachableInitScaffold(),
+    stageResults,
+    finalSupports
+  };
+}
+function buildInitFabricPlan(target, options) {
+  assertExistingDirectory2(target);
+  const fabricDir = join2(target, ".fabric");
+  const bootstrapPath = join2(fabricDir, "bootstrap", "README.md");
+  const forensicPath = join2(fabricDir, "forensic.json");
+  const claudeSkillPath = join2(target, ".claude", "skills", "agents-md-init", "SKILL.md");
+  const codexSkillPath = join2(target, ".agents", "skills", "fabric-init", "SKILL.md");
+  const codexSessionStartHookPath = join2(target, ".codex", "hooks", "fabric-session-start.cjs");
+  const codexStopHookPath = join2(target, ".codex", "hooks", "fabric-stop-reminder.cjs");
+  const codexHooksConfigPath = join2(target, ".codex", "hooks.json");
+  const claudeHookPath = join2(target, ".claude", "hooks", "agents-md-init-reminder.cjs");
+  const claudeSettingsPath = join2(target, ".claude", "settings.json");
+  const metaPath = join2(fabricDir, "agents.meta.json");
+  const humanLockPath = join2(fabricDir, "human-lock.json");
+  const replaceFabricDir = shouldReplaceWritableDirectory(fabricDir, options);
+  const bootstrapAction = planFreshPath(bootstrapPath, options);
+  const metaAction = planFreshPath(metaPath, options);
+  const humanLockAction = planFreshPath(humanLockPath, options);
+  const forensicAction = planFreshPath(forensicPath, options);
+  const forensicReport = buildForensicReport(target);
+  const humanLockTemplate = readFileSync2(findTemplatePath("templates/fabric/human-lock.json"), "utf8");
+  const bootstrapContent = buildFabricBootstrapGuide(target);
+  const bootstrapHash = sha256(bootstrapContent);
+  const meta = createInitialMeta(bootstrapHash);
+  return {
+    target,
+    options,
+    fabricDir,
+    replaceFabricDir,
+    bootstrapPath,
+    bootstrapAction,
+    bootstrapContent,
+    metaPath,
+    metaAction,
+    meta,
+    humanLockPath,
+    humanLockAction,
+    humanLockContent: humanLockTemplate.endsWith("\n") ? humanLockTemplate : `${humanLockTemplate}
+`,
+    forensicPath,
+    forensicAction,
+    forensicReport,
+    claudeSkill: buildOptionalTemplateWritePlan(claudeSkillPath, findTemplatePath(CLAUDE_INIT_SKILL_TEMPLATE), options),
+    codexSkill: buildOptionalTemplateWritePlan(codexSkillPath, findTemplatePath(CODEX_INIT_SKILL_TEMPLATE), options),
+    codexSessionStartHook: buildOptionalTemplateWritePlan(
+      codexSessionStartHookPath,
+      findTemplatePath(CODEX_SESSION_START_HOOK_TEMPLATE),
+      options,
+      true
+    ),
+    codexStopHook: buildOptionalTemplateWritePlan(
+      codexStopHookPath,
+      findTemplatePath(CODEX_STOP_HOOK_TEMPLATE),
+      options,
+      true
+    ),
+    codexHooksConfig: buildCodexHooksConfigPlan(codexHooksConfigPath, options),
+    claudeHook: buildOptionalTemplateWritePlan(
+      claudeHookPath,
+      findTemplatePath(CLAUDE_INIT_REMINDER_HOOK_TEMPLATE),
+      options,
+      true
+    ),
+    claudeSettings: buildClaudeSettingsWritePlan(claudeSettingsPath, options)
+  };
+}
+function executeInitFabricPlan(plan) {
+  if (plan.replaceFabricDir) {
+    rmSync(plan.fabricDir, { force: true });
+  }
+  mkdirSync(plan.fabricDir, { recursive: true });
+  mkdirSync(dirname(plan.bootstrapPath), { recursive: true });
+  preparePlannedPath(plan.bootstrapPath, plan.bootstrapAction);
+  writeFileSync(plan.bootstrapPath, plan.bootstrapContent, "utf8");
+  preparePlannedPath(plan.metaPath, plan.metaAction);
+  writeFileSync(plan.metaPath, `${JSON.stringify(plan.meta, null, 2)}
+`, "utf8");
+  preparePlannedPath(plan.humanLockPath, plan.humanLockAction);
+  writeFileSync(plan.humanLockPath, plan.humanLockContent, "utf8");
+  preparePlannedPath(plan.forensicPath, plan.forensicAction);
+  writeFileSync(plan.forensicPath, `${JSON.stringify(plan.forensicReport, null, 2)}
+`, "utf8");
+  applyOptionalTemplateWritePlan(plan.claudeSkill);
+  applyOptionalTemplateWritePlan(plan.codexSkill);
+  applyOptionalTemplateWritePlan(plan.codexSessionStartHook);
+  applyOptionalTemplateWritePlan(plan.codexStopHook);
+  applyJsonWritePlan(plan.codexHooksConfig);
+  applyOptionalTemplateWritePlan(plan.claudeHook);
+  applyClaudeSettingsWritePlan(plan.claudeSettings);
+  return {
+    bootstrapPath: plan.bootstrapPath,
+    bootstrapAction: plan.bootstrapAction,
+    metaPath: plan.metaPath,
+    metaAction: plan.metaAction,
+    humanLockPath: plan.humanLockPath,
+    humanLockAction: plan.humanLockAction,
+    forensicPath: plan.forensicPath,
+    forensicAction: plan.forensicAction,
+    claudeSkillPath: plan.claudeSkill.path,
+    claudeSkillAction: plan.claudeSkill.action,
+    codexSkillPath: plan.codexSkill.path,
+    codexSkillAction: plan.codexSkill.action,
+    codexSessionStartHookPath: plan.codexSessionStartHook.path,
+    codexSessionStartHookAction: plan.codexSessionStartHook.action,
+    codexStopHookPath: plan.codexStopHook.path,
+    codexStopHookAction: plan.codexStopHook.action,
+    codexHooksConfigPath: plan.codexHooksConfig.path,
+    codexHooksConfigAction: plan.codexHooksConfig.action,
+    claudeHookPath: plan.claudeHook.path,
+    claudeHookAction: plan.claudeHook.action,
+    claudeSettingsPath: plan.claudeSettings.path,
+    claudeSettingsAction: plan.claudeSettings.action
+  };
+}
+function initFabric(target, options) {
+  return executeInitFabricPlan(buildInitFabricPlan(target, options));
+}
+function shouldUseInitWizard(args, terminalInteractive = isInteractiveInit()) {
+  return terminalInteractive && args.interactive !== false && args.yes !== true;
+}
+async function resolveInitExecutionPlanWithWizard(basePlan, args, wizardAdapter) {
+  const selection = await wizardAdapter.run({
+    target: basePlan.target,
+    options: basePlan.options,
+    supports: basePlan.supports,
+    mcpInstallMode: basePlan.mcpInstallMode,
+    lockedStages: collectLockedWizardStages(args)
+  });
+  if (selection === null) {
+    return null;
+  }
+  return buildInitExecutionPlan({
+    target: basePlan.target,
+    options: {
+      ...basePlan.options,
+      skipBootstrap: !selection.bootstrap,
+      skipMcp: !selection.mcp,
+      skipHooks: !selection.hooks
+    },
+    mcpInstallMode: selection.mcp ? selection.mcpInstallMode : basePlan.mcpInstallMode,
+    interactive: false,
+    supports: basePlan.supports
+  });
+}
+function unreachableInitScaffold() {
+  throw new Error("Init scaffold step did not execute");
+}
+function exhaustiveInitExecutionStep(value) {
+  throw new Error(`Unsupported init execution step: ${JSON.stringify(value)}`);
+}
+function exhaustiveInitStagePlan(value) {
+  throw new Error(`Unsupported init stage plan: ${JSON.stringify(value)}`);
+}
+function printInitScaffoldResult(created) {
+  console.log(formatInitPathAction(created.bootstrapPath, created.bootstrapAction));
+  console.log(formatInitPathAction(created.metaPath, created.metaAction));
+  console.log(formatInitPathAction(created.humanLockPath, created.humanLockAction));
+  console.log(formatInitPathAction(created.forensicPath, created.forensicAction));
+  writeStderr(formatOptionalInitPathAction(created.claudeSkillPath, created.claudeSkillAction));
+  writeStderr(formatOptionalInitPathAction(created.codexSkillPath, created.codexSkillAction));
+  writeStderr(
+    formatOptionalInitPathAction(created.codexSessionStartHookPath, created.codexSessionStartHookAction)
+  );
+  writeStderr(
+    formatOptionalInitPathAction(created.codexStopHookPath, created.codexStopHookAction)
+  );
+  writeStderr(formatCodexHooksAction(created.codexHooksConfigPath, created.codexHooksConfigAction));
+  writeStderr(formatOptionalInitPathAction(created.claudeHookPath, created.claudeHookAction));
+  writeStderr(formatClaudeSettingsAction(created.claudeSettingsPath, created.claudeSettingsAction));
+}
+function printInitPostSetup(plan, stageResults, finalSupports) {
+  if (shouldPrintHooksNextStep(plan.options, stageResults)) {
+    console.log(
+      t("cli.init.next-step", {
+        label: nextLabel(),
+        message: paint.muted(t("cli.init.next-step.message"))
+      })
     );
-    writeStderr(formatClaudeSettingsAction(created.claudeSettingsPath, created.claudeSettingsAction));
-    const stageResults = [];
-    if (options.skipBootstrap) {
-      stageResults.push({ name: "bootstrap", disposition: "skipped" });
-    } else {
-      console.log(formatInitStageHeader(t("cli.init.stages.bootstrap")));
-      try {
-        const result = await installBootstrap(target, { force: options.force });
+  }
+  console.log(
+    t("cli.init.reason-message", {
+      label: reasonLabel(),
+      message: paint.muted(formatInitReasonMessage(finalSupports))
+    })
+  );
+  printInitStageSummary(stageResults);
+  printInitCapabilitySummary(finalSupports, stageResults, plan.options);
+}
+function printInitPlanPreview(plan) {
+  console.log(t("cli.init.plan.preview-title"));
+  printInitPlanSummary(plan.target, plan.options, plan.mcpInstallMode, plan.supports);
+  console.log(
+    t("cli.init.plan.preview-result", {
+      mode: plan.options.reapply ? t("cli.init.mode.reapply") : t("cli.init.mode.default"),
+      bootstrap: yesNoLabel(!plan.options.skipBootstrap),
+      mcp: yesNoLabel(!plan.options.skipMcp),
+      hooks: yesNoLabel(!plan.options.skipHooks)
+    })
+  );
+}
+function buildPlanOnlyScaffoldResult(plan) {
+  return {
+    bootstrapPath: plan.bootstrapPath,
+    bootstrapAction: plan.bootstrapAction,
+    metaPath: plan.metaPath,
+    metaAction: plan.metaAction,
+    humanLockPath: plan.humanLockPath,
+    humanLockAction: plan.humanLockAction,
+    forensicPath: plan.forensicPath,
+    forensicAction: plan.forensicAction,
+    claudeSkillPath: plan.claudeSkill.path,
+    claudeSkillAction: plan.claudeSkill.action,
+    codexSkillPath: plan.codexSkill.path,
+    codexSkillAction: plan.codexSkill.action,
+    codexSessionStartHookPath: plan.codexSessionStartHook.path,
+    codexSessionStartHookAction: plan.codexSessionStartHook.action,
+    codexStopHookPath: plan.codexStopHook.path,
+    codexStopHookAction: plan.codexStopHook.action,
+    codexHooksConfigPath: plan.codexHooksConfig.path,
+    codexHooksConfigAction: plan.codexHooksConfig.action,
+    claudeHookPath: plan.claudeHook.path,
+    claudeHookAction: plan.claudeHook.action,
+    claudeSettingsPath: plan.claudeSettings.path,
+    claudeSettingsAction: plan.claudeSettings.action
+  };
+}
+async function executeInitStagePlan(plan, stageName) {
+  const stage = plan.stages.find((entry) => entry.name === stageName);
+  if (stage === void 0) {
+    throw new Error(`Missing init stage plan: ${stageName}`);
+  }
+  if (stage.skipped) {
+    return { name: stageName, disposition: "skipped" };
+  }
+  console.log(formatInitStageHeader(t(`cli.init.stages.${stageName}`)));
+  try {
+    switch (stage.name) {
+      case "bootstrap": {
+        const result = await installBootstrap(plan.target, { force: plan.options.force });
         if (result.details.length === 0) {
           console.log(formatInitStageResult("bootstrap", "skipped", 0, 0, t("cli.bootstrap.install.no-targets")));
-          stageResults.push({ name: "bootstrap", disposition: "skipped" });
-        } else {
-          console.log(
-            formatInitStageResult("bootstrap", "completed", result.installed.length, result.skipped.length)
-          );
-          stageResults.push({ name: "bootstrap", disposition: "ran" });
+          return { name: "bootstrap", disposition: "skipped" };
         }
-      } catch (error) {
-        writeStderr(formatInitStageFailure("bootstrap", error));
-        stageResults.push({ name: "bootstrap", disposition: "failed" });
+        console.log(
+          formatInitStageResult("bootstrap", "completed", result.installed.length, result.skipped.length)
+        );
+        return { name: "bootstrap", disposition: "ran" };
       }
-    }
-    if (options.skipMcp) {
-      stageResults.push({ name: "mcp", disposition: "skipped" });
-    } else {
-      console.log(formatInitStageHeader(t("cli.init.stages.mcp")));
-      try {
-        let localServerPath;
-        if (mcpInstallMode === "local") {
-          const manager = detectPackageManager(target);
+      case "mcp": {
+        if (stage.installMode === "local") {
+          const manager = stage.packageManager ?? detectPackageManager(plan.target);
           writeStderr(t("cli.init.mcp.install.local"));
           writeStderr(t("cli.init.mcp.local.installing", { manager }));
-          installLocalFabricServer(target, manager);
+          installLocalFabricServer(plan.target, manager);
           writeStderr(t("cli.init.mcp.local.installed"));
-          localServerPath = LOCAL_FABRIC_SERVER_PATH;
         } else {
           writeStderr(t("cli.init.mcp.install.global"));
         }
-        const result = await installMcpClients(target, {
-          force: options.force,
-          localServerPath
+        const result = await installMcpClients(plan.target, {
+          force: plan.options.force,
+          localServerPath: stage.localServerPath
         });
         if (result.details.length === 0) {
           console.log(formatInitStageResult("mcp", "skipped", 0, 0, t("cli.config.install.no-configs")));
-          stageResults.push({ name: "mcp", disposition: "skipped" });
-        } else {
-          console.log(formatInitStageResult("mcp", "completed", result.installed.length, result.skipped.length));
-          stageResults.push({ name: "mcp", disposition: "ran" });
+          return { name: "mcp", disposition: "skipped" };
         }
-      } catch (error) {
-        writeStderr(formatInitStageFailure("mcp", error));
-        stageResults.push({ name: "mcp", disposition: "failed" });
+        console.log(formatInitStageResult("mcp", "completed", result.installed.length, result.skipped.length));
+        return { name: "mcp", disposition: "ran" };
       }
-    }
-    if (options.skipHooks) {
-      stageResults.push({ name: "hooks", disposition: "skipped" });
-    } else {
-      console.log(formatInitStageHeader(t("cli.init.stages.hooks")));
-      try {
-        const result = await installHooks(target, { force: options.force });
+      case "hooks": {
+        const result = await installHooks(plan.target, { force: plan.options.force });
         console.log(formatInitStageResult("hooks", "completed", result.installed.length, result.skipped.length));
-        stageResults.push({ name: "hooks", disposition: "ran" });
-      } catch (error) {
-        writeStderr(formatInitStageFailure("hooks", error));
-        stageResults.push({ name: "hooks", disposition: "failed" });
+        return { name: "hooks", disposition: "ran" };
       }
+      default:
+        return exhaustiveInitStagePlan(stage);
     }
-    if (shouldPrintHooksNextStep(options, stageResults)) {
-      console.log(
-        t("cli.init.next-step", {
-          label: nextLabel(),
-          message: paint.muted(t("cli.init.next-step.message"))
-        })
-      );
+  } catch (error) {
+    writeStderr(formatInitStageFailure(stageName, error));
+    return { name: stageName, disposition: "failed" };
+  }
+}
+function shouldReplaceWritableDirectory(path, options) {
+  if (!existsSync2(path)) {
+    return false;
+  }
+  if (statSync2(path).isDirectory()) {
+    return false;
+  }
+  if (!options?.force) {
+    throw new Error(t("cli.init.errors.abort-existing", { path }));
+  }
+  return true;
+}
+function planFreshPath(path, options) {
+  if (!existsSync2(path)) {
+    return "created";
+  }
+  if (!options?.force) {
+    throw new Error(t("cli.init.errors.abort-existing", { path }));
+  }
+  return "overwritten";
+}
+function preparePlannedPath(path, action) {
+  mkdirSync(dirname(path), { recursive: true });
+  if (action === "overwritten" && existsSync2(path)) {
+    rmSync(path, { recursive: true, force: true });
+  }
+}
+function buildOptionalTemplateWritePlan(path, templatePath, options, executable = false) {
+  const existed = existsSync2(path);
+  if (existed && !options?.force) {
+    return { path, action: "skipped", templatePath, executable };
+  }
+  return {
+    path,
+    action: existed ? "overwritten" : "created",
+    templatePath,
+    executable
+  };
+}
+function applyOptionalTemplateWritePlan(plan) {
+  if (plan.action === "skipped") {
+    return;
+  }
+  mkdirSync(dirname(plan.path), { recursive: true });
+  copyFileSync(plan.templatePath, plan.path);
+  if (plan.executable) {
+    chmodSync(plan.path, 493);
+  }
+}
+function buildCodexHooksConfigValue() {
+  return {
+    hooks: {
+      SessionStart: [
+        {
+          matcher: "*",
+          hooks: [{ type: "command", command: CODEX_SESSION_START_COMMAND }]
+        }
+      ],
+      Stop: [
+        {
+          matcher: "*",
+          hooks: [{ type: "command", command: CODEX_STOP_COMMAND }]
+        }
+      ]
     }
-    console.log(
-      t("cli.init.reason-message", {
-        label: reasonLabel(),
-        message: paint.muted(t("cli.init.reason-message.body"))
-      })
-    );
-    printInitStageSummary(stageResults);
+  };
+}
+function buildCodexHooksConfigPlan(configPath, options) {
+  const action = !existsSync2(configPath) ? "created" : options?.force ? "overwritten" : "skipped";
+  return {
+    path: configPath,
+    action,
+    value: buildCodexHooksConfigValue()
+  };
+}
+function applyJsonWritePlan(plan) {
+  if (plan.action === "skipped") {
+    return;
   }
-});
-var init_default = initCommand;
-function initFabric(target, options) {
-  assertExistingDirectory2(target);
-  const agentsPath = join2(target, "AGENTS.md");
-  const fabricDir = join2(target, ".fabric");
-  const forensicPath = join2(fabricDir, "forensic.json");
-  const claudeSkillPath = join2(target, ".claude", "skills", "agents-md-init", "SKILL.md");
-  const claudeHookPath = join2(target, ".claude", "hooks", "agents-md-init-reminder.cjs");
-  const claudeSettingsPath = join2(target, ".claude", "settings.json");
-  const forensicGuardAction = prepareFreshPath(forensicPath, options);
-  const agentsAction = prepareFreshPath(agentsPath, options);
-  const fabricDirAction = prepareFreshPath(fabricDir, options);
-  const forensicAction = forensicGuardAction === "overwritten" || fabricDirAction === "overwritten" ? "overwritten" : "created";
-  const scanReport = createScanReport(target);
-  const forensicReport = buildForensicReport(target);
-  const template = readFileSync2(findAgentsTemplatePath(scanReport.framework.kind), "utf8");
-  const humanLockTemplate = readFileSync2(findTemplatePath("templates/fabric/human-lock.json"), "utf8");
-  const packageName = readPackageName(target) ?? parse(target).base;
-  const agentsContent = template.replaceAll("{ projectName }", packageName).replaceAll("{ frameworkKind }", scanReport.framework.kind);
-  const agentsHash = sha256(agentsContent);
-  const meta = createInitialMeta(agentsHash);
-  const metaPath = join2(fabricDir, "agents.meta.json");
-  const humanLockPath = join2(fabricDir, "human-lock.json");
-  mkdirSync(fabricDir, { recursive: false });
-  writeNewFile(agentsPath, agentsContent, options);
-  writeNewFile(metaPath, `${JSON.stringify(meta, null, 2)}
-`, options);
-  writeNewFile(humanLockPath, humanLockTemplate.endsWith("\n") ? humanLockTemplate : `${humanLockTemplate}
-`, options);
-  writeNewFile(forensicPath, `${JSON.stringify(forensicReport, null, 2)}
-`, options);
-  const claudeSkillAction = copyTemplateIfMissing(findTemplatePath(CLAUDE_INIT_SKILL_TEMPLATE), claudeSkillPath, options);
-  const claudeHookAction = copyExecutableTemplateIfMissing(
-    findTemplatePath(CLAUDE_INIT_REMINDER_HOOK_TEMPLATE),
-    claudeHookPath,
-    options
-  );
-  const claudeSettingsAction = mergeClaudeStopHook(claudeSettingsPath, options);
+  mkdirSync(dirname(plan.path), { recursive: true });
+  writeJsonAtomically(plan.path, plan.value);
+}
+function buildClaudeSettingsWritePlan(settingsPath, options) {
+  let settings;
+  let action = "updated";
+  if (!existsSync2(settingsPath)) {
+    settings = {};
+    action = "created";
+  } else {
+    try {
+      const parsed = JSON.parse(readFileSync2(settingsPath, "utf8"));
+      if (!isRecord(parsed)) {
+        writeStderr(t("cli.init.claude-settings.invalid-object", { label: skippedLabel(), path: settingsPath }));
+        return { path: settingsPath, action: "skipped-invalid", value: null };
+      }
+      settings = parsed;
+    } catch (error) {
+      const reason = error instanceof Error ? error.message : "unknown parse error";
+      writeStderr(t("cli.init.claude-settings.invalid-json", { label: skippedLabel(), path: settingsPath, reason }));
+      return { path: settingsPath, action: "skipped-invalid", value: null };
+    }
+  }
+  if (settings.hooks !== void 0 && !isRecord(settings.hooks)) {
+    writeStderr(t("cli.init.claude-settings.invalid-hooks", { label: skippedLabel(), path: settingsPath }));
+    return { path: settingsPath, action: "skipped-invalid", value: null };
+  }
+  const hooks = settings.hooks ?? {};
+  const stopHooksValue = hooks.Stop;
+  if (stopHooksValue !== void 0 && !Array.isArray(stopHooksValue)) {
+    writeStderr(t("cli.init.claude-settings.invalid-stop-array", { label: skippedLabel(), path: settingsPath }));
+    return { path: settingsPath, action: "skipped-invalid", value: null };
+  }
+  const stopHooks = Array.isArray(stopHooksValue) ? stopHooksValue : [];
+  const hasExistingFabricHook = hasClaudeInitReminderHook(stopHooks);
+  if (hasExistingFabricHook && !options?.force) {
+    return { path: settingsPath, action: "skipped", value: null };
+  }
+  const nextStopHooks = hasExistingFabricHook && options?.force ? removeClaudeInitReminderHook(stopHooks) : [...stopHooks];
+  nextStopHooks.push({
+    matcher: "*",
+    hooks: [
+      {
+        type: "command",
+        command: CLAUDE_INIT_REMINDER_COMMAND
+      }
+    ]
+  });
+  const nextSettings = {
+    ...settings,
+    hooks: {
+      ...hooks,
+      Stop: nextStopHooks
+    }
+  };
   return {
-    agentsPath,
-    agentsAction,
-    metaPath,
-    metaAction: fabricDirAction,
-    humanLockPath,
-    humanLockAction: fabricDirAction,
-    forensicPath,
-    forensicAction,
-    claudeSkillPath,
-    claudeSkillAction,
-    claudeHookPath,
-    claudeHookAction,
-    claudeSettingsPath,
-    claudeSettingsAction
+    path: settingsPath,
+    action: hasExistingFabricHook && options?.force ? "overwritten" : action,
+    value: nextSettings
   };
 }
-function findAgentsTemplatePath(frameworkKind) {
-  const relativePath = AGENTS_TEMPLATE_BY_FRAMEWORK[frameworkKind] ?? "templates/agents-md/AGENTS.md.template";
-  return findTemplatePath(relativePath);
+function applyClaudeSettingsWritePlan(plan) {
+  if (plan.value === null) {
+    return;
+  }
+  mkdirSync(dirname(plan.path), { recursive: true });
+  writeJsonAtomically(plan.path, plan.value);
+}
+function createDefaultInitWizardAdapter() {
+  return {
+    async run(context) {
+      intro(t("cli.init.wizard.intro"));
+      note(
+        t("cli.init.wizard.overview.body", {
+          target: context.target,
+          mode: formatInitModeBadge(context.options)
+        }),
+        t("cli.init.wizard.overview.title")
+      );
+      printInitPlanSummary(context.target, context.options, context.mcpInstallMode, context.supports);
+      log.step(t("cli.init.wizard.step.target"));
+      const continueWithTarget = await confirm({
+        message: t("cli.init.wizard.target.confirm", { target: context.target }),
+        initialValue: true
+      });
+      if (isCancel(continueWithTarget) || !continueWithTarget) {
+        emitInitWizardCancellation();
+        return null;
+      }
+      log.step(t("cli.init.wizard.step.plan"));
+      let groupedSelection;
+      try {
+        groupedSelection = await group(
+          {
+            bootstrap: async () => context.lockedStages.includes("bootstrap") ? false : confirmInGroup({
+              message: t("cli.init.wizard.stage.bootstrap", {
+                defaultValue: formatPromptDefault(!context.options.skipBootstrap)
+              }),
+              initialValue: !context.options.skipBootstrap
+            }),
+            mcp: async () => context.lockedStages.includes("mcp") ? false : confirmInGroup({
+              message: t("cli.init.wizard.stage.mcp", {
+                defaultValue: formatPromptDefault(!context.options.skipMcp)
+              }),
+              initialValue: !context.options.skipMcp
+            }),
+            mcpInstallMode: async ({ results }) => results.mcp ? selectMcpInstallModeInGroup({
+              message: t("cli.init.wizard.mcp-install", { defaultValue: context.mcpInstallMode }),
+              initialValue: context.mcpInstallMode,
+              options: [
+                { value: "global", label: "global", hint: t("cli.init.mcp.install.global") },
+                { value: "local", label: "local", hint: t("cli.init.mcp.install.local") }
+              ]
+            }) : context.mcpInstallMode,
+            hooks: async () => context.lockedStages.includes("hooks") ? false : confirmInGroup({
+              message: t("cli.init.wizard.stage.hooks", {
+                defaultValue: formatPromptDefault(!context.options.skipHooks)
+              }),
+              initialValue: !context.options.skipHooks
+            })
+          },
+          {
+            onCancel() {
+              throw INIT_WIZARD_GROUP_CANCELLED;
+            }
+          }
+        );
+      } catch (error) {
+        if (error === INIT_WIZARD_GROUP_CANCELLED) {
+          emitInitWizardCancellation();
+          return null;
+        }
+        throw error;
+      }
+      if (groupedSelection === null) {
+        emitInitWizardCancellation();
+        return null;
+      }
+      const previewOptions = {
+        ...context.options,
+        skipBootstrap: !groupedSelection.bootstrap,
+        skipMcp: !groupedSelection.mcp,
+        skipHooks: !groupedSelection.hooks
+      };
+      log.step(t("cli.init.wizard.step.review"));
+      printInitPlanSummary(context.target, previewOptions, groupedSelection.mcpInstallMode, context.supports);
+      const confirmed = await confirm({
+        message: t("cli.init.wizard.execute.confirm"),
+        initialValue: true
+      });
+      if (isCancel(confirmed) || !confirmed) {
+        emitInitWizardCancellation();
+        return null;
+      }
+      outro(t("cli.init.wizard.outro"));
+      return groupedSelection;
+    }
+  };
+}
+function emitInitWizardCancellation() {
+  cancel(t("cli.init.wizard.cancelled"));
+}
+async function confirmInGroup(options) {
+  const result = await confirm(options);
+  if (isCancel(result)) {
+    throw INIT_WIZARD_GROUP_CANCELLED;
+  }
+  return result;
+}
+async function selectMcpInstallModeInGroup(options) {
+  const result = await select({
+    message: options.message,
+    initialValue: options.initialValue,
+    options: options.options
+  });
+  if (isCancel(result)) {
+    throw INIT_WIZARD_GROUP_CANCELLED;
+  }
+  return result;
+}
+function collectLockedWizardStages(args) {
+  const lockedStages = [];
+  if (args.bootstrap === false) {
+    lockedStages.push("bootstrap");
+  }
+  if (args.mcp === false) {
+    lockedStages.push("mcp");
+  }
+  if (args.hooks === false) {
+    lockedStages.push("hooks");
+  }
+  return lockedStages;
+}
+function formatPromptDefault(value) {
+  return value ? "Y/n" : "y/N";
+}
+function formatInitModeBanner(options) {
+  if (options.planOnly && options.reapply) {
+    return t("cli.init.plan.mode-banner.plan-reapply");
+  }
+  if (options.planOnly) {
+    return t("cli.init.plan.mode-banner.plan");
+  }
+  if (options.reapply) {
+    return t("cli.init.plan.mode-banner.reapply");
+  }
+  return t("cli.init.plan.mode-banner.default");
+}
+function formatInitModeBadge(options) {
+  if (options.planOnly && options.reapply) {
+    return t("cli.init.mode.badge.plan-reapply");
+  }
+  if (options.planOnly) {
+    return t("cli.init.mode.badge.plan");
+  }
+  if (options.reapply) {
+    return t("cli.init.mode.badge.reapply");
+  }
+  return t("cli.init.mode.badge.default");
 }
 function normalizeTarget2(targetInput) {
   return isAbsolute2(targetInput) ? targetInput : resolve2(process.cwd(), targetInput);
@@ -1126,7 +1702,7 @@ function createInitialMeta(agentsHash) {
     revision: sha256(agentsHash),
     nodes: {
       L0: {
-        file: "AGENTS.md",
+        file: ".fabric/bootstrap/README.md",
         scope_glob: "**",
         deps: [],
         priority: "high",
@@ -1137,18 +1713,6 @@ function createInitialMeta(agentsHash) {
     }
   };
 }
-function readPackageName(target) {
-  const packageJsonPath = join2(target, "package.json");
-  if (!existsSync2(packageJsonPath)) {
-    return void 0;
-  }
-  try {
-    const packageJson = JSON.parse(readFileSync2(packageJsonPath, "utf8"));
-    return packageJson.name;
-  } catch {
-    return void 0;
-  }
-}
 function findTemplatePath(relativePath) {
   const currentModuleDir = dirname(fileURLToPath(import.meta.url));
   const candidates = [
@@ -1175,93 +1739,6 @@ function templateCandidatesFrom(start, relativePath) {
   }
   return candidates.reverse();
 }
-function prepareFreshPath(path, options) {
-  if (!existsSync2(path)) {
-    return "created";
-  }
-  if (!options?.force) {
-    throw new Error(t("cli.init.errors.abort-existing", { path }));
-  }
-  rmSync(path, { recursive: true, force: true });
-  return "overwritten";
-}
-function writeNewFile(path, content, options) {
-  const existed = existsSync2(path);
-  if (existed && !options?.force) {
-    throw new Error(t("cli.init.errors.abort-existing", { path }));
-  }
-  writeFileSync(path, content, "utf8");
-  return existed ? "overwritten" : "created";
-}
-function copyTemplateIfMissing(templatePath, targetPath, options) {
-  mkdirSync(dirname(targetPath), { recursive: true });
-  const existed = existsSync2(targetPath);
-  if (existed && !options?.force) {
-    return "skipped";
-  }
-  copyFileSync(templatePath, targetPath);
-  return existed ? "overwritten" : "created";
-}
-function copyExecutableTemplateIfMissing(templatePath, targetPath, options) {
-  const action = copyTemplateIfMissing(templatePath, targetPath, options);
-  if (action !== "skipped") {
-    chmodSync(targetPath, 493);
-  }
-  return action;
-}
-function mergeClaudeStopHook(settingsPath, options) {
-  mkdirSync(dirname(settingsPath), { recursive: true });
-  let settings;
-  let action = "updated";
-  if (!existsSync2(settingsPath)) {
-    settings = {};
-    action = "created";
-  } else {
-    try {
-      const parsed = JSON.parse(readFileSync2(settingsPath, "utf8"));
-      if (!isRecord(parsed)) {
-        writeStderr(t("cli.init.claude-settings.invalid-object", { label: skippedLabel(), path: settingsPath }));
-        return "skipped-invalid";
-      }
-      settings = parsed;
-    } catch (error) {
-      const reason = error instanceof Error ? error.message : "unknown parse error";
-      writeStderr(t("cli.init.claude-settings.invalid-json", { label: skippedLabel(), path: settingsPath, reason }));
-      return "skipped-invalid";
-    }
-  }
-  if (settings.hooks !== void 0 && !isRecord(settings.hooks)) {
-    writeStderr(t("cli.init.claude-settings.invalid-hooks", { label: skippedLabel(), path: settingsPath }));
-    return "skipped-invalid";
-  }
-  const hooks = settings.hooks ?? {};
-  const stopHooksValue = hooks.Stop;
-  if (stopHooksValue !== void 0 && !Array.isArray(stopHooksValue)) {
-    writeStderr(t("cli.init.claude-settings.invalid-stop-array", { label: skippedLabel(), path: settingsPath }));
-    return "skipped-invalid";
-  }
-  const stopHooks = Array.isArray(stopHooksValue) ? stopHooksValue : [];
-  const hasExistingFabricHook = hasClaudeInitReminderHook(stopHooks);
-  if (hasExistingFabricHook && !options?.force) {
-    return "skipped";
-  }
-  const nextStopHooks = hasExistingFabricHook && options?.force ? removeClaudeInitReminderHook(stopHooks) : [...stopHooks];
-  nextStopHooks.push({
-    matcher: "*",
-    hooks: [
-      {
-        type: "command",
-        command: CLAUDE_INIT_REMINDER_COMMAND
-      }
-    ]
-  });
-  settings.hooks = {
-    ...hooks,
-    Stop: nextStopHooks
-  };
-  writeJsonAtomically(settingsPath, settings);
-  return hasExistingFabricHook && options?.force ? "overwritten" : action;
-}
 function hasClaudeInitReminderHook(stopHooks) {
   return stopHooks.some((entry) => isClaudeInitReminderStopEntry(entry));
 }
@@ -1304,10 +1781,10 @@ function formatClaudeSettingsAction(settingsPath, action) {
 function formatInitStageHeader(message) {
   return `${nextLabel()} ${paint.muted(message)}`;
 }
-function formatInitStageResult(stage, status, installedCount, skippedCount, note) {
+function formatInitStageResult(stage, status, installedCount, skippedCount, note2) {
   const label = status === "completed" ? completedStageLabel() : skippedStageLabel();
   const counts = `installed=${installedCount} skipped=${skippedCount}`;
-  const suffix = note ? ` ${paint.muted(`(${note})`)}` : "";
+  const suffix = note2 ? ` ${paint.muted(`(${note2})`)}` : "";
   return `${label} ${stage}: ${counts}${suffix}`;
 }
 function formatInitStageFailure(stage, error) {
@@ -1329,6 +1806,155 @@ function collectInitStageNames(stageResults, disposition) {
 function shouldPrintHooksNextStep(options, stageResults) {
   return Boolean(options.skipHooks) || stageResults.some((stage) => stage.name === "hooks" && stage.disposition === "failed");
 }
+function isInteractiveInit() {
+  return Boolean(process.stdin.isTTY) && Boolean(process.stdout.isTTY) && Boolean(process.stderr.isTTY);
+}
+function printInitPlanSummary(target, options, mcpInstallMode, supports) {
+  console.log(t("cli.init.plan.title"));
+  console.log(formatInitModeBanner(options));
+  console.log(t("cli.init.plan.target", { target }));
+  console.log(
+    t("cli.init.plan.actions", {
+      bootstrap: yesNoLabel(!options.skipBootstrap),
+      mcp: yesNoLabel(!options.skipMcp),
+      hooks: yesNoLabel(!options.skipHooks),
+      mcpInstall: mcpInstallMode
+    })
+  );
+  const detected = supports.filter((support) => support.detected);
+  console.log(
+    t("cli.init.plan.detected", {
+      clients: detected.length > 0 ? detected.map((support) => support.label).join(", ") : t("cli.shared.none")
+    })
+  );
+  console.log(t("cli.init.plan.writes"));
+  console.log(`  - ${target}/.fabric/bootstrap/README.md`);
+  console.log(`  - ${target}/.fabric/agents.meta.json`);
+  console.log(`  - ${target}/.fabric/human-lock.json`);
+  console.log(`  - ${target}/.fabric/forensic.json`);
+}
+function printInitCapabilitySummary(supports, stageResults, options) {
+  const detected = supports.filter((support) => support.detected);
+  if (detected.length === 0) {
+    console.log(t("cli.init.capabilities.none"));
+    return;
+  }
+  console.log(t("cli.init.capabilities.title"));
+  const rows = detected.map((support) => toCapabilityRow(support, stageResults, options));
+  const headers = {
+    client: t("cli.init.capabilities.header.client"),
+    bootstrap: t("cli.init.capabilities.header.bootstrap"),
+    mcp: t("cli.init.capabilities.header.mcp"),
+    hook: t("cli.init.capabilities.header.hook"),
+    skill: t("cli.init.capabilities.header.skill"),
+    followUp: t("cli.init.capabilities.header.follow-up")
+  };
+  const widths = {
+    client: Math.max(displayWidth(headers.client), ...rows.map((row) => displayWidth(row.client))),
+    bootstrap: Math.max(displayWidth(headers.bootstrap), ...rows.map((row) => displayWidth(row.bootstrap))),
+    mcp: Math.max(displayWidth(headers.mcp), ...rows.map((row) => displayWidth(row.mcp))),
+    hook: Math.max(displayWidth(headers.hook), ...rows.map((row) => displayWidth(row.hook))),
+    skill: Math.max(displayWidth(headers.skill), ...rows.map((row) => displayWidth(row.skill))),
+    followUp: Math.max(displayWidth(headers.followUp), ...rows.map((row) => displayWidth(row.followUp)))
+  };
+  console.log(formatCapabilityTableRow(headers, widths));
+  console.log(formatCapabilityDivider(widths));
+  for (const row of rows) {
+    console.log(formatCapabilityTableRow(row, widths));
+  }
+}
+function formatCodexHooksAction(configPath, action) {
+  switch (action) {
+    case "created":
+      return t("cli.init.codex-hooks.created", { label: createdLabel(), path: configPath });
+    case "overwritten":
+      return t("cli.init.codex-hooks.updated", { label: overwrittenLabel(), path: configPath });
+    case "skipped":
+      return t("cli.init.codex-hooks.skipped", { label: skippedLabel(), path: configPath });
+    default:
+      return t("cli.init.codex-hooks.updated", { label: updatedLabel(), path: configPath });
+  }
+}
+function toCapabilityRow(support, stageResults, options) {
+  const stage = (name) => stageResults.find((entry) => entry.name === name)?.disposition ?? null;
+  const bootstrap = support.capabilities.bootstrap ? capabilityStatus(options.skipBootstrap ? "skipped" : stage("bootstrap")) : t("cli.init.capabilities.status.na");
+  const mcp = support.capabilities.mcp ? capabilityStatus(options.skipMcp ? "skipped" : stage("mcp")) : t("cli.init.capabilities.status.na");
+  const hook = capabilityInstallStatus(support, "hook");
+  const skill = capabilityInstallStatus(support, "skill");
+  return {
+    client: support.label,
+    bootstrap,
+    mcp,
+    hook,
+    skill,
+    followUp: hasInstalledCapability(support, "skill") ? t("cli.init.capabilities.follow-up.ready") : support.capabilities.skill ? t("cli.init.capabilities.follow-up.install") : t("cli.init.capabilities.follow-up.manual")
+  };
+}
+function capabilityInstallStatus(support, capability) {
+  if (!support.capabilities[capability]) {
+    return t("cli.init.capabilities.status.na");
+  }
+  return hasInstalledCapability(support, capability) ? t("cli.init.capabilities.status.installed") : t("cli.init.capabilities.status.supported");
+}
+function hasInstalledCapability(support, capability) {
+  return support.installedCapabilities?.[capability] === true;
+}
+function capabilityStatus(disposition) {
+  switch (disposition) {
+    case "ran":
+      return t("cli.init.capabilities.status.ready");
+    case "skipped":
+      return t("cli.init.capabilities.status.skipped");
+    case "failed":
+      return t("cli.init.capabilities.status.failed");
+    case null:
+      return t("cli.init.capabilities.status.na");
+    default:
+      return t("cli.init.capabilities.status.ready");
+  }
+}
+function formatCapabilityTableRow(row, widths) {
+  return [
+    padEnd(row.client, widths.client),
+    padEnd(row.bootstrap, widths.bootstrap),
+    padEnd(row.mcp, widths.mcp),
+    padEnd(row.hook, widths.hook),
+    padEnd(row.skill, widths.skill),
+    padEnd(row.followUp, widths.followUp)
+  ].join("  ");
+}
+function formatCapabilityDivider(widths) {
+  return [
+    "".padEnd(widths.client, "-"),
+    "".padEnd(widths.bootstrap, "-"),
+    "".padEnd(widths.mcp, "-"),
+    "".padEnd(widths.hook, "-"),
+    "".padEnd(widths.skill, "-"),
+    "".padEnd(widths.followUp, "-")
+  ].join("  ");
+}
+function formatInitReasonMessage(supports) {
+  const detected = supports.filter((support) => support.detected);
+  const installedSkillClients = detected.filter((support) => hasInstalledCapability(support, "skill"));
+  const hasClaudeSkill = installedSkillClients.some((support) => support.clientKind === "ClaudeCodeCLI");
+  const hasCodexSkill = installedSkillClients.some((support) => support.clientKind === "CodexCLI");
+  if (hasClaudeSkill && hasCodexSkill) {
+    return t("cli.init.reason-message.multi-body");
+  }
+  if (hasClaudeSkill) {
+    return t("cli.init.reason-message.claude-body");
+  }
+  if (hasCodexSkill) {
+    return t("cli.init.reason-message.codex-body");
+  }
+  if (detected.some((support) => support.capabilities.skill)) {
+    return t("cli.init.reason-message.installable-body");
+  }
+  return t("cli.init.reason-message.manual-body");
+}
+function yesNoLabel(value) {
+  return value ? t("cli.shared.yes") : t("cli.shared.no");
+}
 function formatInitPathAction(path, action) {
   return t("cli.init.created-path", { label: labelForInitWriteAction(action), path });
 }
@@ -1376,8 +2002,15 @@ function sha256(content) {
   return `sha256:${createHash("sha256").update(content).digest("hex")}`;
 }
 export {
+  buildInitExecutionPlan,
+  buildInitFabricPlan,
+  createDefaultInitWizardAdapter,
   init_default as default,
   detectPackageManager,
+  executeInitExecutionPlan,
+  executeInitFabricPlan,
   initCommand,
-  initFabric
+  initFabric,
+  resolveInitExecutionPlanWithWizard,
+  shouldUseInitWizard
 };