@fenglimg/fabric-cli 1.3.1 → 1.5.0

package/dist/{init-T3LGMGAO.js → init-YR7EVBYQ.js}

@@ -2,19 +2,10 @@
 import {
   buildFabricBootstrapGuide,
   installBootstrap
-} from "./chunk-TKTWHAKV.js";
+} from "./chunk-T2WJF5I3.js";
 import {
   detectFramework
-} from "./chunk-AZRKMFRY.js";
-import {
-  installMcpClients
-} from "./chunk-XFSQM3LJ.js";
-import {
-  detectClientSupports
-} from "./chunk-VOQKQ6W2.js";
-import {
-  installHooks
-} from "./chunk-YDZJRLHL.js";
+} from "./chunk-QSAEGVKE.js";
 import {
   createDebugLogger,
   resolveDevMode
@@ -24,6 +15,15 @@ import {
   padEnd,
   paint
 } from "./chunk-WWNXR34K.js";
+import {
+  installMcpClients
+} from "./chunk-BVTMVW5M.js";
+import {
+  detectClientSupports
+} from "./chunk-BEKSXO5N.js";
+import {
+  installHooks
+} from "./chunk-YDZJRLHL.js";
 import {
   t
 } from "./chunk-6ICJICVU.js";
@@ -34,14 +34,18 @@ 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
+import { execFileSync } from "child_process";
 import { existsSync, readdirSync, readFileSync, statSync } from "fs";
+import { createRequire } from "module";
 import { basename, extname, isAbsolute, join, posix, relative, resolve, sep } from "path";
 import {
   forensicReportSchema
 } from "@fenglimg/fabric-shared";
+var require2 = createRequire(import.meta.url);
 var IGNORED_DIRECTORIES = /* @__PURE__ */ new Set([
   ".fabric",
   ".git",
@@ -67,9 +71,48 @@ var SCRIPT_EXTENSIONS = /* @__PURE__ */ new Set([".js", ".jsx", ".ts", ".tsx"]);
 var DOMAIN_FILE_EXTENSIONS = /* @__PURE__ */ new Set([".js", ".jsx", ".ts", ".tsx", ".json", ".md"]);
 var EXPECTED_CONFIG_FILES_BY_FRAMEWORK = {
   "cocos-creator": ["package.json", "project.config.json", "tsconfig.json"],
+  react: ["package.json", "tsconfig.json"],
   next: ["package.json", "tsconfig.json"],
   vite: ["package.json", "tsconfig.json"]
 };
+var FRAMEWORK_IMPORT_PROFILES = {
+  "cocos-creator": {
+    pattern: "cocos-component-class",
+    family: "component",
+    statement: "Sampled entry files use Cocos Creator component classes.",
+    proposedRule: "Treat assets/scripts/*.ts and adjacent .meta files as framework-owned structure unless the user says otherwise.",
+    alternatives: ["Generic TypeScript utility module"],
+    rationale: "Cocos framework imports and component markers co-occur in sampled entry files.",
+    packages: ["cc"]
+  },
+  react: {
+    pattern: "react-root",
+    family: "entry",
+    statement: "Sampled entry files import React framework packages.",
+    proposedRule: "Keep root rendering and component composition aligned with React entry conventions.",
+    alternatives: ["Server-rendered route module"],
+    rationale: "AST import declarations reference React packages rather than comments or strings.",
+    packages: ["react", "react-dom", "react/jsx-runtime", "react-dom/client"]
+  },
+  vite: {
+    pattern: "vite-main-entry",
+    family: "entry",
+    statement: "Sampled entry files use the conventional Vite main entrypoint.",
+    proposedRule: "Keep primary bootstrapping logic inside src/main.*.",
+    alternatives: ["Alternative bundler entrypoint"],
+    rationale: "Entry path and framework imports align with a Vite bootstrap surface.",
+    packages: ["@vitejs/plugin-react", "@vitejs/plugin-vue", "vite", "react", "vue"]
+  },
+  next: {
+    pattern: "next-route-component",
+    family: "entry",
+    statement: "Sampled entry files align with Next.js route modules.",
+    proposedRule: "Preserve route-segment boundaries when editing app/ or pages/ files.",
+    alternatives: ["Generic source module"],
+    rationale: "Route placement and Next/React imports anchor these files to the request surface.",
+    packages: ["next", "next/link", "next/navigation", "react"]
+  }
+};
 var SAMPLE_LIMIT = 5;
 var SAMPLE_LINE_LIMIT = 30;
 var ENTRY_FAMILY_LIMIT = 1;
@@ -79,12 +122,17 @@ var DEFAULT_SAMPLING_BUDGET = {
   max_files: 15,
   max_lines_per_file: 100
 };
-function buildForensicReport(targetInput) {
+var treeSitterModulePromise = null;
+var parserInitPromise = null;
+var languagePromiseByKind = {};
+var parserBundlePromiseByKind = {};
+async function buildForensicReport(targetInput) {
   const target = normalizeTarget(targetInput);
   const framework = detectFramework(target);
   const topology = buildTopology(target);
-  const entryPoints = collectEntryPoints(topology.files);
-  const codeSamples = buildCodeSamples(target, entryPoints);
+  const entryPoints = collectEntryPoints(target, topology.files);
+  const packageDependencies = readPackageDependencies(target);
+  const codeSamples = await buildCodeSamples(target, entryPoints, framework.kind, topology, packageDependencies);
   const assertions = buildAssertions(framework.kind, topology, codeSamples);
   const candidateFiles = buildCandidateFiles(topology, codeSamples, entryPoints);
   const readme = readReadmeInfo(target);
@@ -179,7 +227,7 @@ function isKeyDirectory(relativePath) {
   const name = basename(relativePath);
   return KEY_DIRECTORY_NAMES.has(name);
 }
-function collectEntryPoints(files) {
+function collectEntryPoints(target, files) {
   const entryPoints = [];
   for (const file of files) {
     const reason = getEntryPointReason(file.relativePath);
@@ -192,7 +240,9 @@ function collectEntryPoints(files) {
       size_bytes: file.sizeBytes
     });
   }
-  return entryPoints;
+  return entryPoints.sort(
+    (left, right) => compareCandidateScore(readGitChurnWeight(target, right.path), readGitChurnWeight(target, left.path))
+  );
 }
 function getEntryPointReason(relativePath) {
   if (!SCRIPT_EXTENSIONS.has(extname(relativePath))) {
@@ -215,20 +265,26 @@ function getEntryPointReason(relativePath) {
   }
   return null;
 }
-function buildCodeSamples(target, entryPoints) {
-  return entryPoints.slice(0, SAMPLE_LIMIT).map((entryPoint) => {
+async function buildCodeSamples(target, entryPoints, frameworkKind, topology, packageDependencies) {
+  const samples = [];
+  for (const entryPoint of entryPoints.slice(0, SAMPLE_LIMIT)) {
     const absolutePath = join(target, ...entryPoint.path.split("/"));
     const sample = readFirstLines(absolutePath, SAMPLE_LINE_LIMIT);
-    const patternAnalysis = inferPatternHint(entryPoint.path, sample.snippet);
-    return {
+    const patternAnalysis = await inferPatternHint(entryPoint.path, sample.snippet, {
+      frameworkKind,
+      topology,
+      packageDependencies
+    });
+    samples.push({
       path: entryPoint.path,
       lines: `1-${sample.lineCount}`,
       snippet: sample.snippet,
       pattern_hint: patternAnalysis.pattern,
       pattern_analysis: patternAnalysis,
       evidence: buildEvidenceAnchors(entryPoint.path, sample.snippet, patternAnalysis.evidence_lines)
-    };
-  });
+    });
+  }
+  return samples;
 }
 function readFirstLines(path, lineLimit) {
   try {
@@ -248,7 +304,100 @@ function readFirstLines(path, lineLimit) {
     };
   }
 }
-function inferPatternHint(relativePath, snippet) {
+function readPackageDependencies(target) {
+  const packageJsonPath = join(target, "package.json");
+  if (!existsSync(packageJsonPath)) {
+    return /* @__PURE__ */ new Map();
+  }
+  try {
+    const packageJson = JSON.parse(readFileSync(packageJsonPath, "utf8"));
+    return new Map([
+      ...Object.entries(packageJson.dependencies ?? {}),
+      ...Object.entries(packageJson.devDependencies ?? {}),
+      ...Object.entries(packageJson.peerDependencies ?? {}),
+      ...Object.entries(packageJson.optionalDependencies ?? {})
+    ]);
+  } catch {
+    return /* @__PURE__ */ new Map();
+  }
+}
+function readGitChurnWeight(target, relativePath) {
+  try {
+    const output = execFileSync("git", ["log", "--follow", "--oneline", "-20", "--", relativePath], {
+      cwd: target,
+      encoding: "utf8",
+      stdio: ["ignore", "pipe", "ignore"],
+      timeout: 1e3
+    });
+    return output.split(/\r?\n/).filter((line) => line.trim().length > 0).length;
+  } catch {
+    return 0;
+  }
+}
+async function inferPatternHint(relativePath, snippet, options = {}) {
+  const input = {
+    relativePath,
+    snippet,
+    frameworkKind: options.frameworkKind ?? "unknown",
+    topology: options.topology ?? createEmptyTopology(),
+    packageDependencies: options.packageDependencies ?? /* @__PURE__ */ new Map()
+  };
+  const importAnalysis = await analyzeImports(input.relativePath, input.snippet);
+  if (importAnalysis.astLevel) {
+    const astResult = buildAstPatternHint(input, importAnalysis.imports);
+    if (astResult !== null) {
+      return astResult;
+    }
+  }
+  return inferTextPatternHint(input.relativePath, input.snippet);
+}
+function createEmptyTopology() {
+  return {
+    total_files: 0,
+    by_ext: {},
+    key_dirs: [],
+    max_depth: 0,
+    files: []
+  };
+}
+function buildAstPatternHint(input, imports) {
+  const profile = resolveFrameworkImportProfile(input.frameworkKind, input.relativePath, imports);
+  if (profile === null) {
+    return null;
+  }
+  const matchingImports = imports.filter((source) => matchesAnyFrameworkPackage(source, profile.packages));
+  const configFiles = getExpectedConfigFiles(input.frameworkKind).filter((file) => hasFile(input.topology.files, file));
+  const packageMatches = profile.packages.filter((packageName) => input.packageDependencies.has(packageName));
+  const coOccurring = compactPatternNames([
+    ...matchingImports.map((source) => `import:${source}`),
+    ...configFiles.map(normalizeConfigPattern),
+    ...packageMatches.map((packageName) => `package:${packageName}`),
+    input.relativePath.startsWith("app/") ? "app-router" : null,
+    input.relativePath.startsWith("pages/") ? "pages-router" : null,
+    input.relativePath === "src/main.ts" || input.relativePath === "src/main.js" ? "main-entry" : null,
+    input.snippet.includes("@ccclass(") ? "ccclass-decorator" : null,
+    input.snippet.includes("extends Component") ? "component-base" : null
+  ]);
+  return {
+    pattern: profile.pattern,
+    type: "pattern",
+    confidence: scoreFrameworkConfidence({
+      importCount: matchingImports.length,
+      configCount: configFiles.length,
+      packageCount: packageMatches.length,
+      astLevel: true
+    }),
+    evidence_lines: matchingImports.length > 0 ? matchingImports : imports.slice(0, 3),
+    co_occurring: coOccurring,
+    family: profile.family,
+    ast_level: true,
+    statement: profile.statement,
+    proposed_rule: profile.proposedRule,
+    alternatives: profile.alternatives,
+    rationale: profile.rationale
+  };
+}
+function inferTextPatternHint(relativePath, snippet) {
   const cocosCoOccurring = compactPatternNames([
     snippet.includes('from "cc"') || snippet.includes("from 'cc'") ? "cc-import" : null,
     snippet.includes("@ccclass(") || snippet.includes("ccclass(") ? "ccclass-decorator" : null,
@@ -256,11 +405,16 @@ function inferPatternHint(relativePath, snippet) {
     snippet.includes("const { ccclass } = _decorator") ? "decorator-destructure" : null
   ]);
   if (cocosCoOccurring.length > 0) {
-    const astLevel = snippet.includes("@ccclass(");
     return {
       pattern: "cocos-component-class",
       type: "pattern",
-      confidence: determineConfidence(1, cocosCoOccurring, astLevel),
+      confidence: scoreFrameworkConfidence({
+        importCount: 0,
+        configCount: 0,
+        packageCount: 0,
+        astLevel: false,
+        keywordCount: cocosCoOccurring.length
+      }),
       evidence_lines: compactPatternNames([
         snippet.includes("_decorator") ? "_decorator" : null,
         snippet.includes("@ccclass(") ? "@ccclass(" : null,
@@ -268,7 +422,7 @@ function inferPatternHint(relativePath, snippet) {
       ]),
       co_occurring: cocosCoOccurring,
       family: "component",
-      ast_level: astLevel,
+      ast_level: false,
       statement: "Sampled entry files use Cocos Creator component classes.",
       proposed_rule: "Treat assets/scripts/*.ts and adjacent .meta files as framework-owned structure unless the user says otherwise.",
       alternatives: ["Generic TypeScript utility module"],
@@ -284,7 +438,13 @@ function inferPatternHint(relativePath, snippet) {
     return {
       pattern: "react-root",
       type: "pattern",
-      confidence: determineConfidence(1, reactCoOccurring, false),
+      confidence: scoreFrameworkConfidence({
+        importCount: 0,
+        configCount: 0,
+        packageCount: 0,
+        astLevel: false,
+        keywordCount: reactCoOccurring.length
+      }),
       evidence_lines: compactPatternNames([
         snippet.includes("createRoot(") ? "createRoot(" : null,
         snippet.includes("ReactDOM.render(") ? "ReactDOM.render(" : null
@@ -307,7 +467,13 @@ function inferPatternHint(relativePath, snippet) {
     return {
       pattern: "next-route-component",
       type: "pattern",
-      confidence: determineConfidence(1, coOccurring, false),
+      confidence: scoreFrameworkConfidence({
+        importCount: 0,
+        configCount: 0,
+        packageCount: 0,
+        astLevel: false,
+        keywordCount: coOccurring.length
+      }),
       evidence_lines: compactPatternNames([
         relativePath.startsWith("app/") ? "app/" : null,
         relativePath.startsWith("pages/") ? "pages/" : null
@@ -330,7 +496,13 @@ function inferPatternHint(relativePath, snippet) {
     return {
       pattern: "vite-main-entry",
       type: "pattern",
-      confidence: determineConfidence(1, coOccurring, false),
+      confidence: scoreFrameworkConfidence({
+        importCount: 0,
+        configCount: 0,
+        packageCount: 0,
+        astLevel: false,
+        keywordCount: coOccurring.length
+      }),
       evidence_lines: ["src/main"],
       co_occurring: coOccurring,
       family: "entry",
@@ -354,6 +526,125 @@ function inferPatternHint(relativePath, snippet) {
     rationale: "No strong framework markers were detected in the sampled snippet."
   };
 }
+async function analyzeImports(relativePath, snippet) {
+  if (snippet.trim().length === 0) {
+    return { imports: [], astLevel: false };
+  }
+  try {
+    const imports = await extractImports(snippet, getLanguageKindForPath(relativePath));
+    return { imports, astLevel: true };
+  } catch {
+    return { imports: [], astLevel: false };
+  }
+}
+async function extractImports(source, languageKind) {
+  const { parser } = await loadTreeSitter(languageKind);
+  let tree = null;
+  try {
+    tree = parser.parse(source);
+    if (tree === null || tree.rootNode.hasError) {
+      throw new Error("tree-sitter parse failed");
+    }
+    const imports = [];
+    collectImportSources(tree.rootNode, imports);
+    return compactPatternNames(imports);
+  } finally {
+    tree?.delete();
+  }
+}
+async function loadTreeSitter(languageKind) {
+  parserBundlePromiseByKind[languageKind] ??= createTreeSitterParserBundle(languageKind);
+  return parserBundlePromiseByKind[languageKind];
+}
+async function createTreeSitterParserBundle(languageKind) {
+  const treeSitter = await loadTreeSitterModule();
+  await initTreeSitterParser(treeSitter);
+  const language = await loadTreeSitterLanguage(treeSitter, languageKind);
+  const parser = new treeSitter.Parser();
+  parser.setLanguage(language);
+  return { parser, language };
+}
+function loadTreeSitterModule() {
+  treeSitterModulePromise ??= import("web-tree-sitter");
+  return treeSitterModulePromise;
+}
+function initTreeSitterParser(treeSitter) {
+  parserInitPromise ??= treeSitter.Parser.init({
+    locateFile: (scriptName) => scriptName.endsWith(".wasm") ? require2.resolve("web-tree-sitter/web-tree-sitter.wasm") : scriptName
+  });
+  return parserInitPromise;
+}
+function loadTreeSitterLanguage(treeSitter, languageKind) {
+  languagePromiseByKind[languageKind] ??= treeSitter.Language.load(resolveTreeSitterGrammarPath(languageKind));
+  return languagePromiseByKind[languageKind];
+}
+function resolveTreeSitterGrammarPath(languageKind) {
+  switch (languageKind) {
+    case "typescript":
+      return require2.resolve("tree-sitter-typescript/tree-sitter-typescript.wasm");
+    case "tsx":
+      return require2.resolve("tree-sitter-typescript/tree-sitter-tsx.wasm");
+    case "javascript":
+      return require2.resolve("tree-sitter-javascript/tree-sitter-javascript.wasm");
+  }
+}
+function getLanguageKindForPath(relativePath) {
+  const extension = extname(relativePath);
+  if (extension === ".tsx") {
+    return "tsx";
+  }
+  if (extension === ".ts") {
+    return "typescript";
+  }
+  return "javascript";
+}
+function collectImportSources(node, imports) {
+  if (node.type === "import_statement" || node.type === "import_declaration") {
+    const sourceNode = node.childForFieldName("source");
+    if (sourceNode !== null) {
+      const source = stripStringLiteral(sourceNode.text);
+      if (source.length > 0) {
+        imports.push(source);
+      }
+    }
+  }
+  for (let index = 0; index < node.namedChildCount; index += 1) {
+    const child = node.namedChild(index);
+    if (child !== null) {
+      collectImportSources(child, imports);
+    }
+  }
+}
+function stripStringLiteral(value) {
+  return value.replace(/^['"]|['"]$/g, "");
+}
+function resolveFrameworkImportProfile(frameworkKind, relativePath, imports) {
+  const primaryProfile = FRAMEWORK_IMPORT_PROFILES[frameworkKind];
+  if (primaryProfile !== void 0 && imports.some((source) => matchesAnyFrameworkPackage(source, primaryProfile.packages))) {
+    return primaryProfile;
+  }
+  if ((relativePath.startsWith("app/") || relativePath.startsWith("pages/")) && FRAMEWORK_IMPORT_PROFILES.next !== void 0) {
+    return FRAMEWORK_IMPORT_PROFILES.next;
+  }
+  return Object.values(FRAMEWORK_IMPORT_PROFILES).find(
+    (profile) => imports.some((source) => matchesAnyFrameworkPackage(source, profile.packages))
+  ) ?? null;
+}
+function matchesAnyFrameworkPackage(source, packageNames) {
+  return packageNames.some((packageName) => source === packageName || source.startsWith(`${packageName}/`));
+}
+function scoreFrameworkConfidence(input) {
+  if (!input.astLevel) {
+    return (input.keywordCount ?? 0) > 0 ? "MEDIUM" : "LOW";
+  }
+  if (input.importCount > 3) {
+    return "HIGH";
+  }
+  if (input.importCount >= 1 && input.importCount <= 3) {
+    return input.configCount > 0 || input.packageCount > 0 ? "MEDIUM" : "MEDIUM";
+  }
+  return input.configCount > 0 || input.packageCount > 0 ? "MEDIUM" : "LOW";
+}
 function readReadmeInfo(target) {
   const readmePath = join(target, "README.md");
   const hasContributing = existsSync(join(target, "CONTRIBUTING.md"));
@@ -856,7 +1147,7 @@ function readProjectName(target) {
   return basename(target);
 }
 function getCliVersion() {
-  return true ? "1.3.1" : "unknown";
+  return true ? "1.5.0" : "unknown";
 }
 function sortRecord(record) {
   return Object.fromEntries(Object.entries(record).sort(([left], [right]) => left.localeCompare(right)));
@@ -869,8 +1160,14 @@ function toPosixPath(path) {
 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",
@@ -891,6 +1188,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,
@@ -918,178 +1230,727 @@ 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
-    };
-    logger(`init target source: ${resolution.source}`);
-    for (const step of resolution.chain) {
-      logger(step);
-    }
-    const supports = detectClientSupports(target);
-    const interactive = args.interactive !== false && isInteractiveInit();
-    if (options.force) {
-      writeStderr(t("cli.init.force.warning", { path: target }));
-    }
-    if (interactive) {
-      printInitPlanSummary(target, options, mcpInstallMode, supports);
-    }
-    const created = initFabric(target, options);
-    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.claudeHookPath, created.claudeHookAction)
-    );
-    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 });
-        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" });
-        }
-      } catch (error) {
-        writeStderr(formatInitStageFailure("bootstrap", error));
-        stageResults.push({ name: "bootstrap", disposition: "failed" });
-      }
-    }
-    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);
-          writeStderr(t("cli.init.mcp.install.local"));
-          writeStderr(t("cli.init.mcp.local.installing", { manager }));
-          installLocalFabricServer(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
-        });
-        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" });
-        }
-      } catch (error) {
-        writeStderr(formatInitStageFailure("mcp", error));
-        stageResults.push({ name: "mcp", disposition: "failed" });
-      }
-    }
-    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 });
-        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" });
-      }
-    }
-    if (shouldPrintHooksNextStep(options, stageResults)) {
-      console.log(
-        t("cli.init.next-step", {
-          label: nextLabel(),
-          message: paint.muted(t("cli.init.next-step.message"))
-        })
-      );
-    }
-    console.log(
-      t("cli.init.reason-message", {
-        label: reasonLabel(),
-        message: paint.muted(formatInitReasonMessage(supports))
-      })
-    );
-    printInitStageSummary(stageResults);
-    printInitCapabilitySummary(supports, stageResults, options);
+    await runInitCommand(args);
   }
 });
 var init_default = initCommand;
-function initFabric(target, options) {
+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 = await 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
+  };
+}
+async function buildInitExecutionPlan(input) {
+  const options = input.options ?? {};
+  const scaffold = await 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
+    };
+  }
+  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);
+    }
+  }
+  return {
+    plan,
+    created: created ?? unreachableInitScaffold(),
+    stageResults,
+    finalSupports
+  };
+}
+async 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");
-  prepareWritableDirectory(fabricDir, options);
-  const bootstrapAction = prepareFreshPath(bootstrapPath, options);
-  const metaAction = prepareFreshPath(metaPath, options);
-  const humanLockAction = prepareFreshPath(humanLockPath, options);
-  const forensicAction = prepareFreshPath(forensicPath, options);
-  const forensicReport = buildForensicReport(target);
+  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 = await buildForensicReport(target);
   const humanLockTemplate = readFileSync2(findTemplatePath("templates/fabric/human-lock.json"), "utf8");
-  const bootstrapContent = buildFabricBootstrapGuide(target);
+  const bootstrapContent = await buildFabricBootstrapGuide(target);
   const bootstrapHash = sha256(bootstrapContent);
   const meta = createInitialMeta(bootstrapHash);
-  mkdirSync(fabricDir, { recursive: true });
-  mkdirSync(dirname(bootstrapPath), { recursive: true });
-  writeNewFile(bootstrapPath, bootstrapContent, 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);
   return {
+    target,
+    options,
+    fabricDir,
+    replaceFabricDir,
     bootstrapPath,
     bootstrapAction,
+    bootstrapContent,
     metaPath,
     metaAction,
+    meta,
     humanLockPath,
     humanLockAction,
+    humanLockContent: humanLockTemplate.endsWith("\n") ? humanLockTemplate : `${humanLockTemplate}
+`,
     forensicPath,
     forensicAction,
-    claudeSkillPath,
-    claudeSkillAction,
-    claudeHookPath,
-    claudeHookAction,
-    claudeSettingsPath,
-    claudeSettingsAction
+    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
+  };
+}
+async function initFabric(target, options) {
+  return executeInitFabricPlan(await 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"))
+      })
+    );
+  }
+  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")));
+          return { name: "bootstrap", disposition: "skipped" };
+        }
+        console.log(
+          formatInitStageResult("bootstrap", "completed", result.installed.length, result.skipped.length)
+        );
+        return { name: "bootstrap", disposition: "ran" };
+      }
+      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(plan.target, manager);
+          writeStderr(t("cli.init.mcp.local.installed"));
+        } else {
+          writeStderr(t("cli.init.mcp.install.global"));
+        }
+        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")));
+          return { name: "mcp", disposition: "skipped" };
+        }
+        console.log(formatInitStageResult("mcp", "completed", result.installed.length, result.skipped.length));
+        return { name: "mcp", disposition: "ran" };
+      }
+      case "hooks": {
+        const result = await installHooks(plan.target, { force: plan.options.force });
+        console.log(formatInitStageResult("hooks", "completed", result.installed.length, result.skipped.length));
+        return { name: "hooks", disposition: "ran" };
+      }
+      default:
+        return exhaustiveInitStagePlan(stage);
+    }
+  } 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 }]
+        }
+      ]
+    }
+  };
+}
+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;
+  }
+  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 {
+    path: settingsPath,
+    action: hasExistingFabricHook && options?.force ? "overwritten" : action,
+    value: nextSettings
+  };
+}
+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);
 }
@@ -1168,102 +2029,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 prepareWritableDirectory(path, options) {
-  if (!existsSync2(path) || statSync2(path).isDirectory()) {
-    return;
-  }
-  if (!options?.force) {
-    throw new Error(t("cli.init.errors.abort-existing", { path }));
-  }
-  rmSync(path, { force: true });
-}
-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));
 }
@@ -1306,10 +2071,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) {
@@ -1332,10 +2097,11 @@ function shouldPrintHooksNextStep(options, stageResults) {
   return Boolean(options.skipHooks) || stageResults.some((stage) => stage.name === "hooks" && stage.disposition === "failed");
 }
 function isInteractiveInit() {
-  return Boolean(process.stdout.isTTY) && Boolean(process.stderr.isTTY);
+  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", {
@@ -1387,21 +2153,42 @@ function printInitCapabilitySummary(supports, stageResults, options) {
     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 = support.capabilities.hook ? capabilityStatus("ran") : t("cli.init.capabilities.status.na");
-  const skill = support.capabilities.skill ? t("cli.init.capabilities.status.installed") : t("cli.init.capabilities.status.manual");
+  const hook = capabilityInstallStatus(support, "hook");
+  const skill = capabilityInstallStatus(support, "skill");
   return {
     client: support.label,
     bootstrap,
     mcp,
     hook,
     skill,
-    followUp: support.capabilities.skill ? t("cli.init.capabilities.follow-up.ready") : t("cli.init.capabilities.follow-up.manual")
+    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":
@@ -1437,8 +2224,21 @@ function formatCapabilityDivider(widths) {
   ].join("  ");
 }
 function formatInitReasonMessage(supports) {
-  if (supports.some((support) => support.detected && support.capabilities.skill)) {
-    return t("cli.init.reason-message.body");
+  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");
 }
@@ -1492,8 +2292,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
 };