wp-typia 0.20.5 → 0.22.0

package/dist-bunli/node-cli.js

@@ -3,7 +3,7 @@ var __require = /* @__PURE__ */ createRequire(import.meta.url);
 // package.json
 var package_default = {
   name: "wp-typia",
-  version: "0.20.5",
+  version: "0.22.0",
   description: "Canonical CLI package for wp-typia scaffolding and project workflows",
   packageManager: "bun@1.3.11",
   type: "module",
@@ -17,7 +17,9 @@ var package_default = {
     "package.json"
   ],
   scripts: {
-    generate: "bun scripts/generate-bunli-metadata.ts",
+    "generate:routing": "node scripts/generate-routing-metadata.mjs",
+    "validate:routing": "node scripts/generate-routing-metadata.mjs --check",
+    generate: "node scripts/generate-routing-metadata.mjs && bun scripts/generate-bunli-metadata.ts",
     build: "bun run generate && bun scripts/build-bunli-runtime.ts",
     "build:standalone": "bun scripts/build-standalone-runtime.ts --targets native --outdir ./dist-standalone",
     "build:standalone:release": "bun scripts/build-standalone-runtime.ts --targets darwin-arm64,darwin-x64,linux-arm64,linux-x64,windows-x64 --outdir ./.cache/standalone/raw",
@@ -71,7 +73,7 @@ var package_default = {
     "@bunli/tui": "0.6.0",
     "@bunli/utils": "0.6.0",
     "@wp-typia/api-client": "^0.4.5",
-    "@wp-typia/project-tools": "0.20.2",
+    "@wp-typia/project-tools": "0.22.0",
     "better-result": "^2.7.0",
     react: "^19.2.5",
     "react-dom": "^19.2.5",
@@ -95,8 +97,9 @@ var package_default = {
 
 // src/node-cli.ts
 import {
-  CLI_DIAGNOSTIC_CODES,
+  CLI_DIAGNOSTIC_CODES as CLI_DIAGNOSTIC_CODES5,
   createCliCommandError,
+  createCliDiagnosticCodeError as createCliDiagnosticCodeError5,
   formatCliDiagnosticError,
   serializeCliDiagnosticError
 } from "@wp-typia/project-tools/cli-diagnostics";
@@ -199,8 +202,12 @@ var ADD_OPTION_METADATA = {
     description: "Anchor block name for hooked-block workflows.",
     type: "string"
   },
+  attribute: {
+    description: "Target block attribute for end-to-end binding-source workflows.",
+    type: "string"
+  },
   block: {
-    description: "Target block slug for variation workflows.",
+    description: "Target block slug for variation, style, and end-to-end binding-source workflows.",
     type: "string"
   },
   "data-storage": {
@@ -220,6 +227,10 @@ var ADD_OPTION_METADATA = {
     description: "Local path, GitHub locator, or npm package that exposes wp-typia.layers.json for built-in block templates.",
     type: "string"
   },
+  from: {
+    description: "Source full block name (namespace/block) for transform workflows.",
+    type: "string"
+  },
   "inner-blocks-preset": {
     description: "Compound-only InnerBlocks preset (freeform, ordered, horizontal, locked-structure).",
     type: "string"
@@ -241,11 +252,31 @@ var ADD_OPTION_METADATA = {
     type: "string"
   },
   slot: {
-    description: "Document editor shell slot for editor-plugin workflows.",
+    description: "Document editor shell slot for editor-plugin workflows (sidebar or document-setting-panel).",
+    type: "string"
+  },
+  source: {
+    description: "Optional data source locator for admin-view workflows, such as rest-resource:products or core-data:postType/post.",
     type: "string"
   },
   template: {
-    description: "Built-in block family for the new block.",
+    description: "Optional built-in block family for the new block; interactive flows let you choose it when omitted and non-interactive runs default to basic.",
+    type: "string"
+  },
+  to: {
+    description: "Target workspace block slug or full block name for transform workflows.",
+    type: "string"
+  }
+};
+var INIT_OPTION_METADATA = {
+  apply: {
+    argumentKind: "flag",
+    description: "Write the planned package.json updates and retrofit helper files instead of previewing only.",
+    type: "boolean"
+  },
+  "package-manager": {
+    description: "Package manager to use for emitted scripts and next steps.",
+    short: "p",
     type: "string"
   }
 };
@@ -297,6 +328,12 @@ var SYNC_OPTION_METADATA = {
     type: "boolean"
   }
 };
+var DOCTOR_OPTION_METADATA = {
+  format: {
+    description: "Use `json` for machine-readable doctor check output.",
+    type: "string"
+  }
+};
 var TEMPLATES_OPTION_METADATA = {
   id: {
     description: "Template id for `templates inspect`.",
@@ -322,6 +359,30 @@ var GLOBAL_OPTION_METADATA = {
     type: "string"
   }
 };
+var COMMAND_OPTION_METADATA_BY_GROUP = {
+  add: ADD_OPTION_METADATA,
+  create: CREATE_OPTION_METADATA,
+  doctor: DOCTOR_OPTION_METADATA,
+  global: GLOBAL_OPTION_METADATA,
+  init: INIT_OPTION_METADATA,
+  migrate: MIGRATE_OPTION_METADATA,
+  sync: SYNC_OPTION_METADATA,
+  templates: TEMPLATES_OPTION_METADATA
+};
+var COMMAND_OPTION_GROUP_NAMES = Object.keys(COMMAND_OPTION_METADATA_BY_GROUP);
+function collectCommandOptionMetadata(...groupNames) {
+  const metadata = {};
+  for (const groupName of groupNames) {
+    for (const [optionName, option] of Object.entries(COMMAND_OPTION_METADATA_BY_GROUP[groupName])) {
+      metadata[optionName] = {
+        ...metadata[optionName] ?? {},
+        ...option
+      };
+    }
+  }
+  return metadata;
+}
+var ALL_COMMAND_OPTION_METADATA = collectCommandOptionMetadata(...COMMAND_OPTION_GROUP_NAMES);
 function collectOptionNamesByType(metadata, type) {
   return Object.entries(metadata).filter(([, option]) => option.type === type).map(([name]) => name);
 }
@@ -332,13 +393,99 @@ function formatNodeFallbackOptionHelp(metadata) {
   });
 }
 function buildCommandOptionParser(...metadataMaps) {
-  const metadata = Object.assign({}, ...metadataMaps);
+  const metadata = {};
+  for (const metadataMap of metadataMaps) {
+    for (const [optionName, option] of Object.entries(metadataMap)) {
+      metadata[optionName] = {
+        ...metadata[optionName] ?? {},
+        ...option
+      };
+    }
+  }
   return {
     booleanOptionNames: new Set(collectOptionNamesByType(metadata, "boolean")),
     shortFlagMap: new Map(Object.entries(metadata).flatMap(([name, option]) => option.short ? [[option.short, { name, type: option.type }]] : [])),
     stringOptionNames: new Set(collectOptionNamesByType(metadata, "string"))
   };
 }
+function buildArgvWalkerRoutingMetadata(...metadataMaps) {
+  const parser = buildCommandOptionParser(...metadataMaps);
+  return {
+    longValueOptions: Array.from(parser.stringOptionNames).map((optionName) => `--${optionName}`).sort((left, right) => left.localeCompare(right)),
+    shortValueOptions: Array.from(parser.shortFlagMap.entries()).filter(([, option]) => option.type === "string").map(([short]) => `-${short}`).sort((left, right) => left.localeCompare(right))
+  };
+}
+var COMMAND_ROUTING_METADATA = buildArgvWalkerRoutingMetadata(ALL_COMMAND_OPTION_METADATA);
+function extractKnownOptionValuesFromArgv(argv, options) {
+  const flags = {};
+  const nextArgv = [];
+  const optionNames = new Set(options.optionNames);
+  for (let index = 0;index < argv.length; index += 1) {
+    const arg = argv[index];
+    if (!arg) {
+      continue;
+    }
+    if (arg === "--") {
+      nextArgv.push(...argv.slice(index));
+      break;
+    }
+    if (arg.length === 2 && arg.startsWith("-")) {
+      const shortFlag = options.parser.shortFlagMap.get(arg.slice(1));
+      if (!shortFlag || !optionNames.has(shortFlag.name)) {
+        nextArgv.push(arg);
+        continue;
+      }
+      if (shortFlag.type === "boolean") {
+        flags[shortFlag.name] = true;
+        continue;
+      }
+      const next = argv[index + 1];
+      if (!next || next.startsWith("-")) {
+        throw new Error(`\`${arg}\` requires a value.`);
+      }
+      flags[shortFlag.name] = next;
+      index += 1;
+      continue;
+    }
+    if (arg.startsWith("--")) {
+      const option = arg.slice(2);
+      const separatorIndex = option.indexOf("=");
+      const rawName = separatorIndex === -1 ? option : option.slice(0, separatorIndex);
+      const inlineValue = separatorIndex === -1 ? undefined : option.slice(separatorIndex + 1);
+      if (!optionNames.has(rawName)) {
+        nextArgv.push(arg);
+        continue;
+      }
+      if (options.parser.booleanOptionNames.has(rawName)) {
+        flags[rawName] = true;
+        continue;
+      }
+      if (!options.parser.stringOptionNames.has(rawName)) {
+        nextArgv.push(arg);
+        continue;
+      }
+      if (inlineValue !== undefined) {
+        if (!inlineValue) {
+          throw new Error(`\`--${rawName}\` requires a value.`);
+        }
+        flags[rawName] = inlineValue;
+        continue;
+      }
+      const next = argv[index + 1];
+      if (!next || next.startsWith("-")) {
+        throw new Error(`\`--${rawName}\` requires a value.`);
+      }
+      flags[rawName] = next;
+      index += 1;
+      continue;
+    }
+    nextArgv.push(arg);
+  }
+  return {
+    argv: nextArgv,
+    flags
+  };
+}
 function parseCommandArgvWithMetadata(argv, options) {
   const flags = {};
   const positionals = [];
@@ -435,17 +582,10 @@ import {
 } from "@wp-typia/project-tools/cli-templates";
 
 // src/add-kind-registry.ts
-var ADD_KIND_IDS = [
-  "block",
-  "variation",
-  "pattern",
-  "binding-source",
-  "rest-resource",
-  "ability",
-  "ai-feature",
-  "editor-plugin",
-  "hooked-block"
-];
+import {
+  CLI_DIAGNOSTIC_CODES,
+  createCliDiagnosticCodeError
+} from "@wp-typia/project-tools/cli-diagnostics";
 var BLOCK_VISIBLE_FIELD_ORDER = [
   "kind",
   "name",
@@ -455,30 +595,123 @@ var BLOCK_VISIBLE_FIELD_ORDER = [
   "data-storage",
   "persistence-policy"
 ];
-function isAddKindId(value) {
-  return typeof value === "string" && ADD_KIND_IDS.includes(value);
+function readOptionalStringFlag(flags, name) {
+  const value = flags[name];
+  if (value === undefined || value === null) {
+    return;
+  }
+  if (typeof value !== "string" || value.trim().length === 0) {
+    throw createCliDiagnosticCodeError(CLI_DIAGNOSTIC_CODES.MISSING_ARGUMENT, `\`--${name}\` requires a value.`);
+  }
+  return value;
+}
+function requireAddKindName(context, message) {
+  if (!context.name) {
+    throw createCliDiagnosticCodeError(CLI_DIAGNOSTIC_CODES.MISSING_ARGUMENT, message);
+  }
+  return context.name;
+}
+function formatExternalLayerSelectHint(option) {
+  const details = [
+    option.description,
+    option.extends.length > 0 ? `extends ${option.extends.join(", ")}` : undefined
+  ].filter((value) => typeof value === "string" && value.length > 0);
+  return details.length > 0 ? details.join(" · ") : undefined;
+}
+function toExternalLayerPromptOptions(options) {
+  return options.map((option) => ({
+    hint: formatExternalLayerSelectHint(option),
+    label: option.id,
+    value: option.id
+  }));
+}
+function defineAddKindRegistryEntry(entry) {
+  return entry;
 }
 function isAddPersistenceTemplate(template) {
   return template === "persistence" || template === "compound";
 }
 var ADD_KIND_REGISTRY = {
-  "binding-source": {
+  "admin-view": defineAddKindRegistryEntry({
+    completion: {
+      nextSteps: (values) => [
+        `Review src/admin-views/${values.adminViewSlug}/ and inc/admin-views/${values.adminViewSlug}.php.`,
+        "Run your workspace build or dev command to verify the generated DataViews admin screen."
+      ],
+      summaryLines: (values, projectDir) => [
+        `Admin view: ${values.adminViewSlug}`,
+        ...values.source ? [`Source: ${values.source}`] : [],
+        `Project directory: ${projectDir}`
+      ],
+      title: "Added DataViews admin screen"
+    },
+    description: "Add an opt-in DataViews-powered admin screen",
+    nameLabel: "Admin view name",
+    async prepareExecution(context) {
+      const name = requireAddKindName(context, "`wp-typia add admin-view` requires <name>. Usage: wp-typia add admin-view <name> [--source <rest-resource:slug|core-data:kind/name>].");
+      const source = readOptionalStringFlag(context.flags, "source");
+      return {
+        execute: (cwd) => context.addRuntime.runAddAdminViewCommand({
+          adminViewName: name,
+          cwd,
+          source
+        }),
+        getValues: (result) => ({
+          adminViewSlug: result.adminViewSlug,
+          ...result.source ? { source: result.source } : {}
+        })
+      };
+    },
+    sortOrder: 10,
+    supportsDryRun: true,
+    usage: "wp-typia add admin-view <name> [--source <rest-resource:slug|core-data:kind/name>] [--dry-run]",
+    visibleFieldNames: () => ["kind", "name", "source"]
+  }),
+  "binding-source": defineAddKindRegistryEntry({
     completion: {
       nextSteps: (values) => [
         `Review src/bindings/${values.bindingSourceSlug}/server.php and src/bindings/${values.bindingSourceSlug}/editor.ts.`,
+        ...values.blockSlug && values.attributeName ? [
+          `Review src/blocks/${values.blockSlug}/block.json for the ${values.attributeName} bindable attribute.`
+        ] : [],
         "Run your workspace build or dev command to verify the binding source hooks and editor registration."
       ],
       summaryLines: (values, projectDir) => [
         `Binding source: ${values.bindingSourceSlug}`,
+        ...values.blockSlug && values.attributeName ? [`Target: ${values.blockSlug}.${values.attributeName}`] : [],
         `Project directory: ${projectDir}`
       ],
       title: "Added binding source"
     },
     description: "Add a shared block bindings source",
     nameLabel: "Binding source name",
-    visibleFieldNames: () => ["kind", "name"]
-  },
-  block: {
+    async prepareExecution(context) {
+      const name = requireAddKindName(context, "`wp-typia add binding-source` requires <name>. Usage: wp-typia add binding-source <name> [--block <block-slug|namespace/block-slug> --attribute <attribute>].");
+      const blockName = readOptionalStringFlag(context.flags, "block");
+      const attributeName = readOptionalStringFlag(context.flags, "attribute");
+      if (Boolean(blockName) !== Boolean(attributeName)) {
+        throw createCliDiagnosticCodeError(CLI_DIAGNOSTIC_CODES.MISSING_ARGUMENT, "`wp-typia add binding-source` requires --block and --attribute to be provided together.");
+      }
+      return {
+        execute: (cwd) => context.addRuntime.runAddBindingSourceCommand({
+          attributeName,
+          bindingSourceName: name,
+          blockName,
+          cwd
+        }),
+        getValues: (result) => ({
+          ...result.attributeName ? { attributeName: result.attributeName } : {},
+          ...result.blockSlug ? { blockSlug: result.blockSlug } : {},
+          bindingSourceSlug: result.bindingSourceSlug
+        })
+      };
+    },
+    sortOrder: 70,
+    supportsDryRun: true,
+    usage: "wp-typia add binding-source <name> [--block <block-slug|namespace/block-slug> --attribute <attribute>] [--dry-run]",
+    visibleFieldNames: () => ["kind", "name", "block", "attribute"]
+  }),
+  block: defineAddKindRegistryEntry({
     completion: {
       nextSteps: () => [
         "Review the generated sources under src/blocks/ and the updated scripts/block-config.ts entry.",
@@ -494,6 +727,50 @@ var ADD_KIND_REGISTRY = {
     description: "Add a real block slice",
     hiddenStringSubmitFields: ["external-layer-id", "external-layer-source"],
     nameLabel: "Block name",
+    async prepareExecution(context) {
+      const name = requireAddKindName(context, "`wp-typia add block` requires <name>. Usage: wp-typia add block <name> [--template <basic|interactivity|persistence|compound>]");
+      const externalLayerId = readOptionalStringFlag(context.flags, "external-layer-id");
+      const externalLayerSource = readOptionalStringFlag(context.flags, "external-layer-source");
+      const shouldPromptForLayerSelection = Boolean(externalLayerSource) && !Boolean(externalLayerId) && context.isInteractiveSession;
+      const selectPrompt = shouldPromptForLayerSelection ? await context.getOrCreatePrompt() : undefined;
+      const alternateRenderTargets = readOptionalStringFlag(context.flags, "alternate-render-targets");
+      const dataStorageMode = readOptionalStringFlag(context.flags, "data-storage");
+      const innerBlocksPreset = readOptionalStringFlag(context.flags, "inner-blocks-preset");
+      const persistencePolicy = readOptionalStringFlag(context.flags, "persistence-policy");
+      let resolvedTemplateId = readOptionalStringFlag(context.flags, "template");
+      if (!resolvedTemplateId && context.isInteractiveSession) {
+        const templatePrompt = await context.getOrCreatePrompt();
+        resolvedTemplateId = await templatePrompt.select("Select a block template", context.addRuntime.ADD_BLOCK_TEMPLATE_IDS.map((templateId) => ({
+          hint: `Scaffold the ${templateId} block family`,
+          label: templateId,
+          value: templateId
+        })), 1);
+      }
+      resolvedTemplateId ??= "basic";
+      return {
+        execute: (cwd) => context.addRuntime.runAddBlockCommand({
+          alternateRenderTargets,
+          blockName: name,
+          cwd,
+          dataStorageMode,
+          externalLayerId,
+          externalLayerSource,
+          innerBlocksPreset,
+          persistencePolicy,
+          selectExternalLayerId: selectPrompt ? (options) => selectPrompt.select("Select an external layer", toExternalLayerPromptOptions(options), 1) : undefined,
+          templateId: resolvedTemplateId
+        }),
+        getValues: (result) => ({
+          blockSlugs: result.blockSlugs.join(", "),
+          templateId: result.templateId
+        }),
+        getWarnings: (result) => result.warnings,
+        warnLine: context.warnLine
+      };
+    },
+    sortOrder: 20,
+    supportsDryRun: true,
+    usage: "wp-typia add block <name> [--template <basic|interactivity|persistence|compound>] [--external-layer-source <./path|github:owner/repo/path[#ref]|npm-package>] [--external-layer-id <layer-id>] [--inner-blocks-preset <freeform|ordered|horizontal|locked-structure>] [--alternate-render-targets <email,mjml,plain-text>] [--data-storage <post-meta|custom-table>] [--persistence-policy <authenticated|public>] [--dry-run]",
     visibleFieldNames: ({ template }) => BLOCK_VISIBLE_FIELD_ORDER.filter((fieldName) => {
       if (fieldName === "alternate-render-targets") {
         return isAddPersistenceTemplate(template);
@@ -506,8 +783,8 @@ var ADD_KIND_REGISTRY = {
       }
       return true;
     })
-  },
-  ability: {
+  }),
+  ability: defineAddKindRegistryEntry({
     completion: {
       nextSteps: (values) => [
         `Review src/abilities/${values.abilitySlug}/ and inc/abilities/${values.abilitySlug}.php.`,
@@ -521,9 +798,24 @@ var ADD_KIND_REGISTRY = {
     },
     description: "Add a typed server/client workflow ability scaffold",
     nameLabel: "Ability name",
+    async prepareExecution(context) {
+      const name = requireAddKindName(context, "`wp-typia add ability` requires <name>. Usage: wp-typia add ability <name>.");
+      return {
+        execute: (cwd) => context.addRuntime.runAddAbilityCommand({
+          abilityName: name,
+          cwd
+        }),
+        getValues: (result) => ({
+          abilitySlug: result.abilitySlug
+        })
+      };
+    },
+    sortOrder: 90,
+    supportsDryRun: true,
+    usage: "wp-typia add ability <name> [--dry-run]",
     visibleFieldNames: () => ["kind", "name"]
-  },
-  "editor-plugin": {
+  }),
+  "editor-plugin": defineAddKindRegistryEntry({
     completion: {
       nextSteps: (values) => [
         `Review src/editor-plugins/${values.editorPluginSlug}/.`,
@@ -536,11 +828,29 @@ var ADD_KIND_REGISTRY = {
       ],
       title: "Added editor plugin"
     },
-    description: "Add a document-level editor extension shell",
+    description: "Add a slot-aware document editor extension shell",
     nameLabel: "Editor plugin name",
+    async prepareExecution(context) {
+      const name = requireAddKindName(context, "`wp-typia add editor-plugin` requires <name>. Usage: wp-typia add editor-plugin <name> [--slot <sidebar|document-setting-panel>].");
+      const slot = readOptionalStringFlag(context.flags, "slot");
+      return {
+        execute: (cwd) => context.addRuntime.runAddEditorPluginCommand({
+          cwd,
+          editorPluginName: name,
+          slot
+        }),
+        getValues: (result) => ({
+          editorPluginSlug: result.editorPluginSlug,
+          slot: result.slot
+        })
+      };
+    },
+    sortOrder: 120,
+    supportsDryRun: true,
+    usage: "wp-typia add editor-plugin <name> [--slot <sidebar|document-setting-panel>] [--dry-run]",
     visibleFieldNames: () => ["kind", "name", "slot"]
-  },
-  "hooked-block": {
+  }),
+  "hooked-block": defineAddKindRegistryEntry({
     completion: {
       nextSteps: (values) => [
         `Review src/blocks/${values.blockSlug}/block.json for the new blockHooks entry.`,
@@ -556,9 +866,36 @@ var ADD_KIND_REGISTRY = {
     },
     description: "Add block.json hook metadata to an existing block",
     nameLabel: "Target block",
+    async prepareExecution(context) {
+      const name = requireAddKindName(context, "`wp-typia add hooked-block` requires <block-slug>. Usage: wp-typia add hooked-block <block-slug> --anchor <anchor-block-name> --position <before|after|firstChild|lastChild>.");
+      const anchorBlockName = readOptionalStringFlag(context.flags, "anchor");
+      if (!anchorBlockName) {
+        throw createCliDiagnosticCodeError(CLI_DIAGNOSTIC_CODES.MISSING_ARGUMENT, "`wp-typia add hooked-block` requires --anchor <anchor-block-name>.");
+      }
+      const position = readOptionalStringFlag(context.flags, "position");
+      if (!position) {
+        throw createCliDiagnosticCodeError(CLI_DIAGNOSTIC_CODES.MISSING_ARGUMENT, "`wp-typia add hooked-block` requires --position <before|after|firstChild|lastChild>.");
+      }
+      return {
+        execute: (cwd) => context.addRuntime.runAddHookedBlockCommand({
+          anchorBlockName,
+          blockName: name,
+          cwd,
+          position
+        }),
+        getValues: (result) => ({
+          anchorBlockName: result.anchorBlockName,
+          blockSlug: result.blockSlug,
+          position: result.position
+        })
+      };
+    },
+    sortOrder: 110,
+    supportsDryRun: true,
+    usage: "wp-typia add hooked-block <block-slug> --anchor <anchor-block-name> --position <before|after|firstChild|lastChild> [--dry-run]",
     visibleFieldNames: () => ["kind", "name", "anchor", "position"]
-  },
-  pattern: {
+  }),
+  pattern: defineAddKindRegistryEntry({
     completion: {
       nextSteps: (values) => [
         `Review src/patterns/${values.patternSlug}.php.`,
@@ -572,9 +909,108 @@ var ADD_KIND_REGISTRY = {
     },
     description: "Add a PHP block pattern shell",
     nameLabel: "Pattern name",
+    async prepareExecution(context) {
+      const name = requireAddKindName(context, "`wp-typia add pattern` requires <name>. Usage: wp-typia add pattern <name>.");
+      return {
+        execute: (cwd) => context.addRuntime.runAddPatternCommand({
+          cwd,
+          patternName: name
+        }),
+        getValues: (result) => ({
+          patternSlug: result.patternSlug
+        })
+      };
+    },
+    sortOrder: 60,
+    supportsDryRun: true,
+    usage: "wp-typia add pattern <name> [--dry-run]",
     visibleFieldNames: () => ["kind", "name"]
-  },
-  "rest-resource": {
+  }),
+  style: defineAddKindRegistryEntry({
+    completion: {
+      nextSteps: (values) => [
+        `Review src/blocks/${values.blockSlug}/styles/${values.styleSlug}.ts.`,
+        "Run your workspace build or dev command to verify the new block style registration."
+      ],
+      summaryLines: (values, projectDir) => [
+        `Block style: ${values.styleSlug}`,
+        `Target block: ${values.blockSlug}`,
+        `Project directory: ${projectDir}`
+      ],
+      title: "Added block style"
+    },
+    description: "Add a Block Styles registration to an existing block",
+    nameLabel: "Style name",
+    async prepareExecution(context) {
+      const name = requireAddKindName(context, "`wp-typia add style` requires <name>. Usage: wp-typia add style <name> --block <block-slug>.");
+      const blockSlug = readOptionalStringFlag(context.flags, "block");
+      if (!blockSlug) {
+        throw createCliDiagnosticCodeError(CLI_DIAGNOSTIC_CODES.MISSING_ARGUMENT, "`wp-typia add style` requires --block <block-slug>.");
+      }
+      return {
+        execute: (cwd) => context.addRuntime.runAddBlockStyleCommand({
+          blockName: blockSlug,
+          cwd,
+          styleName: name
+        }),
+        getValues: (result) => ({
+          blockSlug: result.blockSlug,
+          styleSlug: result.styleSlug
+        })
+      };
+    },
+    sortOrder: 40,
+    supportsDryRun: true,
+    usage: "wp-typia add style <name> --block <block-slug> [--dry-run]",
+    visibleFieldNames: () => ["kind", "name", "block"]
+  }),
+  transform: defineAddKindRegistryEntry({
+    completion: {
+      nextSteps: (values) => [
+        `Review src/blocks/${values.blockSlug}/transforms/${values.transformSlug}.ts.`,
+        "Run your workspace build or dev command to verify the new block transform registration."
+      ],
+      summaryLines: (values, projectDir) => [
+        `Block transform: ${values.transformSlug}`,
+        `From: ${values.fromBlockName}`,
+        `To: ${values.toBlockName}`,
+        `Project directory: ${projectDir}`
+      ],
+      title: "Added block transform"
+    },
+    description: "Add a block-to-block transform into a workspace block",
+    nameLabel: "Transform name",
+    async prepareExecution(context) {
+      const name = requireAddKindName(context, "`wp-typia add transform` requires <name>. Usage: wp-typia add transform <name> --from <namespace/block> --to <block-slug|namespace/block-slug>.");
+      const fromBlockName = readOptionalStringFlag(context.flags, "from");
+      if (!fromBlockName) {
+        throw createCliDiagnosticCodeError(CLI_DIAGNOSTIC_CODES.MISSING_ARGUMENT, "`wp-typia add transform` requires --from <namespace/block>.");
+      }
+      const toBlockName = readOptionalStringFlag(context.flags, "to");
+      if (!toBlockName) {
+        throw createCliDiagnosticCodeError(CLI_DIAGNOSTIC_CODES.MISSING_ARGUMENT, "`wp-typia add transform` requires --to <block-slug|namespace/block-slug>.");
+      }
+      return {
+        execute: (cwd) => context.addRuntime.runAddBlockTransformCommand({
+          cwd,
+          fromBlockName,
+          toBlockName,
+          transformName: name
+        }),
+        getValues: (result) => ({
+          blockSlug: result.blockSlug,
+          fromBlockName: result.fromBlockName,
+          toBlockName: result.toBlockName,
+          transformSlug: result.transformSlug
+        })
+      };
+    },
+    sortOrder: 50,
+    supportsDryRun: true,
+    usage: "wp-typia add transform <name> --from <namespace/block> --to <block-slug|namespace/block-slug> [--dry-run]",
+    visibleFieldNames: () => ["kind", "name", "from", "to"]
+  }),
+  "rest-resource": defineAddKindRegistryEntry({
     completion: {
       nextSteps: (values) => [
         `Review src/rest/${values.restResourceSlug}/ and inc/rest/${values.restResourceSlug}.php.`,
@@ -590,9 +1026,30 @@ var ADD_KIND_REGISTRY = {
     },
     description: "Add a plugin-level typed REST resource",
     nameLabel: "REST resource name",
+    async prepareExecution(context) {
+      const name = requireAddKindName(context, "`wp-typia add rest-resource` requires <name>. Usage: wp-typia add rest-resource <name> [--namespace <vendor/v1>] [--methods <list,read,create>].");
+      const methods = readOptionalStringFlag(context.flags, "methods");
+      const namespace = readOptionalStringFlag(context.flags, "namespace");
+      return {
+        execute: (cwd) => context.addRuntime.runAddRestResourceCommand({
+          cwd,
+          methods,
+          namespace,
+          restResourceName: name
+        }),
+        getValues: (result) => ({
+          methods: result.methods.join(", "),
+          namespace: result.namespace,
+          restResourceSlug: result.restResourceSlug
+        })
+      };
+    },
+    sortOrder: 80,
+    supportsDryRun: true,
+    usage: "wp-typia add rest-resource <name> [--namespace <vendor/v1>] [--methods <list,read,create,update,delete>] [--dry-run]",
     visibleFieldNames: () => ["kind", "name", "namespace", "methods"]
-  },
-  "ai-feature": {
+  }),
+  "ai-feature": defineAddKindRegistryEntry({
     completion: {
       nextSteps: (values) => [
         `Review src/ai-features/${values.aiFeatureSlug}/ and inc/ai-features/${values.aiFeatureSlug}.php.`,
@@ -607,9 +1064,29 @@ var ADD_KIND_REGISTRY = {
     },
     description: "Add a server-owned WordPress AI feature endpoint",
     nameLabel: "AI feature name",
+    async prepareExecution(context) {
+      const name = requireAddKindName(context, "`wp-typia add ai-feature` requires <name>. Usage: wp-typia add ai-feature <name> [--namespace <vendor/v1>].");
+      const namespace = readOptionalStringFlag(context.flags, "namespace");
+      return {
+        execute: (cwd) => context.addRuntime.runAddAiFeatureCommand({
+          aiFeatureName: name,
+          cwd,
+          namespace
+        }),
+        getValues: (result) => ({
+          aiFeatureSlug: result.aiFeatureSlug,
+          namespace: result.namespace
+        }),
+        getWarnings: (result) => result.warnings,
+        warnLine: context.warnLine
+      };
+    },
+    sortOrder: 100,
+    supportsDryRun: true,
+    usage: "wp-typia add ai-feature <name> [--namespace <vendor/v1>] [--dry-run]",
     visibleFieldNames: () => ["kind", "name", "namespace"]
-  },
-  variation: {
+  }),
+  variation: defineAddKindRegistryEntry({
     completion: {
       nextSteps: (values) => [
         `Review src/blocks/${values.blockSlug}/variations/${values.variationSlug}.ts.`,
@@ -624,9 +1101,37 @@ var ADD_KIND_REGISTRY = {
     },
     description: "Add a variation to an existing block",
     nameLabel: "Variation name",
+    async prepareExecution(context) {
+      const name = requireAddKindName(context, "`wp-typia add variation` requires <name>. Usage: wp-typia add variation <name> --block <block-slug>");
+      const blockSlug = readOptionalStringFlag(context.flags, "block");
+      if (!blockSlug) {
+        throw createCliDiagnosticCodeError(CLI_DIAGNOSTIC_CODES.MISSING_ARGUMENT, "`wp-typia add variation` requires --block <block-slug>.");
+      }
+      return {
+        execute: (cwd) => context.addRuntime.runAddVariationCommand({
+          blockName: blockSlug,
+          cwd,
+          variationName: name
+        }),
+        getValues: (result) => ({
+          blockSlug: result.blockSlug,
+          variationSlug: result.variationSlug
+        })
+      };
+    },
+    sortOrder: 30,
+    supportsDryRun: true,
+    usage: "wp-typia add variation <name> --block <block-slug> [--dry-run]",
     visibleFieldNames: () => ["kind", "name", "block"]
-  }
+  })
 };
+var ADD_KIND_IDS = Object.keys(ADD_KIND_REGISTRY).sort((left, right) => ADD_KIND_REGISTRY[left].sortOrder - ADD_KIND_REGISTRY[right].sortOrder);
+function isAddKindId(value) {
+  return typeof value === "string" && ADD_KIND_IDS.includes(value);
+}
+async function getAddKindExecutionPlan(kind, context) {
+  return ADD_KIND_REGISTRY[kind].prepareExecution(context);
+}
 function buildAddKindCompletionDetails(kind, options) {
   const descriptor = ADD_KIND_REGISTRY[kind].completion;
   return {
@@ -641,12 +1146,19 @@ function formatAddKindList() {
 function formatAddKindUsagePlaceholder() {
   return `<${ADD_KIND_IDS.join("|")}>`;
 }
+function supportsAddKindDryRun(kind) {
+  return ADD_KIND_REGISTRY[kind].supportsDryRun;
+}
 
 // src/config.ts
 import fs from "node:fs/promises";
 import os from "node:os";
 import path from "node:path";
 import { isPlainObject as isRecord } from "@wp-typia/api-client/runtime-primitives";
+import {
+  CLI_DIAGNOSTIC_CODES as CLI_DIAGNOSTIC_CODES2,
+  createCliDiagnosticCodeError as createCliDiagnosticCodeError2
+} from "@wp-typia/project-tools/cli-diagnostics";
 var WP_TYPIA_CONFIG_SOURCES = [
   "~/.config/wp-typia/config.json",
   ".wp-typiarc",
@@ -668,16 +1180,22 @@ function deepMerge(base, incoming) {
   return merged;
 }
 async function readJsonFile(filePath) {
+  let source;
   try {
-    const source = await fs.readFile(filePath, "utf8");
-    const parsed = JSON.parse(source);
-    return isRecord(parsed) ? parsed : null;
+    source = await fs.readFile(filePath, "utf8");
   } catch (error) {
     if (typeof error === "object" && error !== null && "code" in error && error.code === "ENOENT") {
       return null;
     }
     throw error;
   }
+  try {
+    const parsed = JSON.parse(source);
+    return isRecord(parsed) ? parsed : null;
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    throw createCliDiagnosticCodeError2(CLI_DIAGNOSTIC_CODES2.INVALID_ARGUMENT, `Unable to parse ${filePath}: ${message}`, error instanceof Error ? { cause: error } : undefined);
+  }
 }
 function resolveConfigPath(cwd, source) {
   if (source.startsWith("~/")) {
@@ -715,43 +1233,24 @@ function getAddBlockDefaults(config) {
 }
 
 // src/config-override.ts
+var GLOBAL_OPTION_PARSER = buildCommandOptionParser(GLOBAL_OPTION_METADATA);
 function extractWpTypiaConfigOverride(argv) {
-  const nextArgv = [];
-  let configOverridePath;
-  for (let index = 0;index < argv.length; index += 1) {
-    const arg = argv[index];
-    if (!arg) {
-      continue;
-    }
-    if (arg === "--") {
-      nextArgv.push(...argv.slice(index));
-      break;
-    }
-    if (arg === "--config" || arg === "-c") {
-      const next = argv[index + 1];
-      if (!next || next.startsWith("-")) {
-        throw new Error(`\`${arg}\` requires a value.`);
-      }
-      configOverridePath = next;
-      index += 1;
-      continue;
-    }
-    if (arg.startsWith("--config=")) {
-      const inlineValue = arg.slice("--config=".length);
-      if (!inlineValue) {
-        throw new Error("`--config` requires a value.");
-      }
-      configOverridePath = inlineValue;
-      continue;
-    }
-    nextArgv.push(arg);
-  }
+  const { argv: nextArgv, flags } = extractKnownOptionValuesFromArgv(argv, {
+    optionNames: ["config"],
+    parser: GLOBAL_OPTION_PARSER
+  });
   return {
     argv: nextArgv,
-    configOverridePath
+    configOverridePath: typeof flags.config === "string" ? flags.config : undefined
   };
 }
 
+// src/runtime-bridge.ts
+import {
+  CLI_DIAGNOSTIC_CODES as CLI_DIAGNOSTIC_CODES4,
+  createCliDiagnosticCodeError as createCliDiagnosticCodeError4
+} from "@wp-typia/project-tools/cli-diagnostics";
+
 // src/runtime-bridge-add-dry-run.ts
 import fs2 from "node:fs";
 import { promises as fsp } from "node:fs";
@@ -916,6 +1415,9 @@ function readAsciiPreferenceFromEnv(env) {
   }
   return;
 }
+function hasNoColorPreference(env) {
+  return typeof env.NO_COLOR === "string" && env.NO_COLOR.length > 0;
+}
 function prefersAsciiOutput(options = {}) {
   if (options.forceAscii) {
     return true;
@@ -925,6 +1427,9 @@ function prefersAsciiOutput(options = {}) {
   if (envPreference !== undefined) {
     return envPreference;
   }
+  if (hasNoColorPreference(env)) {
+    return true;
+  }
   const term = options.term ?? env.TERM;
   if (term === "dumb") {
     return true;
@@ -990,6 +1495,77 @@ ${payload.optionalTitle ?? "Optional:"}`);
     printLine(`Note: ${payload.optionalNote}`);
   }
 }
+function toNonEmptyArray(values) {
+  return values && values.length > 0 ? values : undefined;
+}
+function extractPlannedFiles(payload) {
+  const files = payload.optionalLines?.map((line) => line.match(/^(?:delete|update|write)\s+(.+)$/u)?.[1]).filter((value) => typeof value === "string" && value.length > 0);
+  return toNonEmptyArray(files);
+}
+var PROJECT_DIRECTORY_SUMMARY_PREFIX = "Project directory: ";
+function extractCompletionProjectDir(completion) {
+  const projectDir = completion?.summaryLines?.find((line) => line.startsWith(PROJECT_DIRECTORY_SUMMARY_PREFIX))?.slice(PROJECT_DIRECTORY_SUMMARY_PREFIX.length).trim();
+  return projectDir && projectDir.length > 0 ? projectDir : undefined;
+}
+function serializeCompletionPayload(payload) {
+  return {
+    nextSteps: toNonEmptyArray(payload.nextSteps),
+    optionalLines: toNonEmptyArray(payload.optionalLines),
+    optionalNote: payload.optionalNote,
+    optionalTitle: payload.optionalTitle,
+    preambleLines: toNonEmptyArray(payload.preambleLines),
+    summaryLines: toNonEmptyArray(payload.summaryLines),
+    title: stripLeadingOutputMarker(payload.title),
+    warningLines: toNonEmptyArray(payload.warningLines)
+  };
+}
+function buildStructuredCompletionSuccessPayload(command, completion, metadata = {}) {
+  const serializedCompletion = completion ? serializeCompletionPayload(completion) : undefined;
+  return {
+    ok: true,
+    data: {
+      ...metadata,
+      command,
+      ...serializedCompletion ? {
+        completion: serializedCompletion,
+        files: extractPlannedFiles(serializedCompletion),
+        nextSteps: serializedCompletion.nextSteps,
+        optionalLines: serializedCompletion.optionalLines,
+        optionalNote: serializedCompletion.optionalNote,
+        optionalTitle: serializedCompletion.optionalTitle,
+        preambleLines: serializedCompletion.preambleLines,
+        summaryLines: serializedCompletion.summaryLines,
+        title: serializedCompletion.title,
+        warnings: serializedCompletion.warningLines
+      } : {}
+    }
+  };
+}
+function buildStructuredInitSuccessPayload(plan) {
+  const completion = serializeCompletionPayload(buildInitCompletionPayload(plan));
+  const files = Array.from(new Set([
+    ...plan.plannedFiles.map((filePlan) => filePlan.path),
+    ...plan.commandMode === "preview-only" ? plan.generatedArtifacts : []
+  ]));
+  return {
+    ok: true,
+    data: {
+      command: "init",
+      completion,
+      detectedLayout: plan.detectedLayout,
+      files: toNonEmptyArray(files),
+      mode: plan.commandMode === "apply" ? "apply" : "preview",
+      nextSteps: toNonEmptyArray(plan.nextSteps),
+      packageManager: plan.packageManager,
+      plan,
+      projectDir: plan.projectDir,
+      status: plan.status,
+      summary: plan.summary,
+      title: completion.title,
+      warnings: toNonEmptyArray(plan.notes)
+    }
+  };
+}
 function formatCreateProgressLine(payload, markerOptions) {
   return formatOutputMarker("progress", `${payload.title}: ${payload.detail}`, markerOptions);
 }
@@ -1035,28 +1611,31 @@ function buildCreateDryRunPayload(flow, markerOptions) {
   };
 }
 function buildInitCompletionPayload(plan, markerOptions) {
-  const plannedChanges = [
+  const changeLines = [
     ...plan.packageChanges.addDevDependencies.map((dependency) => `devDependency ${dependency.action} ${dependency.name} -> ${dependency.requiredValue}`),
     ...plan.packageChanges.packageManagerField ? [
       `packageManager ${plan.packageChanges.packageManagerField.action} -> ${plan.packageChanges.packageManagerField.requiredValue}`
     ] : [],
     ...plan.packageChanges.scripts.map((script) => `script ${script.action} ${script.name} -> ${script.requiredValue}`),
-    ...plan.plannedFiles.map((filePlan) => `file add ${filePlan.path} (${filePlan.purpose})`),
-    ...plan.generatedArtifacts.map((artifactPath) => `generated artifact ${artifactPath}`)
+    ...plan.plannedFiles.map((filePlan) => `file ${filePlan.action} ${filePlan.path} (${filePlan.purpose})`),
+    ...plan.commandMode === "preview-only" ? plan.generatedArtifacts.map((artifactPath) => `generated artifact ${artifactPath}`) : []
   ];
+  const modeLine = plan.commandMode === "apply" ? plan.status === "already-initialized" ? "Mode: apply requested; no files were written because the retrofit surface already existed." : "Mode: apply; package.json and retrofit helper files were written." : "Mode: preview only; no files were written.";
+  const optionalTitle = plan.commandMode === "apply" ? `Applied adoption changes (${changeLines.length}):` : `Planned adoption changes (${changeLines.length}):`;
+  const title = plan.status === "already-initialized" ? formatOutputMarker("success", `wp-typia init: ${plan.projectName} is already initialized`, markerOptions) : plan.commandMode === "apply" ? formatOutputMarker("success", `Applied retrofit init for ${plan.projectName}`, markerOptions) : formatOutputMarker("dryRun", `Retrofit init plan for ${plan.projectName}`, markerOptions);
   return {
     nextSteps: plan.nextSteps,
-    optionalLines: plannedChanges,
+    optionalLines: changeLines,
     optionalNote: plan.summary,
-    optionalTitle: `Planned adoption changes (${plannedChanges.length}):`,
+    optionalTitle,
     summaryLines: [
       `Project directory: ${plan.projectDir}`,
       `Detected layout: ${plan.detectedLayout.description}`,
       ...plan.detectedLayout.blockNames.length > 0 ? [`Block targets: ${plan.detectedLayout.blockNames.join(", ")}`] : [],
       `Package manager: ${plan.packageManager}`,
-      "Mode: preview only; no files were written."
+      modeLine
     ],
-    title: plan.status === "already-initialized" ? formatOutputMarker("success", `wp-typia init: ${plan.projectName} is already initialized`, markerOptions) : formatOutputMarker("dryRun", `Retrofit init plan for ${plan.projectName}`, markerOptions),
+    title,
     warningLines: plan.notes
   };
 }
@@ -1145,16 +1724,16 @@ function printBlock(lines, printLine) {
     printLine(line);
   }
 }
-function formatExternalLayerSelectHint(option) {
+function formatExternalLayerSelectHint2(option) {
   const details = [
     option.description,
     option.extends.length > 0 ? `extends ${option.extends.join(", ")}` : undefined
   ].filter((value) => typeof value === "string" && value.length > 0);
   return details.length > 0 ? details.join(" · ") : undefined;
 }
-function toExternalLayerPromptOptions(options) {
+function toExternalLayerPromptOptions2(options) {
   return options.map((option) => ({
-    hint: formatExternalLayerSelectHint(option),
+    hint: formatExternalLayerSelectHint2(option),
     label: option.id,
     value: option.id
   }));
@@ -1172,6 +1751,10 @@ function isInteractiveTerminal({
 import { spawnSync } from "node:child_process";
 import fs4 from "node:fs";
 import path4 from "node:path";
+import {
+  CLI_DIAGNOSTIC_CODES as CLI_DIAGNOSTIC_CODES3,
+  createCliDiagnosticCodeError as createCliDiagnosticCodeError3
+} from "@wp-typia/project-tools/cli-diagnostics";
 var SYNC_INSTALL_MARKERS = [
   "node_modules",
   ".pnp.cjs",
@@ -1186,7 +1769,7 @@ function resolveSyncExecutionTarget(subcommand) {
   if (subcommand === "ai") {
     return "ai";
   }
-  throw new Error(`Unknown sync subcommand "${subcommand}". Expected one of: "ai".`);
+  throw createCliDiagnosticCodeError3(CLI_DIAGNOSTIC_CODES3.INVALID_COMMAND, `Unknown sync subcommand "${subcommand}". Expected one of: "ai".`);
 }
 function formatRunScript(packageManagerId, scriptName, extraArgs = "") {
   const args = extraArgs.trim();
@@ -1214,7 +1797,7 @@ function formatInstallCommand(packageManagerId) {
   }
 }
 function getSyncRootError(cwd) {
-  return new Error(`No generated wp-typia project root was found at ${cwd}. Run \`wp-typia sync\` from a scaffolded project or official workspace root that already contains generated sync scripts. If you expected this directory to work, cd into the scaffold root first or rerun the scaffold before syncing.`);
+  return createCliDiagnosticCodeError3(CLI_DIAGNOSTIC_CODES3.OUTSIDE_PROJECT_ROOT, `No generated wp-typia project root was found at ${cwd}. Run \`wp-typia sync\` from a scaffolded project or official workspace root that already contains generated sync scripts. If you expected this directory to work, cd into the scaffold root first or rerun the scaffold before syncing.`);
 }
 function inferSyncPackageManager(cwd, packageManagerField) {
   const field = String(packageManagerField ?? "");
@@ -1304,7 +1887,7 @@ function assertSyncDependenciesInstalled(project, target) {
   if (markerDir) {
     return;
   }
-  throw new Error(`Project dependencies have not been installed yet. Run \`${formatInstallCommand(project.packageManager)}\` from the project root before \`wp-typia sync\`. The generated sync scripts rely on local tools such as \`tsx\`.`);
+  throw createCliDiagnosticCodeError3(CLI_DIAGNOSTIC_CODES3.DEPENDENCIES_NOT_INSTALLED, `Project dependencies have not been installed yet. Run \`${formatInstallCommand(project.packageManager)}\` from the project root before \`wp-typia sync\`. The generated sync scripts rely on local tools such as \`tsx\`.`);
 }
 function getPackageManagerRunInvocation(packageManager, scriptName, extraArgs) {
   switch (packageManager) {
@@ -1342,7 +1925,7 @@ function buildSyncPlannedCommands(project, extraArgs, target) {
   if (target === "ai") {
     const syncAiCommand2 = createSyncPlannedCommand(project, "sync-ai", extraArgs);
     if (!syncAiCommand2) {
-      throw new Error(`Expected ${project.packageJsonPath} to define a \`sync-ai\` script for \`wp-typia sync ai\`.`);
+      throw createCliDiagnosticCodeError3(CLI_DIAGNOSTIC_CODES3.CONFIGURATION_MISSING, `Expected ${project.packageJsonPath} to define a \`sync-ai\` script for \`wp-typia sync ai\`.`);
     }
     return [syncAiCommand2];
   }
@@ -1351,7 +1934,7 @@ function buildSyncPlannedCommands(project, extraArgs, target) {
   }
   const syncTypesCommand = createSyncPlannedCommand(project, "sync-types", extraArgs);
   if (!syncTypesCommand) {
-    throw new Error(`Expected ${project.packageJsonPath} to define either a \`sync\` or \`sync-types\` script.`);
+    throw createCliDiagnosticCodeError3(CLI_DIAGNOSTIC_CODES3.CONFIGURATION_MISSING, `Expected ${project.packageJsonPath} to define either a \`sync\` or \`sync-types\` script.`);
   }
   const plannedCommands = [syncTypesCommand];
   const syncRestCommand = createSyncPlannedCommand(project, "sync-rest", extraArgs);
@@ -1437,23 +2020,13 @@ function shouldWrapCliCommandError(options) {
   }
   return true;
 }
-function readOptionalStringFlag(flags, name) {
-  const value = flags[name];
-  if (value === undefined || value === null) {
-    return;
-  }
-  if (typeof value !== "string" || value.trim().length === 0) {
-    throw new Error(`\`--${name}\` requires a value.`);
-  }
-  return value;
-}
 function readOptionalLooseStringFlag(flags, name) {
   const value = flags[name];
   if (value === undefined || value === null) {
     return;
   }
   if (typeof value !== "string") {
-    throw new Error(`\`--${name}\` requires a value.`);
+    throw createCliDiagnosticCodeError4(CLI_DIAGNOSTIC_CODES4.MISSING_ARGUMENT, `\`--${name}\` requires a value.`);
   }
   const trimmed = value.trim();
   return trimmed.length > 0 ? trimmed : undefined;
@@ -1468,223 +2041,6 @@ function pushFlag(argv, name, value) {
   }
   argv.push(`--${name}`, String(value));
 }
-function requireAddKindName(context, message) {
-  if (!context.name) {
-    throw new Error(message);
-  }
-  return context.name;
-}
-function runRegisteredAddKind(context, plan) {
-  return executeWorkspaceAddWithOptionalDryRun({
-    buildCompletion: plan.buildCompletion,
-    cwd: context.cwd,
-    dryRun: context.dryRun,
-    emitOutput: context.emitOutput,
-    execute: plan.execute,
-    printLine: context.printLine,
-    warnLine: plan.warnLine
-  });
-}
-var ADD_KIND_EXECUTION_REGISTRY = {
-  ability: async (context) => {
-    const name = requireAddKindName(context, "`wp-typia add ability` requires <name>. Usage: wp-typia add ability <name>.");
-    return runRegisteredAddKind(context, {
-      buildCompletion: (result) => buildAddCompletionPayload({
-        kind: "ability",
-        projectDir: result.projectDir,
-        values: {
-          abilitySlug: result.abilitySlug
-        }
-      }),
-      execute: (targetCwd) => context.addRuntime.runAddAbilityCommand({
-        abilityName: name,
-        cwd: targetCwd
-      })
-    });
-  },
-  "binding-source": async (context) => {
-    const name = requireAddKindName(context, "`wp-typia add binding-source` requires <name>. Usage: wp-typia add binding-source <name>.");
-    return runRegisteredAddKind(context, {
-      buildCompletion: (result) => buildAddCompletionPayload({
-        kind: "binding-source",
-        projectDir: result.projectDir,
-        values: {
-          bindingSourceSlug: result.bindingSourceSlug
-        }
-      }),
-      execute: (targetCwd) => context.addRuntime.runAddBindingSourceCommand({
-        bindingSourceName: name,
-        cwd: targetCwd
-      })
-    });
-  },
-  block: async (context) => {
-    const name = requireAddKindName(context, "`wp-typia add block` requires <name>. Usage: wp-typia add block <name> [--template <basic|interactivity|persistence|compound>]");
-    if (!context.flags.template && context.isInteractiveSession) {
-      throw new Error("`wp-typia add block` requires --template <basic|interactivity|persistence|compound> in interactive terminals. Non-interactive runs default to --template basic.");
-    }
-    const externalLayerId = readOptionalStringFlag(context.flags, "external-layer-id");
-    const externalLayerSource = readOptionalStringFlag(context.flags, "external-layer-source");
-    const shouldPromptForLayerSelection = Boolean(externalLayerSource) && !Boolean(externalLayerId) && context.isInteractiveSession;
-    const selectPrompt = shouldPromptForLayerSelection ? await context.getOrCreatePrompt() : undefined;
-    const alternateRenderTargets = readOptionalStringFlag(context.flags, "alternate-render-targets");
-    const dataStorageMode = readOptionalStringFlag(context.flags, "data-storage");
-    const innerBlocksPreset = readOptionalStringFlag(context.flags, "inner-blocks-preset");
-    const persistencePolicy = readOptionalStringFlag(context.flags, "persistence-policy");
-    const resolvedTemplateId = readOptionalStringFlag(context.flags, "template") ?? "basic";
-    return runRegisteredAddKind(context, {
-      buildCompletion: (result) => buildAddCompletionPayload({
-        kind: "block",
-        projectDir: result.projectDir,
-        values: {
-          blockSlugs: result.blockSlugs.join(", "),
-          templateId: result.templateId
-        },
-        warnings: result.warnings
-      }),
-      execute: (targetCwd) => context.addRuntime.runAddBlockCommand({
-        alternateRenderTargets,
-        blockName: name,
-        cwd: targetCwd,
-        dataStorageMode,
-        externalLayerId,
-        externalLayerSource,
-        innerBlocksPreset,
-        persistencePolicy,
-        selectExternalLayerId: selectPrompt ? (options) => selectPrompt.select("Select an external layer", toExternalLayerPromptOptions(options), 1) : undefined,
-        templateId: resolvedTemplateId
-      }),
-      warnLine: context.warnLine
-    });
-  },
-  "editor-plugin": async (context) => {
-    const name = requireAddKindName(context, "`wp-typia add editor-plugin` requires <name>. Usage: wp-typia add editor-plugin <name> [--slot <PluginSidebar>].");
-    const slot = readOptionalStringFlag(context.flags, "slot");
-    return runRegisteredAddKind(context, {
-      buildCompletion: (result) => buildAddCompletionPayload({
-        kind: "editor-plugin",
-        projectDir: result.projectDir,
-        values: {
-          editorPluginSlug: result.editorPluginSlug,
-          slot: result.slot
-        }
-      }),
-      execute: (targetCwd) => context.addRuntime.runAddEditorPluginCommand({
-        cwd: targetCwd,
-        editorPluginName: name,
-        slot
-      })
-    });
-  },
-  "ai-feature": async (context) => {
-    const name = requireAddKindName(context, "`wp-typia add ai-feature` requires <name>. Usage: wp-typia add ai-feature <name> [--namespace <vendor/v1>].");
-    const namespace = readOptionalStringFlag(context.flags, "namespace");
-    return runRegisteredAddKind(context, {
-      buildCompletion: (result) => buildAddCompletionPayload({
-        kind: "ai-feature",
-        projectDir: result.projectDir,
-        values: {
-          aiFeatureSlug: result.aiFeatureSlug,
-          namespace: result.namespace
-        },
-        warnings: result.warnings
-      }),
-      execute: (targetCwd) => context.addRuntime.runAddAiFeatureCommand({
-        aiFeatureName: name,
-        cwd: targetCwd,
-        namespace
-      })
-    });
-  },
-  "hooked-block": async (context) => {
-    const name = requireAddKindName(context, "`wp-typia add hooked-block` requires <block-slug>. Usage: wp-typia add hooked-block <block-slug> --anchor <anchor-block-name> --position <before|after|firstChild|lastChild>.");
-    const anchorBlockName = readOptionalStringFlag(context.flags, "anchor");
-    if (!anchorBlockName) {
-      throw new Error("`wp-typia add hooked-block` requires --anchor <anchor-block-name>.");
-    }
-    const position = readOptionalStringFlag(context.flags, "position");
-    if (!position) {
-      throw new Error("`wp-typia add hooked-block` requires --position <before|after|firstChild|lastChild>.");
-    }
-    return runRegisteredAddKind(context, {
-      buildCompletion: (result) => buildAddCompletionPayload({
-        kind: "hooked-block",
-        projectDir: result.projectDir,
-        values: {
-          anchorBlockName: result.anchorBlockName,
-          blockSlug: result.blockSlug,
-          position: result.position
-        }
-      }),
-      execute: (targetCwd) => context.addRuntime.runAddHookedBlockCommand({
-        anchorBlockName,
-        blockName: name,
-        cwd: targetCwd,
-        position
-      })
-    });
-  },
-  pattern: async (context) => {
-    const name = requireAddKindName(context, "`wp-typia add pattern` requires <name>. Usage: wp-typia add pattern <name>.");
-    return runRegisteredAddKind(context, {
-      buildCompletion: (result) => buildAddCompletionPayload({
-        kind: "pattern",
-        projectDir: result.projectDir,
-        values: {
-          patternSlug: result.patternSlug
-        }
-      }),
-      execute: (targetCwd) => context.addRuntime.runAddPatternCommand({
-        cwd: targetCwd,
-        patternName: name
-      })
-    });
-  },
-  "rest-resource": async (context) => {
-    const name = requireAddKindName(context, "`wp-typia add rest-resource` requires <name>. Usage: wp-typia add rest-resource <name> [--namespace <vendor/v1>] [--methods <list,read,create>].");
-    const methods = readOptionalStringFlag(context.flags, "methods");
-    const namespace = readOptionalStringFlag(context.flags, "namespace");
-    return runRegisteredAddKind(context, {
-      buildCompletion: (result) => buildAddCompletionPayload({
-        kind: "rest-resource",
-        projectDir: result.projectDir,
-        values: {
-          methods: result.methods.join(", "),
-          namespace: result.namespace,
-          restResourceSlug: result.restResourceSlug
-        }
-      }),
-      execute: (targetCwd) => context.addRuntime.runAddRestResourceCommand({
-        cwd: targetCwd,
-        methods,
-        namespace,
-        restResourceName: name
-      })
-    });
-  },
-  variation: async (context) => {
-    const name = requireAddKindName(context, "`wp-typia add variation` requires <name>. Usage: wp-typia add variation <name> --block <block-slug>");
-    const blockSlug = readOptionalStringFlag(context.flags, "block");
-    if (!blockSlug) {
-      throw new Error("`wp-typia add variation` requires --block <block-slug>.");
-    }
-    return runRegisteredAddKind(context, {
-      buildCompletion: (result) => buildAddCompletionPayload({
-        kind: "variation",
-        projectDir: result.projectDir,
-        values: {
-          blockSlug: result.blockSlug,
-          variationSlug: result.variationSlug
-        }
-      }),
-      execute: (targetCwd) => context.addRuntime.runAddVariationCommand({
-        blockName: blockSlug,
-        cwd: targetCwd,
-        variationName: name
-      })
-    });
-  }
-};
 async function executeWorkspaceAddWithOptionalDryRun(options) {
   const simulated = options.dryRun ? await simulateWorkspaceAddDryRun({
     cwd: options.cwd,
@@ -1708,6 +2064,26 @@ async function executeWorkspaceAddWithOptionalDryRun(options) {
     warnLine: options.warnLine
   });
 }
+function executePreparedAddKind(kind, context, plan) {
+  return executeWorkspaceAddWithOptionalDryRun({
+    buildCompletion: (result) => buildAddCompletionPayload({
+      kind,
+      projectDir: result.projectDir,
+      values: plan.getValues(result),
+      warnings: plan.getWarnings?.(result)
+    }),
+    cwd: context.cwd,
+    dryRun: context.dryRun,
+    emitOutput: context.emitOutput,
+    execute: plan.execute,
+    printLine: context.printLine,
+    warnLine: plan.warnLine
+  });
+}
+async function executePlannedAddKind(kind, executionContext, context) {
+  const plan = await getAddKindExecutionPlan(kind, executionContext);
+  return executePreparedAddKind(kind, context, plan);
+}
 var PACKAGE_MANAGER_PROMPT_OPTIONS = [
   { label: "npm", value: "npm", hint: "Use npm" },
   { label: "pnpm", value: "pnpm", hint: "Use pnpm" },
@@ -1796,7 +2172,7 @@ async function executeCreateCommand({
       promptText: activePrompt ? (message, defaultValue, validate) => activePrompt.text(message, defaultValue, validate) : undefined,
       queryPostType: readOptionalLooseStringFlag(flags, "query-post-type"),
       selectDataStorage: activePrompt ? () => activePrompt.select("Select a data storage mode", [...DATA_STORAGE_PROMPT_OPTIONS], 1) : undefined,
-      selectExternalLayerId: shouldPromptForExternalLayerSelection && activePrompt ? (options) => activePrompt.select("Select an external layer", toExternalLayerPromptOptions(options), 1) : undefined,
+      selectExternalLayerId: shouldPromptForExternalLayerSelection && activePrompt ? (options) => activePrompt.select("Select an external layer", toExternalLayerPromptOptions2(options), 1) : undefined,
       selectPackageManager: activePrompt ? () => activePrompt.select("Select a package manager", [...PACKAGE_MANAGER_PROMPT_OPTIONS], 1) : undefined,
       selectPersistencePolicy: activePrompt ? () => activePrompt.select("Select a persistence policy", [...PERSISTENCE_POLICY_PROMPT_OPTIONS], 1) : undefined,
       selectTemplate: activePrompt ? () => activePrompt.select("Select a template", getTemplateSelectOptions(), 1) : undefined,
@@ -1849,16 +2225,17 @@ async function executeAddCommand({
       if (emitOutput) {
         printLine(addRuntime.formatAddHelpText());
       }
-      throw new Error(`\`wp-typia add\` requires <kind>. Usage: wp-typia add ${formatAddKindUsagePlaceholder()} ...`);
+      throw createCliDiagnosticCodeError4(CLI_DIAGNOSTIC_CODES4.MISSING_ARGUMENT, `\`wp-typia add\` requires <kind>. Usage: wp-typia add ${formatAddKindUsagePlaceholder()} ...`);
     }
     if (!isAddKindId(kind)) {
-      throw new Error(`Unknown add kind "${kind}". Expected one of: ${formatAddKindList()}.`);
+      throw createCliDiagnosticCodeError4(CLI_DIAGNOSTIC_CODES4.INVALID_COMMAND, `Unknown add kind "${kind}". Expected one of: ${formatAddKindList()}.`);
+    }
+    if (dryRun && !supportsAddKindDryRun(kind)) {
+      throw createCliDiagnosticCodeError4(CLI_DIAGNOSTIC_CODES4.INVALID_ARGUMENT, `\`wp-typia add ${kind}\` does not support \`--dry-run\` yet.`);
     }
-    return await ADD_KIND_EXECUTION_REGISTRY[kind]({
+    const executionContext = {
       addRuntime,
       cwd,
-      dryRun,
-      emitOutput,
       flags,
       getOrCreatePrompt: async () => {
         if (activePrompt) {
@@ -1870,8 +2247,13 @@ async function executeAddCommand({
       },
       isInteractiveSession,
       name,
-      printLine,
       warnLine
+    };
+    return await executePlannedAddKind(kind, executionContext, {
+      cwd,
+      dryRun,
+      emitOutput,
+      printLine
     });
   } catch (error) {
     if (!shouldWrapCliCommandError({ emitOutput })) {
@@ -1901,22 +2283,26 @@ async function executeTemplatesCommand({ flags }, printLine = console.log) {
   }
   if (subcommand === "inspect") {
     if (!flags.id) {
-      throw new Error("`wp-typia templates inspect` requires <template-id>.");
+      throw createCliDiagnosticCodeError4(CLI_DIAGNOSTIC_CODES4.MISSING_ARGUMENT, "`wp-typia templates inspect` requires <template-id>.");
     }
     const template = getTemplateById(flags.id);
     if (!template) {
-      throw new Error(`Unknown template "${flags.id}".`);
+      throw createCliDiagnosticCodeError4(CLI_DIAGNOSTIC_CODES4.INVALID_ARGUMENT, `Unknown template "${flags.id}".`);
     }
     printBlock([formatTemplateDetails(template)], printLine);
     return;
   }
-  throw new Error(`Unknown templates subcommand "${subcommand}". Expected list or inspect.`);
+  throw createCliDiagnosticCodeError4(CLI_DIAGNOSTIC_CODES4.INVALID_COMMAND, `Unknown templates subcommand "${subcommand}". Expected list or inspect.`);
 }
-async function executeInitCommand({ cwd, projectDir }, options = {}) {
+async function executeInitCommand({ apply, cwd, packageManager, projectDir }, options = {}) {
   try {
-    const { getInitPlan } = await loadCliInitRuntime();
+    const { runInitCommand } = await loadCliInitRuntime();
     const resolvedProjectDir = projectDir ? (await import("node:path")).resolve(cwd, projectDir) : cwd;
-    const plan = getInitPlan(resolvedProjectDir);
+    const plan = await runInitCommand({
+      apply,
+      packageManager,
+      projectDir: resolvedProjectDir
+    });
     const completion = buildInitCompletionPayload(plan);
     if (options.emitOutput ?? true) {
       printCompletionPayload(completion, {
@@ -1926,6 +2312,9 @@ async function executeInitCommand({ cwd, projectDir }, options = {}) {
     }
     return plan;
   } catch (error) {
+    if (!shouldWrapCliCommandError({ emitOutput: options.emitOutput })) {
+      throw error;
+    }
     throw await wrapCliCommandError("init", error);
   }
 }
@@ -1992,57 +2381,14 @@ async function executeMigrateCommand({
 
 // src/command-contract.ts
 import path5 from "node:path";
-var WP_TYPIA_CANONICAL_CREATE_USAGE = "wp-typia create <project-dir>";
-var WP_TYPIA_POSITIONAL_ALIAS_USAGE = "wp-typia <project-dir>";
-var WP_TYPIA_CANONICAL_MIGRATE_USAGE = "wp-typia migrate <subcommand>";
-var WP_TYPIA_RESERVED_TOP_LEVEL_COMMAND_NAMES = [
-  "create",
-  "init",
-  "sync",
-  "add",
-  "migrate",
-  "templates",
-  "doctor",
-  "mcp",
-  "help",
-  "version",
-  "skills",
-  "completions",
-  "complete"
-];
-var WP_TYPIA_NODE_FALLBACK_TOP_LEVEL_COMMAND_NAMES = [
-  "create",
-  "init",
-  "sync",
-  "add",
-  "migrate",
-  "templates",
-  "doctor",
-  "help",
-  "version"
-];
-var NODE_FALLBACK_TOP_LEVEL_COMMAND_NAME_SET = new Set(WP_TYPIA_NODE_FALLBACK_TOP_LEVEL_COMMAND_NAMES);
-var WP_TYPIA_BUN_REQUIRED_TOP_LEVEL_COMMAND_NAMES = WP_TYPIA_RESERVED_TOP_LEVEL_COMMAND_NAMES.filter((name) => !NODE_FALLBACK_TOP_LEVEL_COMMAND_NAME_SET.has(name));
-var SHARED_OPTION_PARSER = buildCommandOptionParser(ADD_OPTION_METADATA, GLOBAL_OPTION_METADATA, CREATE_OPTION_METADATA, MIGRATE_OPTION_METADATA, TEMPLATES_OPTION_METADATA);
-var STRING_OPTION_NAMES_BY_COMMAND = {
-  add: new Set(collectOptionNamesByType(ADD_OPTION_METADATA, "string")),
-  create: new Set(collectOptionNamesByType(CREATE_OPTION_METADATA, "string")),
-  migrate: new Set(collectOptionNamesByType(MIGRATE_OPTION_METADATA, "string")),
-  templates: new Set(collectOptionNamesByType(TEMPLATES_OPTION_METADATA, "string"))
-};
-var GLOBAL_STRING_OPTION_NAMES = new Set(collectOptionNamesByType(GLOBAL_OPTION_METADATA, "string"));
-var SHORT_OPTION_NAMES_WITH_VALUES = new Set([...SHARED_OPTION_PARSER.shortFlagMap.entries()].filter(([, option]) => option.type === "string").map(([short]) => short));
-function isLongOptionValueConsumer(optionName) {
-  if (GLOBAL_STRING_OPTION_NAMES.has(optionName)) {
-    return true;
-  }
-  return Object.values(STRING_OPTION_NAMES_BY_COMMAND).some((optionNames) => optionNames.has(optionName));
-}
-function findFirstPositionalIndex(argv) {
-  const positionalIndexes = collectPositionalIndexes(argv);
-  return positionalIndexes[0] ?? -1;
+
+// bin/argv-walker.js
+function normalizeOptionSet(values) {
+  return values instanceof Set ? values : new Set(values);
 }
-function collectPositionalIndexes(argv) {
+function collectPositionalIndexes(argv, metadata) {
+  const longValueOptionSet = normalizeOptionSet(metadata.longValueOptions);
+  const shortValueOptionSet = normalizeOptionSet(metadata.shortValueOptions);
   const positionalIndexes = [];
   for (let index = 0;index < argv.length; index += 1) {
     const arg = argv[index];
@@ -2060,37 +2406,67 @@ function collectPositionalIndexes(argv) {
       if (arg.includes("=")) {
         continue;
       }
-      if (isLongOptionValueConsumer(arg.slice(2))) {
+      const next = argv[index + 1];
+      if (longValueOptionSet.has(arg) && next && !next.startsWith("-")) {
         index += 1;
       }
       continue;
     }
-    if (arg.length === 2 && SHORT_OPTION_NAMES_WITH_VALUES.has(arg.slice(1))) {
+    if (arg.length === 2 && shortValueOptionSet.has(arg) && argv[index + 1] && !argv[index + 1].startsWith("-")) {
       index += 1;
     }
   }
   return positionalIndexes;
 }
-var WP_TYPIA_FUTURE_COMMAND_TREE = [
+function findFirstPositionalIndex(argv, metadata) {
+  const positionalIndexes = collectPositionalIndexes(argv, metadata);
+  return positionalIndexes[0] ?? -1;
+}
+
+// src/command-registry.ts
+var WP_TYPIA_CANONICAL_CREATE_USAGE = "wp-typia create <project-dir>";
+var WP_TYPIA_POSITIONAL_ALIAS_USAGE = "wp-typia <project-dir>";
+var WP_TYPIA_CANONICAL_MIGRATE_USAGE = "wp-typia migrate <subcommand>";
+var WP_TYPIA_COMMAND_REGISTRY = [
   {
+    commandTree: true,
     description: "Scaffold a new wp-typia project.",
-    name: "create"
+    interactiveRuntime: true,
+    name: "create",
+    nodeFallback: true,
+    optionGroups: ["create"],
+    requiresBunRuntime: false
   },
   {
-    description: "Preview the minimum retrofit plan for an existing project.",
-    name: "init"
+    commandTree: true,
+    description: "Preview or apply the minimum retrofit plan for an existing project.",
+    name: "init",
+    nodeFallback: true,
+    optionGroups: ["init"],
+    requiresBunRuntime: false
   },
   {
+    commandTree: true,
     description: "Run the common generated-project sync workflow.",
     name: "sync",
+    nodeFallback: true,
+    optionGroups: ["sync"],
+    requiresBunRuntime: false,
     subcommands: ["ai"]
   },
   {
+    commandTree: true,
     description: "Extend an official wp-typia workspace.",
+    interactiveRuntime: true,
     name: "add",
+    nodeFallback: true,
+    optionGroups: ["add"],
+    requiresBunRuntime: false,
     subcommands: [
       "block",
       "variation",
+      "style",
+      "transform",
       "pattern",
       "binding-source",
       "rest-resource",
@@ -2099,8 +2475,13 @@ var WP_TYPIA_FUTURE_COMMAND_TREE = [
     ]
   },
   {
+    commandTree: true,
     description: "Run migration workflows.",
+    interactiveRuntime: true,
     name: "migrate",
+    nodeFallback: true,
+    optionGroups: ["migrate"],
+    requiresBunRuntime: false,
     subcommands: [
       "init",
       "snapshot",
@@ -2115,25 +2496,99 @@ var WP_TYPIA_FUTURE_COMMAND_TREE = [
     ]
   },
   {
+    commandTree: true,
     description: "Inspect scaffold templates.",
     name: "templates",
+    nodeFallback: true,
+    optionGroups: ["templates"],
+    requiresBunRuntime: false,
     subcommands: ["list", "inspect"]
   },
   {
+    commandTree: true,
     description: "Run repository and project diagnostics.",
-    name: "doctor"
+    name: "doctor",
+    nodeFallback: true,
+    optionGroups: ["doctor"],
+    requiresBunRuntime: false
   },
   {
+    commandTree: true,
     description: "Inspect or sync schema-driven MCP metadata.",
     name: "mcp",
+    nodeFallback: false,
+    optionGroups: [],
+    requiresBunRuntime: true,
     subcommands: ["list", "sync"]
+  },
+  {
+    commandTree: false,
+    name: "help",
+    nodeFallback: true,
+    optionGroups: [],
+    requiresBunRuntime: false
+  },
+  {
+    commandTree: false,
+    name: "version",
+    nodeFallback: true,
+    optionGroups: [],
+    requiresBunRuntime: false
+  },
+  {
+    commandTree: false,
+    name: "skills",
+    nodeFallback: false,
+    optionGroups: [],
+    requiresBunRuntime: true
+  },
+  {
+    commandTree: false,
+    name: "completions",
+    nodeFallback: false,
+    optionGroups: [],
+    requiresBunRuntime: true
+  },
+  {
+    commandTree: false,
+    name: "complete",
+    nodeFallback: false,
+    optionGroups: [],
+    requiresBunRuntime: true
   }
 ];
+var WP_TYPIA_RESERVED_TOP_LEVEL_COMMAND_NAMES = WP_TYPIA_COMMAND_REGISTRY.map((command) => command.name);
+var WP_TYPIA_NODE_FALLBACK_TOP_LEVEL_COMMAND_NAMES = WP_TYPIA_COMMAND_REGISTRY.filter((command) => command.nodeFallback).map((command) => command.name);
+var WP_TYPIA_INTERACTIVE_RUNTIME_TOP_LEVEL_COMMAND_NAMES = WP_TYPIA_COMMAND_REGISTRY.filter((command) => ("interactiveRuntime" in command) && command.interactiveRuntime).map((command) => command.name);
+var WP_TYPIA_TOP_LEVEL_COMMAND_NAMES = WP_TYPIA_COMMAND_REGISTRY.filter((command) => command.commandTree).map((command) => command.name);
+var WP_TYPIA_BUN_REQUIRED_TOP_LEVEL_COMMAND_NAMES = WP_TYPIA_COMMAND_REGISTRY.filter((command) => command.requiresBunRuntime).map((command) => command.name);
+var WP_TYPIA_FUTURE_COMMAND_TREE = WP_TYPIA_COMMAND_REGISTRY.filter((command) => command.commandTree).map((command) => ({
+  description: command.description,
+  name: command.name,
+  subcommands: "subcommands" in command ? command.subcommands : undefined
+}));
+var commandOptionGroupNamesByTopLevelCommand = {};
+for (const command of WP_TYPIA_COMMAND_REGISTRY) {
+  commandOptionGroupNamesByTopLevelCommand[command.name] = command.optionGroups;
+}
+var WP_TYPIA_COMMAND_OPTION_GROUP_NAMES_BY_TOP_LEVEL_COMMAND = commandOptionGroupNamesByTopLevelCommand;
+// src/command-contract.ts
+var SHARED_OPTION_PARSER = buildCommandOptionParser(ALL_COMMAND_OPTION_METADATA);
+var STRING_OPTION_NAMES_BY_GROUP = Object.fromEntries(Object.entries(COMMAND_OPTION_METADATA_BY_GROUP).map(([groupName, metadata]) => [
+  groupName,
+  new Set(collectOptionNamesByType(metadata, "string"))
+]));
+var STRING_OPTION_NAMES_BY_COMMAND = Object.fromEntries(WP_TYPIA_RESERVED_TOP_LEVEL_COMMAND_NAMES.map((commandName) => [
+  commandName,
+  new Set(WP_TYPIA_COMMAND_OPTION_GROUP_NAMES_BY_TOP_LEVEL_COMMAND[commandName].flatMap((groupName) => Array.from(STRING_OPTION_NAMES_BY_GROUP[groupName])))
+]));
+var GLOBAL_STRING_OPTION_NAMES = new Set(collectOptionNamesByType(GLOBAL_OPTION_METADATA, "string"));
+var SHORT_OPTION_NAMES_WITH_VALUES = new Set([...SHARED_OPTION_PARSER.shortFlagMap.entries()].filter(([, option]) => option.type === "string").map(([short]) => short));
 function isReservedTopLevelCommandName(value) {
   return WP_TYPIA_RESERVED_TOP_LEVEL_COMMAND_NAMES.includes(value);
 }
 function assertStringOptionValues(argv) {
-  const firstPositionalIndex = findFirstPositionalIndex(argv);
+  const firstPositionalIndex = findFirstPositionalIndex(argv, COMMAND_ROUTING_METADATA);
   if (firstPositionalIndex === -1) {
     return;
   }
@@ -2199,7 +2654,7 @@ function assertPositionalAliasProjectDir(projectDir) {
   }
 }
 function normalizeWpTypiaArgv(argv) {
-  const positionalIndexes = collectPositionalIndexes(argv);
+  const positionalIndexes = collectPositionalIndexes(argv, COMMAND_ROUTING_METADATA);
   const firstPositionalIndex = positionalIndexes[0] ?? -1;
   if (firstPositionalIndex === -1) {
     return argv;
@@ -2230,13 +2685,14 @@ function normalizeWpTypiaArgv(argv) {
 }
 
 // src/node-cli.ts
-var NODE_FALLBACK_OPTION_PARSER = buildCommandOptionParser(GLOBAL_OPTION_METADATA, CREATE_OPTION_METADATA, ADD_OPTION_METADATA, MIGRATE_OPTION_METADATA, SYNC_OPTION_METADATA, TEMPLATES_OPTION_METADATA);
+var NODE_FALLBACK_OPTION_PARSER = buildCommandOptionParser(ALL_COMMAND_OPTION_METADATA);
 var NODE_FALLBACK_BOOLEAN_OPTION_NAMES = ["help", "version"];
 var STANDALONE_GUIDANCE_LINE = "Prefer not to install Bun? Use the standalone wp-typia binary from the GitHub release assets.";
 var NODE_FALLBACK_RUNTIME_SUMMARY_LINES = [
   "Runtime: Node fallback",
   "Human-readable fallback for common non-interactive create/init/add/migrate flows, doctor, sync, templates, --help, and --version when Bun is unavailable.",
-  `Install Bun 1.3.11+ or use \`bunx wp-typia ...\` for the full Bunli/OpenTUI runtime and Bun-only command surfaces such as \`skills\`, \`completions\`, and \`mcp\`. ${STANDALONE_GUIDANCE_LINE}`
+  `Install Bun 1.3.11+ or use \`bunx wp-typia ...\` for the full Bunli/OpenTUI runtime and Bun-only command surfaces such as \`skills\`, \`completions\`, and \`mcp\`. ${STANDALONE_GUIDANCE_LINE}`,
+  "Output markers: WP_TYPIA_ASCII=1 forces ASCII markers, WP_TYPIA_ASCII=0 opts back into Unicode markers, and non-empty NO_COLOR requests ASCII markers when WP_TYPIA_ASCII is unset."
 ];
 function printLine(line = "") {
   console.log(line);
@@ -2258,44 +2714,24 @@ function hasFlagBeforeTerminator(argv, flag) {
   return false;
 }
 function parseGlobalFlags(argv) {
-  const nextArgv = [];
-  const flags = {};
-  for (let index = 0;index < argv.length; index += 1) {
-    const arg = argv[index];
-    if (!arg) {
-      continue;
-    }
-    if (arg === "--") {
-      nextArgv.push(...argv.slice(index));
-      break;
-    }
-    if (arg === "--format" || arg === "--id") {
-      const next = argv[index + 1];
-      if (!next || next.startsWith("-")) {
-        throw new Error(`\`${arg}\` requires a value.`);
-      }
-      if (arg === "--format") {
-        flags.format = next;
-      } else {
-        flags.id = next;
+  try {
+    const { argv: nextArgv, flags } = extractKnownOptionValuesFromArgv(argv, {
+      optionNames: ["format", "id"],
+      parser: NODE_FALLBACK_OPTION_PARSER
+    });
+    return {
+      argv: nextArgv,
+      flags: {
+        format: typeof flags.format === "string" ? flags.format : undefined,
+        id: typeof flags.id === "string" ? flags.id : undefined
       }
-      index += 1;
-      continue;
-    }
-    if (arg.startsWith("--format=")) {
-      flags.format = arg.slice("--format=".length);
-      continue;
-    }
-    if (arg.startsWith("--id=")) {
-      flags.id = arg.slice("--id=".length);
-      continue;
+    };
+  } catch (error) {
+    if (error instanceof Error && /\`--format\` requires a value\.|\`--id\` requires a value\./.test(error.message)) {
+      throw createCliDiagnosticCodeError5(CLI_DIAGNOSTIC_CODES5.MISSING_ARGUMENT, error.message);
     }
-    nextArgv.push(arg);
+    throw error;
   }
-  return {
-    argv: nextArgv,
-    flags
-  };
 }
 async function applyNodeFallbackConfigDefaults(command, subcommand, flags, configOverridePath, cwd) {
   let config = await loadWpTypiaUserConfig(cwd);
@@ -2373,7 +2809,10 @@ function renderInitHelp() {
     "",
     ...NODE_FALLBACK_RUNTIME_SUMMARY_LINES,
     "",
-    "Preview-only retrofit planner for existing WordPress block or plugin projects. No files are written yet."
+    "Preview-by-default retrofit planner for existing WordPress block or plugin projects. Re-run with --apply to write package.json updates and helper scripts.",
+    "",
+    "Supported flags:",
+    ...formatNodeFallbackOptionHelp(INIT_OPTION_METADATA)
   ]);
 }
 function renderAddHelp() {
@@ -2408,6 +2847,27 @@ function renderSyncHelp() {
     ...formatNodeFallbackOptionHelp(SYNC_OPTION_METADATA)
   ]);
 }
+function renderDoctorHelp() {
+  printBlock2([
+    "Usage: wp-typia doctor [--format json]",
+    "",
+    ...NODE_FALLBACK_RUNTIME_SUMMARY_LINES,
+    "",
+    "Runs read-only environment readiness checks. Official wp-typia workspace roots also get inventory, source-tree drift, iframe/API v3 compatibility, and shared convention checks.",
+    "",
+    "Supported flags:",
+    ...formatNodeFallbackOptionHelp(DOCTOR_OPTION_METADATA)
+  ]);
+}
+var NODE_FALLBACK_HELP_RENDERERS = {
+  add: renderAddHelp,
+  create: renderCreateHelp,
+  doctor: renderDoctorHelp,
+  init: renderInitHelp,
+  migrate: renderMigrateHelp,
+  sync: renderSyncHelp,
+  templates: renderTemplatesHelp
+};
 function renderVersion(options = {}) {
   if (options.format === "json") {
     printLine(JSON.stringify({
@@ -2432,7 +2892,7 @@ function renderTemplatesJson(flags, subcommand) {
   const templateId = flags.id;
   if (!templateId) {
     throw createCliCommandError({
-      code: CLI_DIAGNOSTIC_CODES.MISSING_ARGUMENT,
+      code: CLI_DIAGNOSTIC_CODES5.MISSING_ARGUMENT,
       command: "templates",
       detailLines: ["`wp-typia templates inspect` requires <template-id>."]
     });
@@ -2440,7 +2900,7 @@ function renderTemplatesJson(flags, subcommand) {
   const template = getTemplateById(templateId);
   if (!template) {
     throw createCliCommandError({
-      code: CLI_DIAGNOSTIC_CODES.INVALID_ARGUMENT,
+      code: CLI_DIAGNOSTIC_CODES5.INVALID_ARGUMENT,
       command: "templates",
       detailLines: [`Unknown template "${templateId}".`]
     });
@@ -2451,7 +2911,7 @@ function renderTemplatesJson(flags, subcommand) {
 }
 function renderUnsupportedCommand(command) {
   throw createCliCommandError({
-    code: CLI_DIAGNOSTIC_CODES.UNSUPPORTED_COMMAND,
+    code: CLI_DIAGNOSTIC_CODES5.UNSUPPORTED_COMMAND,
     command,
     detailLines: [
       [
@@ -2477,118 +2937,24 @@ async function renderDoctorJson() {
   }, null, 2));
   if (checks.some((check) => check.status === "fail")) {
     throw createCliCommandError2({
+      code: CLI_DIAGNOSTIC_CODES5.DOCTOR_CHECK_FAILED,
       command: "doctor",
       detailLines: getDoctorFailureDetailLines(checks),
       summary: "One or more doctor checks failed."
     });
   }
 }
-async function runNodeCli(argv = process.argv.slice(2)) {
-  const normalizedArgv = normalizeWpTypiaArgv(argv);
-  const { argv: argvWithoutConfigOverride, configOverridePath } = extractWpTypiaConfigOverride(normalizedArgv);
-  const { argv: cliArgv, flags } = parseGlobalFlags(argvWithoutConfigOverride);
-  const { flags: commandFlags, positionals } = parseArgv(cliArgv);
-  const rawMergedFlags = {
-    ...commandFlags,
-    ...flags
-  };
-  const [command, subcommand] = positionals;
-  const helpRequested = cliArgv.length === 0 || hasFlagBeforeTerminator(cliArgv, "--help") || command === "help";
-  const versionRequested = hasFlagBeforeTerminator(cliArgv, "--version") || command === "version";
-  if (helpRequested) {
-    if (command === "templates") {
-      renderTemplatesHelp();
-      return;
-    }
-    if (command === "create") {
-      renderCreateHelp();
-      return;
-    }
-    if (command === "init") {
-      renderInitHelp();
-      return;
-    }
-    if (command === "add") {
-      renderAddHelp();
-      return;
-    }
-    if (command === "migrate") {
-      renderMigrateHelp();
-      return;
-    }
-    if (command === "sync") {
-      renderSyncHelp();
-      return;
-    }
-    renderGeneralHelp();
-    return;
-  }
-  if (versionRequested) {
-    renderVersion({
-      format: typeof rawMergedFlags.format === "string" ? rawMergedFlags.format : undefined
-    });
-    return;
-  }
-  const mergedFlags = await applyNodeFallbackConfigDefaults(command, subcommand, rawMergedFlags, configOverridePath, process.cwd());
-  if (command === "templates") {
-    const templateId = typeof mergedFlags.id === "string" ? mergedFlags.id : positionals[2];
-    const resolvedSubcommand = templateId ? "inspect" : subcommand ?? "list";
-    if (resolvedSubcommand !== "list" && resolvedSubcommand !== "inspect") {
-      throw new Error(`Unknown templates subcommand "${resolvedSubcommand}". Expected list or inspect.`);
-    }
-    if (mergedFlags.format === "json") {
-      renderTemplatesJson({
-        format: mergedFlags.format,
-        id: templateId
-      }, resolvedSubcommand);
-      return;
-    }
-    await executeTemplatesCommand({
-      flags: {
-        id: templateId,
-        subcommand: resolvedSubcommand
-      }
-    });
-    return;
-  }
-  if (command === "create") {
-    const projectDir = positionals[1];
-    if (!projectDir) {
-      throw createCliCommandError({
-        command: "create",
-        detailLines: [
-          "`wp-typia create` requires <project-dir>.",
-          "`--dry-run` still needs a logical project directory name because wp-typia derives slugs, package names, and planned file paths from it."
-        ]
-      });
-    }
-    await executeCreateCommand({
-      cwd: process.cwd(),
-      flags: mergedFlags,
-      interactive: false,
-      projectDir
-    });
-    return;
-  }
-  if (command === "init") {
-    const plan = await executeInitCommand({
-      cwd: process.cwd(),
-      projectDir: positionals[1]
-    }, {
-      emitOutput: mergedFlags.format !== "json"
-    });
-    if (mergedFlags.format === "json") {
-      printLine(JSON.stringify({
-        init: plan
-      }, null, 2));
-    }
-    return;
-  }
-  if (command === "add") {
+var NODE_FALLBACK_COMMAND_DISPATCHERS = {
+  add: async ({
+    cwd,
+    mergedFlags,
+    positionals
+  }) => {
     if (!positionals[1]) {
       const { formatAddHelpText } = await import("@wp-typia/project-tools/cli-add");
       printLine(formatAddHelpText());
       throw createCliCommandError({
+        code: CLI_DIAGNOSTIC_CODES5.MISSING_ARGUMENT,
         command: "add",
         detailLines: [
           `\`wp-typia add\` requires <kind>. Usage: wp-typia add ${formatAddKindUsagePlaceholder()} ...`
@@ -2599,7 +2965,7 @@ async function runNodeCli(argv = process.argv.slice(2)) {
       let completion;
       try {
         completion = await executeAddCommand({
-          cwd: process.cwd(),
+          cwd,
           emitOutput: false,
           flags: mergedFlags,
           interactive: false,
@@ -2612,43 +2978,107 @@ async function runNodeCli(argv = process.argv.slice(2)) {
           error
         });
       }
-      printLine(JSON.stringify({
-        completion
-      }, null, 2));
+      printLine(JSON.stringify(buildStructuredCompletionSuccessPayload("add", completion, {
+        dryRun: Boolean(mergedFlags["dry-run"]),
+        kind: positionals[1],
+        name: positionals[2],
+        projectDir: extractCompletionProjectDir(completion) ?? cwd
+      }), null, 2));
       return;
     }
     await executeAddCommand({
-      cwd: process.cwd(),
+      cwd,
       flags: mergedFlags,
-      interactive: false,
+      interactive: undefined,
       kind: positionals[1],
       name: positionals[2]
     });
-    return;
-  }
-  if (command === "migrate") {
-    await executeMigrateCommand({
-      command: positionals[1],
-      cwd: process.cwd(),
-      flags: mergedFlags
-    });
-    return;
-  }
-  if (command === "doctor") {
+  },
+  create: async ({
+    cwd,
+    mergedFlags,
+    positionals
+  }) => {
+    const projectDir = positionals[1];
+    if (!projectDir) {
+      throw createCliCommandError({
+        code: CLI_DIAGNOSTIC_CODES5.MISSING_ARGUMENT,
+        command: "create",
+        detailLines: [
+          "`wp-typia create` requires <project-dir>.",
+          "`--dry-run` still needs a logical project directory name because wp-typia derives slugs, package names, and planned file paths from it."
+        ]
+      });
+    }
+    let completion;
+    try {
+      completion = await executeCreateCommand({
+        cwd,
+        emitOutput: mergedFlags.format !== "json",
+        flags: mergedFlags,
+        interactive: mergedFlags.format === "json" ? false : undefined,
+        projectDir
+      });
+    } catch (error) {
+      throw createCliCommandError({
+        command: "create",
+        error
+      });
+    }
+    if (mergedFlags.format === "json") {
+      printLine(JSON.stringify(buildStructuredCompletionSuccessPayload("create", completion, {
+        dryRun: Boolean(mergedFlags["dry-run"]),
+        projectDir: extractCompletionProjectDir(completion) ?? projectDir,
+        template: typeof mergedFlags.template === "string" ? mergedFlags.template : undefined
+      }), null, 2));
+    }
+  },
+  doctor: async ({ cwd, mergedFlags }) => {
     if (mergedFlags.format === "json") {
       await renderDoctorJson();
       return;
     }
-    await executeDoctorCommand(process.cwd());
-    return;
-  }
-  if (command === "sync") {
+    await executeDoctorCommand(cwd);
+  },
+  init: async ({
+    cwd,
+    mergedFlags,
+    positionals
+  }) => {
+    const plan = await executeInitCommand({
+      apply: Boolean(mergedFlags.apply),
+      cwd,
+      packageManager: typeof mergedFlags["package-manager"] === "string" ? mergedFlags["package-manager"] : undefined,
+      projectDir: positionals[1]
+    }, {
+      emitOutput: mergedFlags.format !== "json"
+    });
+    if (mergedFlags.format === "json") {
+      printLine(JSON.stringify(buildStructuredInitSuccessPayload(plan), null, 2));
+    }
+  },
+  migrate: async ({
+    cwd,
+    mergedFlags,
+    positionals
+  }) => {
+    await executeMigrateCommand({
+      command: positionals[1],
+      cwd,
+      flags: mergedFlags
+    });
+  },
+  sync: async ({
+    cwd,
+    mergedFlags,
+    positionals
+  }) => {
     try {
       const syncTarget = resolveSyncExecutionTarget(positionals[1]);
       const sync = await executeSyncCommand({
         captureOutput: mergedFlags.format === "json" && !Boolean(mergedFlags["dry-run"]),
         check: Boolean(mergedFlags.check),
-        cwd: process.cwd(),
+        cwd,
         dryRun: Boolean(mergedFlags["dry-run"]),
         target: syncTarget
       });
@@ -2673,6 +3103,83 @@ async function runNodeCli(argv = process.argv.slice(2)) {
         error
       });
     }
+  },
+  templates: async ({
+    mergedFlags,
+    positionals
+  }) => {
+    const subcommand = positionals[1];
+    const templateId = typeof mergedFlags.id === "string" ? mergedFlags.id : positionals[2];
+    const resolvedSubcommand = templateId ? "inspect" : subcommand ?? "list";
+    if (resolvedSubcommand !== "list" && resolvedSubcommand !== "inspect") {
+      throw createCliCommandError({
+        code: CLI_DIAGNOSTIC_CODES5.INVALID_COMMAND,
+        command: "templates",
+        detailLines: [
+          `Unknown templates subcommand "${resolvedSubcommand}". Expected list or inspect.`
+        ]
+      });
+    }
+    if (mergedFlags.format === "json") {
+      renderTemplatesJson({
+        format: mergedFlags.format,
+        id: templateId
+      }, resolvedSubcommand);
+      return;
+    }
+    await executeTemplatesCommand({
+      flags: {
+        id: templateId,
+        subcommand: resolvedSubcommand
+      }
+    });
+  }
+};
+async function runNodeCli(argv = process.argv.slice(2)) {
+  const normalizedArgv = normalizeWpTypiaArgv(argv);
+  const { argv: argvWithoutConfigOverride, configOverridePath } = extractWpTypiaConfigOverride(normalizedArgv);
+  const { argv: cliArgv, flags } = parseGlobalFlags(argvWithoutConfigOverride);
+  const { flags: commandFlags, positionals } = parseArgv(cliArgv);
+  const rawMergedFlags = {
+    ...commandFlags,
+    ...flags
+  };
+  const [command, subcommand] = positionals;
+  const helpRequested = cliArgv.length === 0 || hasFlagBeforeTerminator(cliArgv, "--help") || command === "help";
+  const helpTarget = command === "help" ? subcommand : command;
+  const versionRequested = hasFlagBeforeTerminator(cliArgv, "--version") || command === "version";
+  if (helpRequested) {
+    if (helpTarget) {
+      const helpRenderer = NODE_FALLBACK_HELP_RENDERERS[helpTarget];
+      if (helpRenderer) {
+        helpRenderer();
+        return;
+      }
+      if (helpTarget === "help" || helpTarget === "version") {
+        renderGeneralHelp();
+        return;
+      }
+    } else {
+      renderGeneralHelp();
+      return;
+    }
+    renderGeneralHelp();
+    return;
+  }
+  if (versionRequested) {
+    renderVersion({
+      format: typeof rawMergedFlags.format === "string" ? rawMergedFlags.format : undefined
+    });
+    return;
+  }
+  const mergedFlags = await applyNodeFallbackConfigDefaults(command, subcommand, rawMergedFlags, configOverridePath, process.cwd());
+  const commandDispatcher = command && NODE_FALLBACK_COMMAND_DISPATCHERS[command];
+  if (commandDispatcher) {
+    await commandDispatcher({
+      cwd: process.cwd(),
+      mergedFlags,
+      positionals
+    });
     return;
   }
   renderUnsupportedCommand(command ?? "(missing)");
@@ -2707,4 +3214,4 @@ export {
   hasFlagBeforeTerminator
 };
 
-//# debugId=A072E3D67E76AD4064756E2164756E21
+//# debugId=9D8430CB181D13B964756E2164756E21